public static <T> Yielder<T> each(final Sequence<T> sequence) { return sequence.toYielder( null, new YieldingAccumulator<T, T>() { @Override public T accumulate(T accumulated, T in) { yield(); return in; } } ); }
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator) { return provider.get().toYielder(initValue, accumulator); } }
@Override public Yielder<OutType> get() { return new WrappingYielder<>(baseSequence.toYielder(initValue, accumulator), wrapper); } });
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, Out> accumulator) { return baseSequence.toYielder(initValue, new MappingYieldingAccumulator<>(fn, accumulator)); } }
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator) { return base.toYielder(initValue, accumulator); }
@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> 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( final OutType initValue, final YieldingAccumulator<OutType, T> accumulator ) { try { return makeYielder(baseSequence.toYielder(initValue, accumulator)); } catch (SegmentMissingException e) { appendMissingSegment(responseContext); return Yielders.done(initValue, null); } }
Yielder<Sequence<T>> yielderYielder = baseSequences.toYielder( null, new YieldingAccumulator<Sequence<T>, Sequence<T>>()
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, final YieldingAccumulator<OutType, T> accumulator) { final CombiningYieldingAccumulator<OutType, T> combiningAccumulator = new CombiningYieldingAccumulator<>(ordering, mergeFn, accumulator); combiningAccumulator.setRetVal(initValue); Yielder<T> baseYielder = baseSequence.toYielder(null, combiningAccumulator); return makeYielder(baseYielder, combiningAccumulator, false); }
final Yielder<OutType> baseYielder = baseSequence.toYielder(initValue, accumulator); return new Yielder<OutType>()
@Override public Yielder<T> accumulate(Yielder<T> accumulated, Sequence<T> in) { final Yielder<T> retVal = in.toYielder( null, new YieldingAccumulator<T, T>() { @Override public T accumulate(T accumulated, T in) { yield(); return in; } } ); if (retVal.isDone()) { try { retVal.close(); } catch (IOException e) { throw Throwables.propagate(e); } return null; } else { yield(); } return retVal; } }
pQueue, (queue, in) -> { final Yielder<T> yielder = in.toYielder( null, new YieldingAccumulator<T, T>()
.toYielder(initValue, accumulator); } else { return Iterables.getOnlyElement(listOfSequences).toYielder(initValue, accumulator);
Yielder<Integer> yielder = null; try { yielder = seq.toYielder( 1, new YieldingAccumulator<Integer, Integer>()
public ScanQueryLimitRowIterator( QueryRunner<ScanResultValue> baseRunner, QueryPlus<ScanResultValue> queryPlus, Map<String, Object> responseContext ) { ScanQuery query = (ScanQuery) queryPlus.getQuery(); resultFormat = query.getResultFormat(); limit = query.getLimit(); Sequence<ScanResultValue> baseSequence = baseRunner.run(queryPlus, responseContext); yielder = baseSequence.toYielder( null, new YieldingAccumulator<ScanResultValue, ScanResultValue>() { @Override public ScanResultValue accumulate(ScanResultValue accumulated, ScanResultValue in) { yield(); return in; } } ); }
public <OutType> Yielder<OutType> makeYielder( Yielder<Sequence<T>> yielderYielder, OutType initValue, YieldingAccumulator<OutType, T> accumulator ) { while (!yielderYielder.isDone()) { Yielder<OutType> yielder = yielderYielder.get().toYielder(initValue, accumulator); if (accumulator.yielded()) { return wrapYielder(yielder, yielderYielder, accumulator); } initValue = yielder.get(); try { yielder.close(); } catch (IOException e) { throw Throwables.propagate(e); } yielderYielder = yielderYielder.next(null); } return Yielders.done(initValue, yielderYielder); }
final Yielder yielder = resultSeq.toYielder( null, new YieldingAccumulator()
private void check(String expected, Sequence<Integer> complex) { List<Integer> combined = complex.toList(); Assert.assertEquals(expected, combined.toString()); Yielder<Integer> yielder = complex.toYielder( null, new YieldingAccumulator<Integer, Integer>() { @Override public Integer accumulate(Integer accumulated, Integer in) { yield(); return in; } } ); List<Integer> combinedByYielder = new ArrayList<>(); while (!yielder.isDone()) { combinedByYielder.add(yielder.get()); yielder = yielder.next(null); } Assert.assertEquals(expected, combinedByYielder.toString()); }
Yielder<Integer> yielder = seq.toYielder( 0, new YieldingAccumulator<Integer, Integer>()