Example usage for com.google.common.collect PeekingIterator peek

Introduction

In this page you can find the example usage for com.google.common.collect PeekingIterator peek.

Prototype

E peek();

Source Link

Document

Returns the next element in the iteration, without advancing the iteration.

Usage

From source file:org.apache.jackrabbit.oak.plugins.document.util.MergeSortedIterators.java

private void fetchNextIterator() {
    Iterator<T> it = nextIterator();
    if (it != null && it.hasNext()) {
        PeekingIterator<T> pIt = Iterators.peekingIterator(it);
        if (!iterators.isEmpty() && comparator.compare(pIt.peek(), lastPeek) < 0) {
            throw new IllegalStateException(description() + " First element of next iterator (" + pIt.peek()
                    + ")" + " must be after previous iterator (" + lastPeek + ")");
        }//from  w ww.java2  s .  c o m
        lastPeek = pIt.peek();
        iterators.add(pIt);
        adjustLast();
    }
}

---

From source file:org.diqube.util.SortedSetUnionIterator.java

@Override
public E next() {
    if (!hasNext())
        return null;
    PeekingIterator<E> nextSmallestIt = null;
    for (PeekingIterator<E> it : iterators) {
        if (!it.hasNext())
            continue;

        if (nextSmallestIt == null || (nextSmallestIt.peek().compareTo(it.peek()) > 0))
            nextSmallestIt = it;// www . j  ava  2 s .c o m
    }
    return nextSmallestIt.next();
}

---

From source file:org.diqube.cache.ConstantTimeCache.java

private void cleanupCache(long now) {
    PeekingIterator<Triple<Long, K1, K2>> it = Iterators.peekingIterator(timeouts.iterator());
    while (it.hasNext() && it.peek().getLeft() < now) {
        Triple<Long, K1, K2> t = it.next();
        values.remove(new Pair<>(t.getMiddle(), t.getRight()));
        secondLevelKeys.computeIfPresent(t.getMiddle(), (k, v) -> {
            Set<K2> res = new ConcurrentSkipListSet<>(v);
            res.remove(t.getRight());//from   www. j  a v  a  2s .  c  o  m
            if (res.isEmpty())
                return null;
            return res;
        });
        it.remove();
    }
}

---

From source file:org.kiji.schema.impl.cassandra.CassandraKijiPartition.java

/**
 * Convert a set of (start-token, host) pairs into a set of (token-range, host) pairs.
 *
 * Package private for testing.//from w  w  w .j  av a2  s .co m
 *
 * @param startTokens The set of start tokens with hosts.
 * @return The token corresponding token ranges.
 */
static Map<Range<Long>, InetAddress> getTokenRanges(final SortedMap<Long, InetAddress> startTokens) {

    ImmutableMap.Builder<Range<Long>, InetAddress> tokenRangesBldr = ImmutableMap.builder();

    final PeekingIterator<Entry<Long, InetAddress>> startTokensItr = Iterators
            .peekingIterator(startTokens.entrySet().iterator());

    // Add a range for [-, firstStartToken) owned by the final key (the wrap-around range).
    // For more information on Casandra VNode token ranges:
    //    http://www.datastax.com/dev/blog/virtual-nodes-in-cassandra-1-2
    tokenRangesBldr.put(Range.lessThan(startTokens.firstKey()), startTokens.get(startTokens.lastKey()));

    while (startTokensItr.hasNext()) {
        Entry<Long, InetAddress> startToken = startTokensItr.next();
        if (!startTokensItr.hasNext()) {
            // The final start token
            // Add a range for [lastStartToken, )
            tokenRangesBldr.put(Range.atLeast(startToken.getKey()), startToken.getValue());
        } else {
            // Add a range for [thisStartToken, nextStartToken)
            tokenRangesBldr.put(Range.closedOpen(startToken.getKey(), startTokensItr.peek().getKey()),
                    startToken.getValue());
        }
    }

    final Map<Range<Long>, InetAddress> tokenRanges = tokenRangesBldr.build();

    // Check that the returned ranges are coherent; most importantly that all possible tokens fall
    // within the returned range set.

    if (startTokens.size() + 1 != tokenRanges.size()) {
        throw new InternalKijiError(
                String.format("Unexpected number of token ranges. start-tokens: %s, token-ranges: %s.",
                        startTokens.size(), tokenRanges.size()));
    }

    final RangeSet<Long> ranges = TreeRangeSet.create();
    for (Range<Long> tokenRange : tokenRanges.keySet()) {
        ranges.add(tokenRange);
    }

    if (!ranges.encloses(Range.closed(Long.MIN_VALUE, Long.MAX_VALUE))) {
        throw new InternalKijiError("Token range does not include all possible tokens.");
    }

    return tokenRanges;
}

---

From source file:com.github.zhongl.index.Merger.java

public IndicesFile merge(PeekingIterator<Index> base, PeekingIterator<Index> delta) throws IOException {
    IndicesFile file = new IndicesFile(dir, encoder);

    while (base.hasNext() && delta.hasNext()) {

        Index a = base.peek();
        Index b = delta.peek();//from w  w  w  . jav a  2  s .c  o  m
        Index c;

        int result = a.compareTo(b);

        if (result < 0)
            c = base.next(); // a <  b, use a
        else if (result > 0)
            c = delta.next(); // a >  b, use b
        else { // a == b, use b
            c = b;
            delta.next();
            base.next();
        }

        if (c.isRemoved())
            continue; // remove this entry
        file.append(c);
    }

    mergeRestOf(base, file);
    mergeRestOf(delta, file);

    return file;
}

---

From source file:com.indeed.lsmtree.core.MergingIterator.java

public MergingIterator(final Collection<Iterator<Generation.Entry<K, V>>> iterators,
        final Comparator<K> keyComparator) {
    this.keyComparator = keyComparator;
    Comparator<PeekingIterator<EntryAndGenerationId<K, V>>> comparator = new Comparator<PeekingIterator<EntryAndGenerationId<K, V>>>() {
        @Override//from   ww  w  . j av a2 s . c om
        public int compare(PeekingIterator<EntryAndGenerationId<K, V>> o1,
                PeekingIterator<EntryAndGenerationId<K, V>> o2) {
            EntryAndGenerationId<K, V> a = o1.peek();
            EntryAndGenerationId<K, V> b = o2.peek();
            int cmp = keyComparator.compare(a.entry.getKey(), b.entry.getKey());
            if (cmp != 0)
                return cmp;
            return Ints.compare(a.generationId, b.generationId);
        }
    };
    heap = new PriorityQueue<PeekingIterator<EntryAndGenerationId<K, V>>>(iterators.size(), comparator);
    int i = 0;
    for (final Iterator<Generation.Entry<K, V>> iterator : iterators) {
        final int generationId = i;
        PeekingIterator<EntryAndGenerationId<K, V>> iter = Iterators
                .peekingIterator(new Iterator<EntryAndGenerationId<K, V>>() {

                    Iterator<Generation.Entry<K, V>> it = iterator;

                    @Override
                    public boolean hasNext() {
                        return it.hasNext();
                    }

                    @Override
                    public EntryAndGenerationId<K, V> next() {
                        return new EntryAndGenerationId<K, V>(it.next(), generationId);
                    }

                    @Override
                    public void remove() {
                        throw new UnsupportedOperationException();
                    }
                });
        if (iter.hasNext()) {
            heap.add(iter);
        }
        i++;
    }
}

---

From source file:co.cask.cdap.data.file.PartitionedFileWriter.java

@Override
public void appendAll(final Iterator<? extends T> events) throws IOException {
    if (closed) {
        throw new IOException("Attempts to write to a closed FileWriter.");
    }//from  www. ja v  a  2 s .co m

    PeekingIterator<T> iterator = Iterators.peekingIterator(events);
    while (iterator.hasNext()) {
        getWriter(iterator.peek()).appendAll(new AppendIterator(iterator));
    }
}

---

From source file:co.jirm.orm.dao.JirmDao.java

public void insertMaps(Iterator<Map<String, Object>> values, int batchSize) {
    if (!values.hasNext())
        return;/*from   w  w  w  .j a v  a 2 s.  c om*/
    PeekingIterator<Map<String, Object>> vs = peekingIterator(values);
    Map<String, Object> first = vs.peek();
    final String sql = writerStrategy.insertStatement(new StringBuilder(), definition, first).toString();
    ImmutableList<String> keys = ImmutableList.copyOf(vs.peek().keySet());
    Iterator<List<Map<String, Object>>> it = partition(vs, batchSize);

    while (it.hasNext()) {
        List<Map<String, Object>> batch = it.next();
        final List<Object[]> batchValues = Lists.newArrayListWithExpectedSize(batch.size());
        for (Map<String, Object> b : batch) {
            ImmutableList<String> actualKeys = ImmutableList.copyOf(b.keySet());
            check.state(actualKeys.equals(keys), "Keys don't match up to {} for {}", keys, actualKeys);
            batchValues.add(writerStrategy.fillValues(definition, b).toArray());
        }
        /*
         * TODO this will keep making a prepared statementS.
         * Hopefully the JDBC driver has some caching for this.
         */
        sqlExecutor.batchUpdate(sql, batchValues);
    }

}

---

From source file:org.apache.storm.state.BaseStateIterator.java

private boolean seekToAvailableEntry(PeekingIterator<Map.Entry<KENCODED, VENCODED>> iterator) {
    if (iterator != null) {
        while (iterator.hasNext()) {
            Map.Entry<KENCODED, VENCODED> entry = iterator.peek();
            if (!providedKeys.contains(entry.getKey())) {
                if (isTombstoneValue(entry.getValue())) {
                    providedKeys.add(entry.getKey());
                } else {
                    return true;
                }//from w ww . j  av a2s  . c o m
            }

            iterator.next();
        }
    }

    return false;
}

---

From source file:com.google.errorprone.bugpatterns.AbstractExpectedExceptionChecker.java

@Override
public Description matchMethod(MethodTree tree, VisitorState state) {
    if (tree.getBody() == null) {
        return NO_MATCH;
    }/*from   ww  w. j av  a  2  s. co  m*/
    PeekingIterator<? extends StatementTree> it = Iterators
            .peekingIterator(tree.getBody().getStatements().iterator());
    while (it.hasNext() && !MATCHER.matches(it.peek(), state)) {
        it.next();
    }
    List<Tree> expectations = new ArrayList<>();
    while (it.hasNext() && MATCHER.matches(it.peek(), state)) {
        expectations.add(it.next());
    }
    if (expectations.isEmpty()) {
        return NO_MATCH;
    }
    List<StatementTree> suffix = new ArrayList<>();
    Iterators.addAll(suffix, it);
    return handleMatch(tree, state, expectations, suffix);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• »