@AccumulatorStateMetadata(stateFactoryClass = KeyValuePairsStateFactory.class, stateSerializerClass = KeyValuePairStateSerializer.class) public interface KeyValuePairsState extends AccumulatorState { KeyValuePairs get(); void set(KeyValuePairs value); void addMemoryUsage(long memory); Type getKeyType(); Type getValueType(); }
public static <T> AccumulatorStateSerializer<T> generateStateSerializer(Class<T> clazz, Map<String, Type> fieldTypes, DynamicClassLoader classLoader) if (metadata != null && metadata.stateSerializerClass() != void.class) { try { return (AccumulatorStateSerializer<T>) metadata.stateSerializerClass().getConstructor().newInstance();
public static <T> AccumulatorStateFactory<T> generateStateFactory(Class<T> clazz, Map<String, Type> fieldTypes, DynamicClassLoader classLoader) if (metadata != null && metadata.stateFactoryClass() != void.class) { try { return (AccumulatorStateFactory<T>) metadata.stateFactoryClass().getConstructor().newInstance();
@AccumulatorStateMetadata(stateFactoryClass = LongDecimalWithOverflowAndLongStateFactory.class, stateSerializerClass = LongDecimalWithOverflowAndLongStateSerializer.class) public interface LongDecimalWithOverflowAndLongState extends LongDecimalWithOverflowState { long getLong(); void setLong(long value); }
@AccumulatorStateMetadata(stateSerializerClass = SetDigestStateSerializer.class, stateFactoryClass = SetDigestStateFactory.class) public interface SetDigestState extends AccumulatorState { SetDigest getDigest(); void setDigest(SetDigest value); }
@AccumulatorStateMetadata(stateSerializerClass = EvaluateClassifierPredictionsStateSerializer.class, stateFactoryClass = EvaluateClassifierPredictionsStateFactory.class) public interface EvaluateClassifierPredictionsState extends AccumulatorState { void addMemoryUsage(int memory); Map<String, Integer> getTruePositives(); Map<String, Integer> getFalsePositives(); Map<String, Integer> getFalseNegatives(); }
@AccumulatorStateMetadata(stateFactoryClass = LongDecimalWithOverflowStateFactory.class, stateSerializerClass = LongDecimalWithOverflowStateSerializer.class) public interface LongDecimalWithOverflowState extends AccumulatorState { Slice getLongDecimal(); void setLongDecimal(Slice unscaledDecimal); long getOverflow(); void setOverflow(long overflow); }
@AccumulatorStateMetadata(stateSerializerClass = DigestAndPercentileStateSerializer.class, stateFactoryClass = DigestAndPercentileStateFactory.class) public interface DigestAndPercentileState extends AccumulatorState { QuantileDigest getDigest(); void setDigest(QuantileDigest digest); double getPercentile(); void setPercentile(double percentile); void addMemoryUsage(int value); }
@AccumulatorStateMetadata(stateSerializerClass = GeometryStateSerializer.class, stateFactoryClass = GeometryStateFactory.class) public interface GeometryState extends AccumulatorState { OGCGeometry getGeometry(); void setGeometry(OGCGeometry geometry); }
@AccumulatorStateMetadata(stateSerializerClass = DigestAndPercentileArrayStateSerializer.class, stateFactoryClass = DigestAndPercentileArrayStateFactory.class) public interface DigestAndPercentileArrayState extends AccumulatorState { QuantileDigest getDigest(); void setDigest(QuantileDigest digest); void setPercentiles(List<Double> percentiles); List<Double> getPercentiles(); void addMemoryUsage(int value); }
@AccumulatorStateMetadata(stateSerializerClass = DoubleHistogramStateSerializer.class, stateFactoryClass = NumericHistogramStateFactory.class) public interface State extends AccumulatorState { NumericHistogram get(); void set(NumericHistogram value); }
@AccumulatorStateMetadata(stateSerializerClass = HyperLogLogStateSerializer.class, stateFactoryClass = HyperLogLogStateFactory.class) public interface HyperLogLogState extends AccumulatorState { int NUMBER_OF_BUCKETS = 4096; HyperLogLog getHyperLogLog(); void setHyperLogLog(HyperLogLog value); void addMemoryUsage(int value); }
@AccumulatorStateMetadata(stateFactoryClass = HistogramStateFactory.class, stateSerializerClass = HistogramStateSerializer.class) public interface HistogramState extends AccumulatorState { /** * will create an empty histogram if none exists * * @return histogram based on the type of state (single, grouped). Note that empty histograms will serialize to null as required */ TypedHistogram get(); void addMemoryUsage(long memory); void deserialize(Block block, Type type, int expectedSize); }
@AccumulatorStateMetadata(stateSerializerClass = LearnStateSerializer.class, stateFactoryClass = LearnStateFactory.class) public interface LearnState extends AccumulatorState { // Mapping of string labels for classifiers that use strings instead of doubles BiMap<String, Integer> getLabelEnumeration(); int enumerateLabel(String label); List<Double> getLabels(); List<FeatureVector> getFeatureVectors(); Slice getParameters(); void setParameters(Slice parameters); void addMemoryUsage(long value); }
@AccumulatorStateMetadata(stateSerializerClass = SpatialPartitioningStateSerializer.class, stateFactoryClass = SpatialPartitioningStateFactory.class) public interface SpatialPartitioningState extends AccumulatorState { int getPartitionCount(); void setPartitionCount(int partitionCount); long getCount(); void setCount(long count); Rectangle getExtent(); void setExtent(Rectangle envelope); List<Rectangle> getSamples(); void setSamples(List<Rectangle> samples); }
@AccumulatorStateMetadata(stateSerializerClass = BlockStateSerializer.class) public interface BlockState extends AccumulatorState { Block getBlock(); void setBlock(Block value); static void write(Type type, BlockState state, BlockBuilder out) { if (state.getBlock() == null) { out.appendNull(); } else { type.writeObject(out, state.getBlock()); } } }
@AccumulatorStateMetadata(stateSerializerClass = NullableLongStateSerializer.class) public interface NullableLongState extends AccumulatorState { long getLong(); void setLong(long value); @InitialBooleanValue(true) boolean isNull(); void setNull(boolean value); static void write(Type type, NullableLongState state, BlockBuilder out) { if (state.isNull()) { out.appendNull(); } else { type.writeLong(out, state.getLong()); } } }
@AccumulatorStateMetadata(stateSerializerClass = BlockPositionStateSerializer.class) public interface BlockPositionState extends AccumulatorState { Block getBlock(); int getPosition(); void setBlock(Block value); void setPosition(int position); static void write(Type type, BlockPositionState state, BlockBuilder out) { if (state.getBlock() == null) { out.appendNull(); } else { type.appendTo(state.getBlock(), state.getPosition(), out); } } }
@AccumulatorStateMetadata(stateSerializerClass = NullableDoubleStateSerializer.class) public interface NullableDoubleState extends AccumulatorState { double getDouble(); void setDouble(double value); @InitialBooleanValue(true) boolean isNull(); void setNull(boolean value); static void write(Type type, NullableDoubleState state, BlockBuilder out) { if (state.isNull()) { out.appendNull(); } else { type.writeDouble(out, state.getDouble()); } } }
@AccumulatorStateMetadata(stateFactoryClass = MultimapAggregationStateFactory.class, stateSerializerClass = MultimapAggregationStateSerializer.class) public interface MultimapAggregationState extends AccumulatorState { void add(Block keyBlock, Block valueBlock, int position); void forEach(MultimapAggregationStateConsumer consumer); default void merge(MultimapAggregationState otherState) { otherState.forEach(this::add); } boolean isEmpty(); default void reset() { throw new UnsupportedOperationException(); } long getEstimatedSize(); int getEntryCount(); }