public static <T> List<LocalProperty<T>> stripLeadingConstants(List<? extends LocalProperty<T>> properties) { PeekingIterator<? extends LocalProperty<T>> iterator = peekingIterator(properties.iterator()); while (iterator.hasNext() && iterator.peek() instanceof ConstantProperty) { iterator.next(); } return ImmutableList.copyOf(iterator); }
public MergeIterator( final Comparator<T> comparator, List<Iterator<T>> iterators ) { pQueue = new PriorityQueue<>( 16, new Comparator<PeekingIterator<T>>() { @Override public int compare(PeekingIterator<T> lhs, PeekingIterator<T> rhs) { return comparator.compare(lhs.peek(), rhs.peek()); } } ); for (Iterator<T> iterator : iterators) { final PeekingIterator<T> iter = Iterators.peekingIterator(iterator); if (iter != null && iter.hasNext()) { pQueue.add(iter); } } }
@Override public boolean process(Node node) { sum += node.weightedCount; while (iterator.hasNext() && sum > iterator.peek() * weightedCount) { iterator.next(); // we know the max value ever seen, so cap the percentile to provide better error // bounds in this case long value = Math.min(node.getUpperBound(), max); builder.add(value); } return iterator.hasNext(); } });
final PeekingIterator<Double> iterator = Iterators.peekingIterator(quantiles.iterator()); while (iterator.hasNext()) { builder.add(max); iterator.next();
@Override public boolean hasNext() { if (iterator == null) { iterator = Iterators.peekingIterator(query.execute().get().getColumns().iterator()); } else if (!iterator.hasNext() && columns == count) { // only need to do another query if maximum columns were retrieved refresh(); } while(filter != null && iterator != null && iterator.hasNext() && !filter.accept(iterator.peek())) { next(); if(!iterator.hasNext() && columns == count) { refresh(); } } return iterator.hasNext(); }
public static <T> Set<T> extractLeadingConstants(List<? extends LocalProperty<T>> properties) { ImmutableSet.Builder<T> builder = ImmutableSet.builder(); PeekingIterator<? extends LocalProperty<T>> iterator = peekingIterator(properties.iterator()); while (iterator.hasNext() && iterator.peek() instanceof ConstantProperty) { builder.add(((ConstantProperty<T>) iterator.next()).getColumn()); } return builder.build(); }
@Override public T next() { if (!hasNext()) { throw new NoSuchElementException(); } final PeekingIterator<T> littleIt; if (!iterOfIterators.hasNext()) { littleIt = firstElementComparedPQueue.remove(); } else if (firstElementComparedPQueue.isEmpty()) { littleIt = iterOfIterators.next(); } else { T pQueueValue = firstElementComparedPQueue.peek().peek(); T iterItersValue = iterOfIterators.peek().peek(); if (comparator.compare(pQueueValue, iterItersValue) <= 0) { littleIt = firstElementComparedPQueue.remove(); } else { littleIt = iterOfIterators.next(); } } T retVal = littleIt.next(); if (littleIt.hasNext()) { firstElementComparedPQueue.add(littleIt); } return retVal; }
private void visitStatements(List<? extends StatementTree> statements) { boolean first = true; PeekingIterator<StatementTree> it = Iterators.peekingIterator(statements.iterator()); dropEmptyDeclarations(); while (it.hasNext()) { StatementTree tree = it.next(); builder.forcedBreak(); if (!first) { builder.blankLineWanted(BlankLineWanted.PRESERVE); } markForPartialFormat(); first = false; List<VariableTree> fragments = variableFragments(it, tree); if (!fragments.isEmpty()) { visitVariables( fragments, DeclarationKind.NONE, canLocalHaveHorizontalAnnotations(fragments.get(0).getModifiers())); } else { scan(tree, null); } } }
@Override public boolean hasNext() { if (iterator == null) { iterator = Iterators.peekingIterator(query.execute().get().getColumns().iterator()); } else if (!iterator.hasNext() && columns == count) { // only need to do another query if maximum columns were retrieved refresh(); } while(filter != null && iterator != null && iterator.hasNext() && !filter.accept(iterator.peek())) { next(); if(!iterator.hasNext() && columns == count) { refresh(); } } return iterator.hasNext(); }
final PeekingIterator<String> iter = Iterators.peekingIterator( Iterators.transform( indexed.iterator(), if (iter.hasNext()) { pQueue.add(Pair.of(i, iter));
@JsonCreator public ArbitraryGranularitySpec( @JsonProperty("queryGranularity") Granularity queryGranularity, @JsonProperty("rollup") Boolean rollup, @JsonProperty("intervals") List<Interval> inputIntervals ) { this.queryGranularity = queryGranularity == null ? Granularities.NONE : queryGranularity; this.rollup = rollup == null ? Boolean.TRUE : rollup; this.intervals = new TreeSet<>(Comparators.intervalsByStartThenEnd()); if (inputIntervals == null) { inputIntervals = new ArrayList<>(); } // Insert all intervals for (final Interval inputInterval : inputIntervals) { intervals.add(inputInterval); } // Ensure intervals are non-overlapping (but they may abut each other) final PeekingIterator<Interval> intervalIterator = Iterators.peekingIterator(intervals.iterator()); while (intervalIterator.hasNext()) { final Interval currentInterval = intervalIterator.next(); if (intervalIterator.hasNext()) { final Interval nextInterval = intervalIterator.peek(); if (currentInterval.overlaps(nextInterval)) { throw new IAE("Overlapping intervals: %s, %s", currentInterval, nextInterval); } } } }
@Override public OutType next() { if (!hasNext()) { throw new NoSuchElementException(); } if (!lhs.hasNext()) { return fn.apply(null, rhs.next()); } if (!rhs.hasNext()) { return fn.apply(lhs.next(), null); } int compared = comparator.compare(lhs.peek(), rhs.peek()); if (compared < 0) { return fn.apply(lhs.next(), null); } if (compared == 0) { return fn.apply(lhs.next(), rhs.next()); } return fn.apply(null, rhs.next()); }
final PeekingIterator<Long> iterator = Iterators.peekingIterator(bucketUpperBounds.iterator()); while (iterator.hasNext()) { double bucketCount = sum.get() - lastSum.get(); Bucket bucket = new Bucket(bucketCount / normalizationFactor, bucketWeightedSum.get() / bucketCount); iterator.next();
@Override public boolean hasNext() { if (iterator == null) { // First time through iterator = Iterators.peekingIterator(query.execute().get().getList().iterator()); } else if (!iterator.hasNext() && rows == query.getRowCount()) { // only need to do another query if maximum rows were retrieved query.setKeys(startKey, endKey); iterator = Iterators.peekingIterator(query.execute().get().getList().iterator()); rows = 0; if (iterator.hasNext()) { // First element is startKey which was the last element on the previous query result - skip it next(); } } while(filter != null && iterator != null && iterator.hasNext() && !filter.accept(iterator.peek())) { next(); if(!iterator.hasNext() && rows == query.getRowCount()) { refresh(); } } return iterator.hasNext(); }
private void refresh() { query.setKeys(startKey, endKey); iterator = Iterators.peekingIterator(query.execute().get().getList().iterator()); rows = 0; if (iterator.hasNext()) { // First element is startKey which was the last element on the previous query result - skip it next(); } } }