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); }
@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; }
final PeekingIterator<Double> iterator = Iterators.peekingIterator(quantiles.iterator()); while (iterator.hasNext()) { builder.add(max); iterator.next();
@Override public InType next() { if (!hasNext()) { throw new NoSuchElementException(); } InType res = null; while (hasNext()) { if (res == null) { res = fn.apply(it.next(), null); continue; } if (comparator.compare(res, it.peek()) == 0) { res = fn.apply(res, it.next()); } else { break; } } return res; }
public void testCantRemoveAfterPeek() { List<String> list = Lists.newArrayList("A", "B", "C"); Iterator<String> iterator = list.iterator(); PeekingIterator<?> peekingIterator = Iterators.peekingIterator(iterator); assertEquals("A", peekingIterator.next()); assertEquals("B", peekingIterator.peek()); /* Should complain on attempt to remove() after peek(). */ try { peekingIterator.remove(); fail("remove() should throw IllegalStateException after a peek()"); } catch (IllegalStateException e) { /* expected */ } assertEquals( "After remove() throws exception, peek should still be ok", "B", peekingIterator.peek()); /* Should recover to be able to remove() after next(). */ assertEquals("B", peekingIterator.next()); peekingIterator.remove(); assertEquals("Should have removed an element", 2, list.size()); assertFalse("Second element should be gone", list.contains("B")); }
if (node.getInitializer().get(0).getKind() == VARIABLE) { PeekingIterator<StatementTree> it = Iterators.peekingIterator(node.getInitializer().iterator()); visitVariables( variableFragments(it, it.next()), DeclarationKind.NONE, Direction.HORIZONTAL); } else { boolean first = true;
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 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()); }
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); } } }
private void doCollectMatching(List<Term> accumulator, String start, String end) { whitespaces.on(); try { accumulator.add(terms.next()); for (;;) { Term t = terms.peek(); if (t.is(start)) { doCollectMatching(accumulator, start, end); } else if (t.is(end)) { accumulator.add(terms.next()); return; } else { accumulator.add(terms.next()); } } } finally { whitespaces.off(); } }
public void testPeekDoesntChangeIteration() { List<?> list = Lists.newArrayList("A", "B", "C"); Iterator<?> iterator = list.iterator(); PeekingIterator<?> peekingIterator = Iterators.peekingIterator(iterator); assertEquals("Should be able to peek() at first element", "A", peekingIterator.peek()); assertEquals( "Should be able to peek() first element multiple times", "A", peekingIterator.peek()); assertEquals( "next() should still return first element after peeking", "A", peekingIterator.next()); assertEquals("Should be able to peek() at middle element", "B", peekingIterator.peek()); assertEquals( "Should be able to peek() middle element multiple times", "B", peekingIterator.peek()); assertEquals( "next() should still return middle element after peeking", "B", peekingIterator.next()); assertEquals("Should be able to peek() at last element", "C", peekingIterator.peek()); "Should be able to peek() last element multiple times", "C", peekingIterator.peek()); assertEquals( "next() should still return last element after peeking", "C", peekingIterator.next()); peekingIterator.next(); fail("next() should still throw exception after the end of iteration"); } catch (NoSuchElementException e) {
@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 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<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();
private boolean signature(Statement.Builder builder) { Term t = terms.peek(); if (t.is("@")) { do { builder.addAnnotations(terms.next()); Verify.verify(terms.peek().isWordOrNumber()); builder.addAnnotations(terms.next()); } while (terms.peek().is(".")); if (terms.peek().is("(")) { builder.addAllAnnotations(collectUntilMatching(")")); } return false; } else if (t.is("<")) { builder.addAllSignature(collectUntilMatching(">")); return false; } else if (t.is("class") || t.is("interface")) { builder.addSignature(terms.next()); return true; } else { builder.addSignature(terms.next()); return false; } }
/** * Attempt to match the desired properties to a sequence of known properties. * <p> * Returns a list of the same length as the original. Entries are: * - Optional.empty(): the property was satisfied completely * - non-empty: the (simplified) property that was not satisfied */ public static <T> List<Optional<LocalProperty<T>>> match(List<LocalProperty<T>> actuals, List<LocalProperty<T>> desired) { // After normalizing actuals, each symbol should only appear once PeekingIterator<LocalProperty<T>> actualIterator = peekingIterator(normalizeAndPrune(actuals).iterator()); Set<T> constants = new HashSet<>(); boolean consumeMoreActuals = true; List<Optional<LocalProperty<T>>> result = new ArrayList<>(desired.size()); for (LocalProperty<T> desiredProperty : desired) { while (consumeMoreActuals && actualIterator.hasNext() && desiredProperty.isSimplifiedBy(actualIterator.peek())) { constants.addAll(actualIterator.next().getColumns()); } Optional<LocalProperty<T>> simplifiedDesired = desiredProperty.withConstants(constants); consumeMoreActuals &= !simplifiedDesired.isPresent(); // Only continue processing actuals if all previous desired properties were fully satisfied result.add(simplifiedDesired); } return result; }
/** * The parser expands multi-variable declarations into separate single-variable declarations. All * of the fragments in the original declaration have the same start position, so we use that as a * signal to collect them and preserve the multi-variable declaration in the output. * * <p>e.g. {@code int x, y;} is parsed as {@code int x; int y;}. */ private List<VariableTree> variableFragments(PeekingIterator<? extends Tree> it, Tree first) { List<VariableTree> fragments = new ArrayList<>(); if (first.getKind() == VARIABLE) { int start = getStartPosition(first); fragments.add((VariableTree) first); while (it.hasNext() && it.peek().getKind() == VARIABLE && getStartPosition(it.peek()) == start) { fragments.add((VariableTree) it.next()); } } return fragments; }