@Override @SuppressWarnings("unchecked") public void setInputType(TypeInformation<?> type, ExecutionConfig executionConfig) { this.typeSerializer = (TypeSerializer<T>) type.createSerializer(executionConfig); } }
@Override @PublicEvolving public TypeSerializer<Either<L, R>> createSerializer(ExecutionConfig config) { return new EitherSerializer<L, R>(leftType.createSerializer(config), rightType.createSerializer(config)); }
/** * Creates a new MessageAcknowledgingSourceBase for IDs of the given type. * * @param idTypeInfo The type information of the message ID type, used to create a serializer for the message IDs. */ protected MessageAcknowledgingSourceBase(TypeInformation<UId> idTypeInfo) { this.idSerializer = idTypeInfo.createSerializer(new ExecutionConfig()); }
public TypeSerializerInputFormat(TypeInformation<T> resultType) { this.resultType = resultType; // TODO: fix this shit this.serializer = resultType.createSerializer(new ExecutionConfig()); }
private TypeSerializer<?> createSubclassSerializer(Class<?> subclass) { TypeSerializer<?> serializer = TypeExtractor.createTypeInfo(subclass).createSerializer(executionConfig); if (serializer instanceof PojoSerializer) { PojoSerializer<?> subclassSerializer = (PojoSerializer<?>) serializer; subclassSerializer.copyBaseFieldOrder(this); } return serializer; }
@Override public TypeSerializer<Row> createSerializer(ExecutionConfig config) { int len = getArity(); TypeSerializer<?>[] fieldSerializers = new TypeSerializer[len]; for (int i = 0; i < len; i++) { fieldSerializers[i] = types[i].createSerializer(config); } return new RowSerializer(fieldSerializers); }
@SuppressWarnings("unchecked") @Override @PublicEvolving public TypeSerializer<T> createSerializer(ExecutionConfig executionConfig) { return (TypeSerializer<T>) new GenericArraySerializer<C>( componentInfo.getTypeClass(), componentInfo.createSerializer(executionConfig)); }
@Override public void open(Configuration parameters) throws Exception { for (AggregationFunction<Object> aggFunction : aggFunctions) { aggFunction.initializeAggregate(); } this.serializer = (TupleSerializerBase<T>) typeInfo.createSerializer(getRuntimeContext().getExecutionConfig()); }
public PojoSerializer<T> createPojoSerializer(ExecutionConfig config) { TypeSerializer<?>[] fieldSerializers = new TypeSerializer<?>[fields.length]; Field[] reflectiveFields = new Field[fields.length]; for (int i = 0; i < fields.length; i++) { fieldSerializers[i] = fields[i].getTypeInformation().createSerializer(config); reflectiveFields[i] = fields[i].getField(); } return new PojoSerializer<T>(getTypeClass(), fieldSerializers, reflectiveFields, config); }
public SumAggregator(int pos, TypeInformation<T> typeInfo, ExecutionConfig config) { fieldAccessor = FieldAccessorFactory.getAccessor(typeInfo, pos, config); adder = SumFunction.getForClass(fieldAccessor.getFieldType().getTypeClass()); if (typeInfo instanceof TupleTypeInfo) { isTuple = true; serializer = null; } else { isTuple = false; this.serializer = typeInfo.createSerializer(config); } }
public SumAggregator(String field, TypeInformation<T> typeInfo, ExecutionConfig config) { fieldAccessor = FieldAccessorFactory.getAccessor(typeInfo, field, config); adder = SumFunction.getForClass(fieldAccessor.getFieldType().getTypeClass()); if (typeInfo instanceof TupleTypeInfo) { isTuple = true; serializer = null; } else { isTuple = false; this.serializer = typeInfo.createSerializer(config); } }
public static TypeSerializer<Event> createTypeSerializer() { TypeInformation<Event> typeInformation = (TypeInformation<Event>) TypeExtractor.createTypeInfo(Event.class); return typeInformation.createSerializer(new ExecutionConfig()); } }
@Override protected TypeSerializer<TestUserClassBase> createSerializer() { // only register one of the three child classes, the third child class is NO POJO ExecutionConfig conf = new ExecutionConfig(); conf.registerPojoType(TestUserClass1.class); TypeSerializer<TestUserClassBase> serializer = type.createSerializer(conf); assert(serializer instanceof PojoSerializer); return serializer; }
@Override protected <T> TypeSerializer<T> createSerializer(Class<T> type) { ExecutionConfig conf = new ExecutionConfig(); conf.registerTypeWithKryoSerializer(LocalDate.class, LocalDateSerializer.class); TypeInformation<T> typeInfo = new GenericTypeInfo<T>(type); return typeInfo.createSerializer(conf); }
public TypeSerializerFormatTest(int numberOfTuples, long blockSize, int parallelism) { super(numberOfTuples, blockSize, parallelism); resultType = TypeExtractor.getForObject(getRecord(0)); serializer = resultType.createSerializer(new ExecutionConfig()); }
public KeyedOneInputStreamOperatorTestHarness( OneInputStreamOperator<IN, OUT> operator, final KeySelector<IN, K> keySelector, TypeInformation<K> keyType, int maxParallelism, int numSubtasks, int subtaskIndex) throws Exception { super(operator, maxParallelism, numSubtasks, subtaskIndex); ClosureCleaner.clean(keySelector, false); config.setStatePartitioner(0, keySelector); config.setStateKeySerializer(keyType.createSerializer(executionConfig)); }
public <K> void configureForKeyedStream( KeySelector<IN, K> keySelector, TypeInformation<K> keyType) { ClosureCleaner.clean(keySelector, false); streamConfig.setStatePartitioner(0, keySelector); streamConfig.setStateKeySerializer(keyType.createSerializer(executionConfig)); }
public KeyedOneInputStreamOperatorTestHarness( final OneInputStreamOperator<IN, OUT> operator, final KeySelector<IN, K> keySelector, final TypeInformation<K> keyType, final MockEnvironment environment) throws Exception { super(operator, environment); ClosureCleaner.clean(keySelector, false); config.setStatePartitioner(0, keySelector); config.setStateKeySerializer(keyType.createSerializer(executionConfig)); }
@Test public void testStringArray() { String[][] array = new String[][]{{null,"b"},{"c","d"},{"e","f"},{"g","h"},null}; TypeInformation<String[][]> ti = TypeExtractor.getForClass(String[][].class); SerializerTestInstance<String[][]> testInstance = new SerializerTestInstance<String[][]>(ti.createSerializer(new ExecutionConfig()), String[][].class, -1, array); testInstance.testAll(); }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testGenericObjectArrays() { MyGenericPojo<String>[][] array = (MyGenericPojo<String>[][]) new MyGenericPojo[][]{ { new MyGenericPojo<String>(new String[][]{{"a", "b"},{"c", "d"}}), null} }; TypeInformation<MyGenericPojo<String>[][]> ti = TypeInformation.of(new TypeHint<MyGenericPojo<String>[][]>(){}); SerializerTestInstance testInstance = new SerializerTestInstance(ti.createSerializer(new ExecutionConfig()), MyGenericPojo[][].class, -1, (Object) array); testInstance.testAll(); }