/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public FilterOperator(FilterOperator<Type> that) { super(that); this.predicateDescriptor = that.getPredicateDescriptor(); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public CoGroupOperator(CoGroupOperator<InputType0, InputType1, Key> that) { super(that); this.keyDescriptor0 = that.getKeyDescriptor0(); this.keyDescriptor1 = that.getKeyDescriptor1(); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public CollectionSource(CollectionSource that) { super(that); this.collection = that.getCollection(); }
/** * Creates a copy of the given {@link LoopOperator}. * * @param that should be copied */ public LoopOperator(LoopOperator<InputType, ConvergenceType> that) { super(that); this.criterionDescriptor = that.getCriterionDescriptor(); this.numExpectedIterations = that.getNumExpectedIterations(); this.state = that.getState(); this.initializeSlots(that.getInputType(), that.getConvergenceType()); }
/** * Creates a copy of the given {@link LoopOperator}. * * @param that should be copied */ public DoWhileOperator(DoWhileOperator<InputType, ConvergenceType> that) { super(that); this.criterionDescriptor = that.getCriterionDescriptor(); this.numExpectedIterations = that.getNumExpectedIterations(); this.state = that.getState(); this.initializeSlots(that.getInputType(), that.getConvergenceType()); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public SampleOperator(SampleOperator<Type> that) { super(that); this.sampleSizeFunction = that.sampleSizeFunction; this.seedFunction = that.seedFunction; this.sampleMethod = that.getSampleMethod(); this.datasetSize = that.getDatasetSize(); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public JavaReservoirSampleOperator(SampleOperator<Type> that) { super(that); assert that.getSampleMethod() == Methods.RESERVOIR || that.getSampleMethod() == Methods.ANY; }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public MapOperator(MapOperator<InputType, OutputType> that) { super(that); this.functionDescriptor = that.getFunctionDescriptor(); }
/** * Creates a copy of the given {@link RepeatOperator}. * * @param that should be copied */ public RepeatOperator(RepeatOperator<Type> that) { super(that); this.initializeSlots(that.getType()); this.numIterations = that.numIterations; this.state = that.getState(); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public TextFileSource(TextFileSource that) { super(that); this.inputUrl = that.getInputUrl(); this.encoding = that.getEncoding(); }
/** * @deprecated This method is just a hack that is necessary because of the ambiguous nature of this operator. */ public static <Type> ReduceOperator<Type> createGroupedReduce( ReduceDescriptor<Type> reduceDescriptor, DataSetType<? extends Iterable<Type>> inputType, DataSetType<Type> outputType) { return new ReduceOperator<>(reduceDescriptor, (DataSetType<Type>) inputType, outputType); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public MapPartitionsOperator(MapPartitionsOperator<InputType, OutputType> that) { super(that); this.functionDescriptor = that.getFunctionDescriptor(); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public TableSource(TableSource that) { super(that); this.tableName = that.getTableName(); }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public PageRankOperator(PageRankOperator that) { super(that); this.numIterations = that.getNumIterations(); this.dampingFactor = that.dampingFactor; this.graphDensity = that.graphDensity; }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public MaterializedGroupByOperator(MaterializedGroupByOperator<Type, Key> that) { super(that); this.keyDescriptor = that.getKeyDescriptor(); }
/** * Provides the type of input and output datasets. * * @return the {@link DataSetType} */ public DataSetType<Type> getType() { return this.getInputType0(); }
/** * Creates a new instance with any sampling method. * * @param sampleSizeFunction user-specified size of the sample in dependence of the current iteration number * @param type {@link DataSetType} of the sampled dataset */ public SampleOperator(IntUnaryOperator sampleSizeFunction, DataSetType<Type> type) { this(sampleSizeFunction, type, Methods.ANY, iterationNumber -> randomSeed()); }
public CoGroupOperator(TransformationDescriptor<InputType0, Key> keyDescriptor0, TransformationDescriptor<InputType1, Key> keyDescriptor1, DataSetType<InputType0> inputType0, DataSetType<InputType1> inputType1) { super(inputType0, inputType1, CoGroupOperator.createOutputDataSetType(), true); this.keyDescriptor0 = keyDescriptor0; this.keyDescriptor1 = keyDescriptor1; }
/** * Copies an instance (exclusive of broadcasts). * * @param that that should be copied */ public SparkRandomPartitionSampleOperator(SampleOperator<Type> that) { super(that); assert that.getSampleMethod() == Methods.RANDOM || that.getSampleMethod() == Methods.ANY; }