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; }
@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 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 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; }
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()); assertEquals( "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.peek(); fail("Should throw exception if no next to peek()"); } catch (NoSuchElementException e) { peekingIterator.peek(); fail("Should continue to throw exception if no next to peek()"); } catch (NoSuchElementException e) {
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 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(); } });
@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(); }
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(
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 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")); }
@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()); }
@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(); }
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); }
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; } }