@Override protected EitherSerializer createOuterSerializerWithNestedSerializers(TypeSerializer<?>[] nestedSerializers) { return new EitherSerializer<>(nestedSerializers[0], nestedSerializers[1]); }
@SuppressWarnings("unchecked") @Override public boolean equals(Object obj) { if (obj instanceof EitherSerializer) { EitherSerializer<L, R> other = (EitherSerializer<L, R>) obj; return other.canEqual(this) && leftSerializer.equals(other.leftSerializer) && rightSerializer.equals(other.rightSerializer); } else { return false; } }
@Override protected TypeSerializer<?>[] getNestedSerializers(EitherSerializer outerSerializer) { return new TypeSerializer<?>[]{ outerSerializer.getLeftSerializer(), outerSerializer.getRightSerializer() }; } }
@Test public void testSerializeIndividually() throws IOException { EitherTypeInfo<LongValue, DoubleValue> eitherTypeInfo = new EitherTypeInfo<>( ValueTypeInfo.LONG_VALUE_TYPE_INFO, ValueTypeInfo.DOUBLE_VALUE_TYPE_INFO); EitherSerializer<LongValue, DoubleValue> eitherSerializer = (EitherSerializer<LongValue, DoubleValue>) eitherTypeInfo.createSerializer(new ExecutionConfig()); LongValue lv = new LongValue(); DoubleValue dv = new DoubleValue(); Either<LongValue, DoubleValue> left = Left(lv); Either<LongValue, DoubleValue> right = Right(dv); TestOutputView out = new TestOutputView(); eitherSerializer.serialize(left, out); eitherSerializer.serialize(right, out); eitherSerializer.serialize(left, out); TestInputView in = out.getInputView(); // the first deserialization creates a new instance of Left Either<LongValue, DoubleValue> copy0 = eitherSerializer.deserialize(right, in); // then the cross-references are used for future copies Either<LongValue, DoubleValue> copy1 = eitherSerializer.deserialize(copy0, in); Either<LongValue, DoubleValue> copy2 = eitherSerializer.deserialize(copy1, in); // validate reference equality assertSame(right, copy1); assertSame(copy0, copy2); // validate reference equality of contained objects assertSame(right.right(), copy1.right()); assertSame(copy0.left(), copy2.left()); }
@Test public void testEitherWithObjectReuse() { EitherTypeInfo<LongValue, DoubleValue> eitherTypeInfo = new EitherTypeInfo<>( ValueTypeInfo.LONG_VALUE_TYPE_INFO, ValueTypeInfo.DOUBLE_VALUE_TYPE_INFO); EitherSerializer<LongValue, DoubleValue> eitherSerializer = (EitherSerializer<LongValue, DoubleValue>) eitherTypeInfo.createSerializer(new ExecutionConfig()); LongValue lv = new LongValue(); DoubleValue dv = new DoubleValue(); Either<LongValue, DoubleValue> left = Left(lv); Either<LongValue, DoubleValue> right = Right(dv); // the first copy creates a new instance of Left Either<LongValue, DoubleValue> copy0 = eitherSerializer.copy(left, right); // then the cross-references are used for future copies Either<LongValue, DoubleValue> copy1 = eitherSerializer.copy(right, copy0); Either<LongValue, DoubleValue> copy2 = eitherSerializer.copy(left, copy1); // validate reference equality assertSame(right, copy1); assertSame(copy0, copy2); // validate reference equality of contained objects assertSame(right.right(), copy1.right()); assertSame(copy0.left(), copy2.left()); }
@Override protected TypeSerializer<Either<String, Integer>> createSerializer() { return new EitherSerializer<>(StringSerializer.INSTANCE, IntSerializer.INSTANCE); }
@Override public TypeSerializerSchemaCompatibility<Either<L, R>> resolveSchemaCompatibility( TypeSerializer<Either<L, R>> newSerializer) { checkState(nestedSnapshot != null); if (newSerializer instanceof EitherSerializer) { EitherSerializer<L, R> serializer = (EitherSerializer<L, R>) newSerializer; return nestedSnapshot.resolveCompatibilityWithNested( TypeSerializerSchemaCompatibility.compatibleAsIs(), serializer.getLeftSerializer(), serializer.getRightSerializer()); } else { return TypeSerializerSchemaCompatibility.incompatible(); } } }
@SuppressWarnings("unchecked") @Override public boolean equals(Object obj) { if (obj instanceof EitherSerializer) { EitherSerializer<L, R> other = (EitherSerializer<L, R>) obj; return other.canEqual(this) && leftSerializer.equals(other.leftSerializer) && rightSerializer.equals(other.rightSerializer); } else { return false; } }
@Override public TypeSerializer<Either<L, R>> duplicate() { TypeSerializer<L> duplicateLeft = leftSerializer.duplicate(); TypeSerializer<R> duplicateRight = rightSerializer.duplicate(); if ((leftSerializer != duplicateLeft) || (rightSerializer != duplicateRight)) { // stateful return new EitherSerializer<L, R>(duplicateLeft, duplicateRight); } else { return this; } }
@SuppressWarnings("unchecked") private TypeSerializerSchemaCompatibility<Either<L, R>> checkJavaSerializerCompatibility( EitherSerializer<L, R> serializer) { TypeSerializer<L> leftSerializer = serializer.getLeftSerializer(); TypeSerializer<R> rightSerializer = serializer.getRightSerializer(); TypeSerializerSnapshot<L> leftSnapshot = (TypeSerializerSnapshot<L>) getNestedSerializersAndConfigs().get(0).f1; TypeSerializerSnapshot<R> rightSnapshot = (TypeSerializerSnapshot<R>) getNestedSerializersAndConfigs().get(1).f1; TypeSerializerSchemaCompatibility<?> leftCompatibility = leftSnapshot.resolveSchemaCompatibility(leftSerializer); TypeSerializerSchemaCompatibility<?> rightCompatibility = rightSnapshot.resolveSchemaCompatibility(rightSerializer); if (leftCompatibility.isCompatibleAsIs() && rightCompatibility.isCompatibleAsIs()) { return TypeSerializerSchemaCompatibility.compatibleAsIs(); } if (leftCompatibility.isCompatibleAfterMigration() && rightCompatibility.isCompatibleAfterMigration()) { return TypeSerializerSchemaCompatibility.compatibleAfterMigration(); } return TypeSerializerSchemaCompatibility.incompatible(); } }
@SuppressWarnings("unchecked") @Override public boolean equals(Object obj) { if (obj instanceof EitherSerializer) { EitherSerializer<L, R> other = (EitherSerializer<L, R>) obj; return other.canEqual(this) && leftSerializer.equals(other.leftSerializer) && rightSerializer.equals(other.rightSerializer); } else { return false; } }
@Override @PublicEvolving public TypeSerializer<Either<L, R>> createSerializer(ExecutionConfig config) { return new EitherSerializer<L, R>(leftType.createSerializer(config), rightType.createSerializer(config)); }
@Override public EitherSerializer<L, R> restoreSerializer() { checkState(nestedSnapshot != null); return new EitherSerializer<>( nestedSnapshot.getRestoredNestedSerializer(0), nestedSnapshot.getRestoredNestedSerializer(1)); }
@SuppressWarnings("unchecked") @Parameterized.Parameters(name = "Test Specification = {0}") public static Collection<TestSpecification<?>> testSpecifications() { final TestSpecifications testSpecifications = new TestSpecifications(MigrationVersion.v1_6, MigrationVersion.v1_7); testSpecifications.add( "either-serializer", EitherSerializer.class, JavaEitherSerializerSnapshot.class, () -> new EitherSerializer<>(StringSerializer.INSTANCE, IntSerializer.INSTANCE)); testSpecifications.add( "generic-array-serializer", GenericArraySerializer.class, GenericArraySerializerSnapshot.class, () -> new GenericArraySerializer<>(String.class, StringSerializer.INSTANCE)); return testSpecifications.get(); } }
@Override public TypeSerializer<Either<L, R>> duplicate() { TypeSerializer<L> duplicateLeft = leftSerializer.duplicate(); TypeSerializer<R> duplicateRight = rightSerializer.duplicate(); if ((leftSerializer != duplicateLeft) || (rightSerializer != duplicateRight)) { // stateful return new EitherSerializer<L, R>(duplicateLeft, duplicateRight); } else { return this; } }
@Override public TypeSerializer<Either<L, R>> duplicate() { TypeSerializer<L> duplicateLeft = leftSerializer.duplicate(); TypeSerializer<R> duplicateRight = rightSerializer.duplicate(); if ((leftSerializer != duplicateLeft) || (rightSerializer != duplicateRight)) { // stateful return new EitherSerializer<L, R>(duplicateLeft, duplicateRight); } else { return this; } }
@Override @PublicEvolving public TypeSerializer<Either<L, R>> createSerializer(ExecutionConfig config) { return new EitherSerializer<L, R>(leftType.createSerializer(config), rightType.createSerializer(config)); }
@Override @PublicEvolving public TypeSerializer<Either<L, R>> createSerializer(ExecutionConfig config) { return new EitherSerializer<L, R>(leftType.createSerializer(config), rightType.createSerializer(config)); }
@Override public TypeSerializer<Either<L, R>> restoreSerializer() { checkState(nestedSnapshot != null); return new EitherSerializer<>( nestedSnapshot.getRestoreSerializer(0), nestedSnapshot.getRestoreSerializer(1)); }
if (leftCompatResult.getConvertDeserializer() != null && rightCompatResult.getConvertDeserializer() != null) { return CompatibilityResult.requiresMigration( new EitherSerializer<>( new TypeDeserializerAdapter<>(leftCompatResult.getConvertDeserializer()), new TypeDeserializerAdapter<>(rightCompatResult.getConvertDeserializer())));