@Override public T apply(Yielder<T> input) { return input.get(); } }
@Override public T get() { return baseYielder.get(); }
@Override public OutType get() { return baseYielder.get(); }
@Override public OutType get() { return yielder.get(); }
@Override public OutType get() { return yielder.get(); }
@Override public T apply(Yielder<T> input) { return input.get(); } }
@Nullable @Override public InputRow nextRow() { final InputRow inputRow = rowYielder.get(); rowYielder = rowYielder.next(null); return transformer.transform(inputRow); }
@Override public OutType get() { try { waitLatch.await(1000, TimeUnit.MILLISECONDS); } catch (Exception e) { throw Throwables.propagate(e); } return baseYielder.get(); }
@Override public Yielder<OutType> next(OutType initValue) { combiningAccumulator.reset(); return makeYielder( finalYielder == null ? yielder.next(yielder.get()) : finalYielder, combiningAccumulator, finalFinalValue ); }
@Override public void serialize(Yielder yielder, final JsonGenerator jgen, SerializerProvider provider) throws IOException { try { jgen.writeStartArray(); while (!yielder.isDone()) { final Object o = yielder.get(); jgen.writeObject(o); yielder = yielder.next(null); } jgen.writeEndArray(); } finally { yielder.close(); } } }
@Override public ScanResultValue next() { ScanResultValue batch = yielder.get(); if (ScanQuery.RESULT_FORMAT_COMPACTED_LIST.equals(resultFormat) || ScanQuery.RESULT_FORMAT_LIST.equals(resultFormat)) { List events = (List) batch.getEvents(); if (events.size() <= limit - count) { count += events.size(); yielder = yielder.next(null); return batch; } else { // last batch // single batch length is <= Integer.MAX_VALUE, so this should not overflow int left = (int) (limit - count); count = limit; return new ScanResultValue(batch.getSegmentId(), batch.getColumns(), events.subList(0, left)); } } throw new UnsupportedOperationException(ScanQuery.RESULT_FORMAT_VALUE_VECTOR + " is not supported yet"); }
@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); } }
@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); } } }
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); }
public Meta.Frame nextFrame(final long fetchOffset, final int fetchMaxRowCount) { synchronized (lock) { ensure(State.RUNNING); Preconditions.checkState(fetchOffset == offset, "fetchOffset[%,d] != offset[%,d]", fetchOffset, offset); try { final List<Object> rows = new ArrayList<>(); while (!yielder.isDone() && (fetchMaxRowCount < 0 || offset < fetchOffset + fetchMaxRowCount)) { rows.add(yielder.get()); yielder = yielder.next(null); offset++; } final boolean done = yielder.isDone(); if (done) { close(); } return new Meta.Frame(fetchOffset, done, rows); } catch (Throwable t) { this.throwable = t; try { close(); } catch (Throwable t1) { t.addSuppressed(t1); } throw t; } } }
OutType nextInit = yielder.get(); try { yielder.close();
final SegmentAnalysis analysis = yielder.get(); final DataSegment segment = segmentMap.get(analysis.getId());
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()); }
Assert.assertEquals(9, yielder.get().intValue());