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); } } }
public void testPeekOnEmptyList() { List<?> list = Collections.emptyList(); Iterator<?> iterator = list.iterator(); PeekingIterator<?> peekingIterator = Iterators.peekingIterator(iterator); try { peekingIterator.peek(); fail("Should throw NoSuchElementException if nothing to peek()"); } catch (NoSuchElementException e) { /* expected */ } }
@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<Double> iterator = Iterators.peekingIterator(quantiles.iterator()); while (iterator.hasNext()) { builder.add(max); iterator.next();
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 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(); }
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); } } }
new ImmutableList.Builder<>(ranges.size()); Collections.sort(ranges, Range.<C>rangeLexOrdering()); PeekingIterator<Range<C>> peekingItr = Iterators.peekingIterator(ranges.iterator()); while (peekingItr.hasNext()) { Range<C> range = peekingItr.next(); while (peekingItr.hasNext()) { Range<C> nextRange = peekingItr.peek(); if (range.isConnected(nextRange)) { checkArgument(
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());
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 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(); }
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();
ColumnScannerImpl(Iterator<Entry<Key, Value>> e, Function<Key, Column> columnConverter) { peekingIter = Iterators.peekingIterator(e); this.columnConverter = columnConverter; row = ByteUtil.toBytes(peekingIter.peek().getKey().getRowData()); iter = Iterators.transform(peekingIter, this::entry2cv); }
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")); }
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(); } } }
/** * 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; }