@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator) { Yielder<OutType> yielder = toYielder(initValue, YieldingAccumulators.fromAccumulator(accumulator)); try { return yielder.get(); } finally { CloseQuietly.close(yielder); } } }
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator) { final FilteringYieldingAccumulator<OutType, T> filteringAccumulator = new FilteringYieldingAccumulator<>(pred, accumulator); return wrapYielder(baseSequence.toYielder(initValue, filteringAccumulator), filteringAccumulator); }
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator) { final LimitedYieldingAccumulator<OutType, T> limitedAccumulator = new LimitedYieldingAccumulator<>( accumulator ); final Yielder<OutType> subYielder = baseSequence.toYielder(initValue, limitedAccumulator); return new LimitedYielder<>(subYielder, limitedAccumulator); }
@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator) { Yielder<OutType> yielder = null; try { yielder = toYielder(initValue, YieldingAccumulators.fromAccumulator(accumulator)); return yielder.get(); } finally { CloseQuietly.close(yielder); } }
private <T> MergeSequence<T> makeUnorderedMergedSequence( Ordering<T> ordering, List<TestSequence<T>> seqs ) { return new MergeSequence<T>(ordering, Sequences.simple(seqs)); }
default <R> Sequence<R> flatMerge( Function<? super T, ? extends Sequence<? extends R>> mapper, Ordering<? super R> ordering ) { return new MergeSequence<>(ordering, this.map(mapper)); }
@Override public boolean isDone() { return !accumulator.didSomething() || yielder.isDone(); }
@Override public Yielder<OutType> get() { return new WrappingYielder<>(baseYielder.next(initValue), wrapper); } });
@Override public Yielder<T> next(T initValue) { return new ExecuteWhenDoneYielder<>(baseYielder.next(initValue), runnable, executor); }
default <R> Sequence<R> flatMap(Function<? super T, ? extends Sequence<? extends R>> mapper) { return new ConcatSequence<>(this.map(mapper)); }
@Override public void run() { seq.toList(); } }
@Override public Yielder<OutType> get() { return new WrappingYielder<>(baseSequence.toYielder(initValue, accumulator), wrapper); } });
@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, Out> accumulator) { return baseSequence.accumulate(initValue, new MappingAccumulator<>(fn, accumulator)); }
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, Out> accumulator) { return baseSequence.toYielder(initValue, new MappingYieldingAccumulator<>(fn, accumulator)); } }
@Override public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator) { return baseSequence.accumulate(initValue, new FilteringAccumulator<>(pred, accumulator)); }
@Override public boolean hasNext() { return !yielder.isDone() && count < limit; }
public FunctionalIterable<T> drop(int numToDrop) { return new FunctionalIterable<>(new DroppingIterable<>(delegate, numToDrop)); }
public FunctionalIterator<T> drop(int numToDrop) { return new FunctionalIterator<>(new DroppingIterator<>(delegate, numToDrop)); }
@Override public void yield() { accumulator.yield(); }
@Override public void yield() { baseAccumulator.yield(); }