@Override public <OutType> OutType accumulate(OutType initValue, final Accumulator<OutType, T> accumulator) { return baseSequences.accumulate(initValue, (accumulated, in) -> in.accumulate(accumulated, accumulator)); }
@Override public OutType get() { return baseSequence.accumulate(outType, accumulator); } });
@Override public <OutType> OutType accumulate(final OutType initValue, final Accumulator<OutType, T> accumulator) { try { return baseSequence.accumulate(initValue, accumulator); } catch (SegmentMissingException e) { appendMissingSegment(responseContext); return initValue; } }
private static <T> void evaluateSequenceForSideEffects(final Sequence<T> sequence) { sequence.accumulate(null, (accumulated, in) -> null); }
@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator) { return provider.get().accumulate(initValue, accumulator); }
@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, Out> accumulator) { return baseSequence.accumulate(initValue, new MappingAccumulator<>(fn, accumulator)); }
@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator) { return base.accumulate(initValue, accumulator); }
@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator) { return baseSequence.accumulate(initValue, new FilteringAccumulator<>(pred, accumulator)); }
@Override public void serialize(Sequence value, final JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeStartArray(); value.accumulate( null, new Accumulator<Object, Object>() { @Override public Object accumulate(Object o, Object o1) { try { jgen.writeObject(o1); } catch (IOException e) { throw Throwables.propagate(e); } return null; } } ); jgen.writeEndArray(); } }
default List<T> toList() { return accumulate(new ArrayList<>(), Accumulators.list()); }
public static IncrementalIndex makeIncrementalIndex( GroupByQuery query, GroupByQueryConfig config, NonBlockingPool<ByteBuffer> bufferPool, Sequence<Row> rows, boolean combine ) { Pair<IncrementalIndex, Accumulator<IncrementalIndex, Row>> indexAccumulatorPair = GroupByQueryHelper.createIndexAccumulatorPair( query, config, bufferPool, combine ); return rows.accumulate(indexAccumulatorPair.lhs, indexAccumulatorPair.rhs); }
public static void testAccumulation(final String prefix, Sequence<Integer> seq, final List<Integer> nums) { int expectedSum = 0; for (Integer num : nums) { expectedSum += num; } int sum = seq.accumulate( 0, new Accumulator<Integer, Integer>() { final Iterator<Integer> valsIter = nums.iterator(); @Override public Integer accumulate(Integer accumulated, Integer in) { Assert.assertEquals(prefix, valsIter.next(), in); return accumulated + in; } } ); Assert.assertEquals(prefix, expectedSum, sum); }
@Override public T accumulate(T prevValue, T t) { if (!accumulatedSomething) { accumulatedSomething = true; } if (prevValue == null) { return mergeFn.apply(t, null); } if (ordering.compare(prevValue, t) == 0) { return mergeFn.apply(prevValue, t); } retVal = accumulator.accumulate(retVal, prevValue); return t; } }
@Override public Node implement(InterpreterImplementor implementor) { final Sink sink = implementor.compiler.sink(this); return () -> runQuery().accumulate( sink, (Sink theSink, Object[] in) -> { try { theSink.send(Row.of(in)); } catch (InterruptedException e) { throw Throwables.propagate(e); } return theSink; } ); }
.create(); input.accumulate( queue, new Accumulator<MinMaxPriorityQueue<T>, T>()
pQueue = baseSequences.accumulate( pQueue, (queue, in) -> {
seq.accumulate( 1, new Accumulator<Integer, Integer>()
@Test public void testNoSideEffects() { final List<Integer> nums = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); final AtomicLong accumulated = new AtomicLong(0); final Sequence<Integer> seq = Sequences.simple( Iterables.transform( nums, input -> { accumulated.addAndGet(input); return input; } ) ).limit(5); Assert.assertEquals(10, seq.accumulate(0, new IntAdditionAccumulator()).intValue()); Assert.assertEquals(10, accumulated.get()); Assert.assertEquals(10, seq.accumulate(0, new IntAdditionAccumulator()).intValue()); Assert.assertEquals(20, accumulated.get()); }
seq.accumulate( 1, new Accumulator<Integer, Integer>()
retVal.defaultReturnValue(0); cursors.accumulate( retVal, (map, cursor) -> {