private static TypeSerializer[] duplicateFieldSerializers(TypeSerializer<Object>[] fieldSerializers) { TypeSerializer[] duplicatedSerializers = new TypeSerializer[fieldSerializers.length]; for (int index = 0; index < fieldSerializers.length; index++) { duplicatedSerializers[index] = fieldSerializers[index].duplicate(); assert duplicatedSerializers[index] != null; } return duplicatedSerializers; }
private GenericTypeComparator(GenericTypeComparator<T> toClone) { this.ascending = toClone.ascending; this.serializer = toClone.serializer.duplicate(); this.type = toClone.type; }
/** * Returns the {@link TypeSerializer} that can be used to serialize the value in the state. * Note that the serializer may initialized lazily and is only guaranteed to exist after * calling {@link #initializeSerializerUnlessSet(ExecutionConfig)}. */ public TypeSerializer<T> getSerializer() { if (serializer != null) { return serializer.duplicate(); } else { throw new IllegalStateException("Serializer not yet initialized."); } }
@Override public TypeSerializer<T> getSerializer() { if (this.serializer != null) { if (firstSerializer) { firstSerializer = false; return this.serializer; } else { return this.serializer.duplicate(); } } else { throw new RuntimeException("SerializerFactory has not been initialized from configuration."); } }
@Override public TypeSerializer<Map<K, V>> duplicate() { TypeSerializer<K> duplicateKeySerializer = keySerializer.duplicate(); TypeSerializer<V> duplicateValueSerializer = valueSerializer.duplicate(); return (duplicateKeySerializer == keySerializer) && (duplicateValueSerializer == valueSerializer) ? this : new MapSerializer<>(duplicateKeySerializer, duplicateValueSerializer); }
@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<TimerHeapInternalTimer<K, N>> duplicate() { final TypeSerializer<K> keySerializerDuplicate = keySerializer.duplicate(); final TypeSerializer<N> namespaceSerializerDuplicate = namespaceSerializer.duplicate(); if (keySerializerDuplicate == keySerializer && namespaceSerializerDuplicate == namespaceSerializer) { // all delegate serializers seem stateless, so this is also stateless. return this; } else { // at least one delegate serializer seems to be stateful, so we return a new instance. return new LegacyTimerSerializer<>(keySerializerDuplicate, namespaceSerializerDuplicate); } }
@Override public StreamElementSerializer<T> duplicate() { TypeSerializer<T> copy = typeSerializer.duplicate(); return (copy == typeSerializer) ? this : new StreamElementSerializer<T>(copy); }
@Override public LockableTypeSerializer<E> duplicate() { TypeSerializer<E> elementSerializerCopy = elementSerializer.duplicate(); return elementSerializerCopy == elementSerializer ? this : new LockableTypeSerializer<>(elementSerializerCopy); }
@Override public GenericArraySerializer<C> duplicate() { TypeSerializer<C> duplicateComponentSerializer = this.componentSerializer.duplicate(); if (duplicateComponentSerializer == this.componentSerializer) { // is not stateful, return ourselves return this; } else { return new GenericArraySerializer<C>(componentClass, duplicateComponentSerializer); } }
@Override public TypeSerializer<Row> duplicate() { TypeSerializer<?>[] duplicateFieldSerializers = new TypeSerializer[fieldSerializers.length]; for (int i = 0; i < fieldSerializers.length; i++) { duplicateFieldSerializers[i] = fieldSerializers[i].duplicate(); } return new RowSerializer(duplicateFieldSerializers); }
@Override public TypeSerializer<List<T>> duplicate() { TypeSerializer<T> duplicateElement = elementSerializer.duplicate(); return duplicateElement == elementSerializer ? this : new ListSerializer<>(duplicateElement); }
@Override public NFASerializer<T> duplicate() { return new NFASerializer<>(eventSerializer.duplicate()); }
@Override public TypeSerializer<BufferEntry<T>> duplicate() { return new BufferEntrySerializer<>(elementSerializer.duplicate()); }
public TypeSerializer<T> duplicate() { return (deserializer != null) ? deserializer.duplicate() : serializer.duplicate(); }
@Override public Optional<StateSnapshotTransformer<byte[]>> createForSerializedState() { return snapshotTransformFactory.createForDeserializedState() .map(est -> new RocksDBListState.StateSnapshotTransformerWrapper<>(est, elementSerializer.duplicate())); } }
public CompositeTypeSerializerConfigSnapshot(TypeSerializer<?>... nestedSerializers) { Preconditions.checkNotNull(nestedSerializers); this.nestedSerializersAndConfigs = new ArrayList<>(nestedSerializers.length); for (TypeSerializer<?> nestedSerializer : nestedSerializers) { TypeSerializerSnapshot<?> configSnapshot = nestedSerializer.snapshotConfiguration(); this.nestedSerializersAndConfigs.add( new Tuple2<>(nestedSerializer.duplicate(), Preconditions.checkNotNull(configSnapshot))); } }