@Test public void testFromNonAtomicAndNonComposite() throws Exception { ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); BatchTableEnvironment tableEnv = TableEnvironment.getTableEnvironment(env, config()); List<Either<String, Integer>> data = new ArrayList<>(); data.add(new Either.Left<>("Hello")); data.add(new Either.Right<>(42)); data.add(new Either.Left<>("World")); Table table = tableEnv .fromDataSet( env.fromCollection( data, TypeInformation.of(new TypeHint<Either<String, Integer>>() { }) ), "either") .select("either"); DataSet<Row> ds = tableEnv.toDataSet(table, Row.class); List<Row> results = ds.collect(); String expected = "Left(Hello)\n" + "Left(World)\n" + "Right(42)\n"; compareResultAsText(results, expected); }
/** * Utility function for {@link EitherSerializer} to support object reuse. * * To support object reuse both subclasses of Either contain a reference to * an instance of the other type. This method provides access to and * initializes the cross-reference. * * @param input container for Left or Right value * @param leftSerializer for creating an instance of the left type * @param <L> * the type of Left * @param <R> * the type of Right * @return input if Left type else input's Left reference */ @Internal public static <L, R> Left<L, R> obtainLeft(Either<L, R> input, TypeSerializer<L> leftSerializer) { if (input.isLeft()) { return (Left<L, R>) input; } else { Right<L, R> right = (Right<L, R>) input; if (right.left == null) { right.left = Left.of(leftSerializer.createInstance()); right.left.right = right; } return right.left; } }
/** * Utility function for {@link EitherSerializer} to support object reuse. * * To support object reuse both subclasses of Either contain a reference to * an instance of the other type. This method provides access to and * initializes the cross-reference. * * @param input container for Left or Right value * @param leftSerializer for creating an instance of the left type * @param <L> * the type of Left * @param <R> * the type of Right * @return input if Left type else input's Left reference */ @Internal public static <L, R> Left<L, R> obtainLeft(Either<L, R> input, TypeSerializer<L> leftSerializer) { if (input.isLeft()) { return (Left<L, R>) input; } else { Right<L, R> right = (Right<L, R>) input; if (right.left == null) { right.left = Left.of(leftSerializer.createInstance()); right.left.right = right; } return right.left; } }
@Override public Either<L, R> deserialize(Either<L, R> reuse, DataInputView source) throws IOException { boolean isLeft = source.readBoolean(); if (isLeft) { Left<L, R> to = Either.obtainLeft(reuse, leftSerializer); L left = leftSerializer.deserialize(to.left(), source); to.setValue(left); return to; } else { Right<L, R> to = Either.obtainRight(reuse, rightSerializer); R right = rightSerializer.deserialize(to.right(), source); to.setValue(right); return to; } }
@Override public Either<L, R> deserialize(Either<L, R> reuse, DataInputView source) throws IOException { boolean isLeft = source.readBoolean(); if (isLeft) { Left<L, R> to = Either.obtainLeft(reuse, leftSerializer); L left = leftSerializer.deserialize(to.left(), source); to.setValue(left); return to; } else { Right<L, R> to = Either.obtainRight(reuse, rightSerializer); R right = rightSerializer.deserialize(to.right(), source); to.setValue(right); return to; } }
@Override public Either<L, R> copy(Either<L, R> from, Either<L, R> reuse) { if (from.isLeft()) { Left<L, R> to = Either.obtainLeft(reuse, leftSerializer); L left = leftSerializer.copy(from.left(), to.left()); to.setValue(left); return to; } else { Right<L, R> to = Either.obtainRight(reuse, rightSerializer); R right = rightSerializer.copy(from.right(), to.right()); to.setValue(right); return to; } }
@Override public Either<L, R> copy(Either<L, R> from, Either<L, R> reuse) { if (from.isLeft()) { Left<L, R> to = Either.obtainLeft(reuse, leftSerializer); L left = leftSerializer.copy(from.left(), to.left()); to.setValue(left); return to; } else { Right<L, R> to = Either.obtainRight(reuse, rightSerializer); R right = rightSerializer.copy(from.right(), to.right()); to.setValue(right); return to; } }
public void setVertexGroupValue(VGV vertexGroupValue) { if (vertexGroupValue == null) { f2 = nullValue; } else { f2 = new Either.Left<>(vertexGroupValue); } }
public void setVertexGroupValue(VGV vertexGroupValue) { if (vertexGroupValue == null) { f2 = nullValue; } else { f2 = new Either.Left<>(vertexGroupValue); } }
/** * Creates a left value of {@link Either} * */ public static <L, R> Left<L, R> of(L left) { return new Left<L, R>(left); } }
/** * Create a Left value of Either */ public static <L, R> Either<L, R> Left(L value) { return new Left<L, R>(value); }
public void setVertexGroupValue(VGV vertexGroupValue) { if (vertexGroupValue == null) { f2 = nullValue; } else { f2 = new Either.Left<>(vertexGroupValue); } }
/** * Create a Left value of Either */ public static <L, R> Either<L, R> Left(L value) { return new Left<L, R>(value); }
/** * Creates a left value of {@link Either} * */ public static <L, R> Left<L, R> of(L left) { return new Left<L, R>(left); } }
/** * Utility function for {@link EitherSerializer} to support object reuse. * * To support object reuse both subclasses of Either contain a reference to * an instance of the other type. This method provides access to and * initializes the cross-reference. * * @param input container for Left or Right value * @param leftSerializer for creating an instance of the left type * @param <L> * the type of Left * @param <R> * the type of Right * @return input if Left type else input's Left reference */ @Internal public static <L, R> Left<L, R> obtainLeft(Either<L, R> input, TypeSerializer<L> leftSerializer) { if (input.isLeft()) { return (Left<L, R>) input; } else { Right<L, R> right = (Right<L, R>) input; if (right.left == null) { right.left = Left.of(leftSerializer.createInstance()); right.left.right = right; } return right.left; } }
@SuppressWarnings("unchecked") @Test public void testEitherWithTuple() { Either<Tuple2<Long, Long>, Double>[] testData = new Either[] { Either.Left(new Tuple2<>(2L, 9L)), new Left<>(new Tuple2<>(Long.MIN_VALUE, Long.MAX_VALUE)), new Right<>(32.0), Right(Double.MIN_VALUE), Right(Double.MAX_VALUE)}; EitherTypeInfo<Tuple2<Long, Long>, Double> eitherTypeInfo = (EitherTypeInfo<Tuple2<Long, Long>, Double>) new EitherTypeInfo<Tuple2<Long, Long>, Double>( new TupleTypeInfo<Tuple2<Long, Long>>(BasicTypeInfo.LONG_TYPE_INFO, BasicTypeInfo.LONG_TYPE_INFO), BasicTypeInfo.DOUBLE_TYPE_INFO); EitherSerializer<Tuple2<Long, Long>, Double> eitherSerializer = (EitherSerializer<Tuple2<Long, Long>, Double>) eitherTypeInfo.createSerializer(new ExecutionConfig()); SerializerTestInstance<Either<Tuple2<Long, Long>, Double>> testInstance = new EitherSerializerTestInstance<Either<Tuple2<Long, Long>, Double>>( eitherSerializer, eitherTypeInfo.getTypeClass(), -1, testData); testInstance.testAll(); }
@Test public void testStringValueDoubleValueEither() { @SuppressWarnings("unchecked") Either<StringValue, DoubleValue>[] testData = new Either[] { Left(new StringValue("banana")), Left.of(new StringValue("apple")), new Left(new StringValue("")), Right(new DoubleValue(32.0)), Right.of(new DoubleValue(Double.MIN_VALUE)), new Right(new DoubleValue(Double.MAX_VALUE))}; EitherTypeInfo<StringValue, DoubleValue> eitherTypeInfo = new EitherTypeInfo<>( ValueTypeInfo.STRING_VALUE_TYPE_INFO, ValueTypeInfo.DOUBLE_VALUE_TYPE_INFO); EitherSerializer<StringValue, DoubleValue> eitherSerializer = (EitherSerializer<StringValue, DoubleValue>) eitherTypeInfo.createSerializer(new ExecutionConfig()); SerializerTestInstance<Either<StringValue, DoubleValue>> testInstance = new EitherSerializerTestInstance<>(eitherSerializer, eitherTypeInfo.getTypeClass(), -1, testData); testInstance.testAll(); }
@Test public void testEitherWithTupleValues() { @SuppressWarnings("unchecked") Either<Tuple2<LongValue, LongValue>, DoubleValue>[] testData = new Either[] { Left(new Tuple2<>(new LongValue(2L), new LongValue(9L))), new Left<>(new Tuple2<>(new LongValue(Long.MIN_VALUE), new LongValue(Long.MAX_VALUE))), new Right<>(new DoubleValue(32.0)), Right(new DoubleValue(Double.MIN_VALUE)), Right(new DoubleValue(Double.MAX_VALUE))}; EitherTypeInfo<Tuple2<LongValue, LongValue>, DoubleValue> eitherTypeInfo = new EitherTypeInfo<>( new TupleTypeInfo<Tuple2<LongValue, LongValue>>(ValueTypeInfo.LONG_VALUE_TYPE_INFO, ValueTypeInfo.LONG_VALUE_TYPE_INFO), ValueTypeInfo.DOUBLE_VALUE_TYPE_INFO); EitherSerializer<Tuple2<LongValue, LongValue>, DoubleValue> eitherSerializer = (EitherSerializer<Tuple2<LongValue, LongValue>, DoubleValue>) eitherTypeInfo.createSerializer(new ExecutionConfig()); SerializerTestInstance<Either<Tuple2<LongValue, LongValue>, DoubleValue>> testInstance = new EitherSerializerTestInstance<>(eitherSerializer, eitherTypeInfo.getTypeClass(), -1, testData); testInstance.testAll(); }
@Override public Either<L, R> deserialize(Either<L, R> reuse, DataInputView source) throws IOException { boolean isLeft = source.readBoolean(); if (isLeft) { Left<L, R> to = Either.obtainLeft(reuse, leftSerializer); L left = leftSerializer.deserialize(to.left(), source); to.setValue(left); return to; } else { Right<L, R> to = Either.obtainRight(reuse, rightSerializer); R right = rightSerializer.deserialize(to.right(), source); to.setValue(right); return to; } }