/** * Creates a data set that contains groups of data units. */ public static <T> DataSetType<Iterable<T>> createGroupedUnchecked(Class<?> dataUnitClass) { return new DataSetType<>(new DataUnitGroupType<>(new BasicDataUnitType<>(dataUnitClass))); }
/** * Creates a flat data set that contains basic data units. This is the normal case. */ public static <T> DataSetType<T> createDefaultUnchecked(Class<?> dataUnitClass) { return new DataSetType<>(new BasicDataUnitType<>(dataUnitClass).unchecked()); }
/** * Checks whether this instance is more general that the given one, i.e., it is a valid type of datasets that are * also valid under the given type. * * @param that the other instance * @return whether this instance is a super type of {@code that} instance */ public boolean isSupertypeOf(DataSetType that) { return this.dataUnitType.toBasicDataUnitType().isSupertypeOf(that.dataUnitType.toBasicDataUnitType()); }
/** * Find out whether this corresponds to either {@link #none()} or {@link #groupedNone()}. * * @return whether above condition holds */ public boolean isNone() { return this.equals(none()) || this.equals(groupedNone()); }
/** * Creates a new instance. * * @param typeClass type of the stream elements */ public CountOperator(Class<Type> typeClass) { this(DataSetType.createDefault(typeClass)); }
public CartesianOperator(Class<InputType0> inputType0Class, Class<InputType1> inputType1Class) { super(DataSetType.createDefault(inputType0Class), DataSetType.createDefault(inputType1Class), DataSetType.createDefaultUnchecked(Tuple2.class), true); }
/** * Checks whether the given instance is the same as this instance or more specific. * * @param that the other instance * @return whether this instance is a super type of {@code that} instance */ public boolean isSupertypeOf(BasicDataUnitType<?> that) { return this.getTypeClass().isAssignableFrom(that.getTypeClass()); }
/** * Creates a new data set type that contains groups of data units. */ public static <T> DataSetType<Iterable<T>> createGrouped(BasicDataUnitType<T> inputType) { return new DataSetType<>(new DataUnitGroupType<>(inputType)); }
public static <T> DataUnitGroupType<T> createGroupedUnchecked(Class<?> cls) { return new DataUnitGroupType<>(createBasicUnchecked(cls)); }
public ReduceDescriptor(SerializableBinaryOperator<Type> javaImplementation, Class<Type> inputType) { this(javaImplementation, DataUnitType.createGroupedUnchecked(inputType), DataUnitType.createBasicUnchecked(inputType) ); }
public TransformationDescriptor(FunctionDescriptor.SerializableFunction<Input, Output> javaImplementation, Class<Input> inputTypeClass, Class<Output> outputTypeClass) { this(javaImplementation, BasicDataUnitType.createBasic(inputTypeClass), BasicDataUnitType.createBasic(outputTypeClass)); }
public FlatMapDescriptor(SerializableFunction<Input, Iterable<Output>> javaImplementation, Class<Input> inputTypeClass, Class<Output> outputTypeClass, ProbabilisticDoubleInterval selectivity, LoadProfileEstimator loadProfileEstimator) { this(javaImplementation, DataUnitType.createBasic(inputTypeClass), DataUnitType.createBasic(outputTypeClass), selectivity, loadProfileEstimator ); }
/** * Tells whether this is a normal data unit type. */ public boolean isPlain() { return !this.isGroup(); }
/** * Creates a flat data set that contains basic data units. This is the normal case. */ public static <T> DataSetType<T> createDefault(BasicDataUnitType<T> dataUnitType) { return new DataSetType<>(dataUnitType); }
/** * Creates a new instance. * * @param callback callback that is executed locally for each incoming data unit * @param typeClass type of the incoming elements */ public LocalCallbackSink(Consumer<T> callback, Class<T> typeClass) { this(callback, DataSetType.createDefault(typeClass)); }
/** * Creates a data set that contains groups of data units. */ public static <T> DataSetType<Iterable<T>> createGrouped(Class<? extends T> dataUnitClass) { return new DataSetType<>(new DataUnitGroupType<>(new BasicDataUnitType<>(dataUnitClass))); }
public MapPartitionsDescriptor(SerializableFunction<Iterable<Input>, Iterable<Output>> javaImplementation, Class<Input> inputTypeClass, Class<Output> outputTypeClass, ProbabilisticDoubleInterval selectivity, LoadProfileEstimator loadProfileEstimator) { this(javaImplementation, DataUnitType.createBasic(inputTypeClass), DataUnitType.createBasic(outputTypeClass), selectivity, loadProfileEstimator); }
/** * Creates a new instance. * * @param typeClass the type of the datasets to be coalesced */ public UnionAllOperator(Class<Type> typeClass) { this(DataSetType.createDefault(typeClass)); }
/** * Creates a new instance. * * @param typeClass type of the dataunit elements */ public DistinctOperator(Class<Type> typeClass) { this(DataSetType.createDefault(typeClass)); }
/** * Creates a new instance. */ public ZipWithIdOperator(Class<InputType> inputTypeClass) { this(DataSetType.createDefault(inputTypeClass)); }