/** * {@inheritDoc} */ @SuppressWarnings("unchecked") public boolean contains(final Object o) { return contains.test(o); }
private void forEachKeyOfLeaf(int nodeOrder, Consumer<Object> consumer) { int relativeLeafOrder = nodeOrder - leafLevelOrder; for (Object key : leafKeys[relativeLeafOrder]) { consumer.accept(key); } }
@Override public void accept(long t, long u) { action.accept(t, u); } }
/** * {@inheritDoc} */ public Iterator<V> iterator() { return iterator.get(); }
/** * Primitive specialised forEach implementation. * <p/> * NB: Renamed from forEach to avoid overloading on parameter types of lambda * expression, which doesn't interplay well with type inference in lambda expressions. * * @param consumer a callback called for each key/value pair in the map. */ public void longForEach(final LongLongConsumer consumer) { final long[] entries = this.entries; for (int i = 0; i < entries.length; i += 2) { final long key = entries[i]; if (key != missingValue) { consumer.accept(entries[i], entries[i + 1]); } } }
@Override public boolean test(Object o) { if (o instanceof Watermark || o instanceof SnapshotBarrier || o == DONE_ITEM) { assert item == null : "Received multiple special items without a call to reset(): " + item; item = (BroadcastItem) o; return false; } return dest.test(o); } }
private void forEachKeyOfLeaf(int nodeOrder, Consumer<Object> consumer) { int relativeLeafOrder = nodeOrder - leafLevelOrder; for (Object key : leafKeys[relativeLeafOrder]) { consumer.accept(key); } }
@Override public void accept(long t, long u) { action.accept(t, u); } }
/** * {@inheritDoc} */ public Iterator<V> iterator() { return iterator.get(); }
/** * Primitive specialised forEach implementation. * <p/> * NB: Renamed from forEach to avoid overloading on parameter types of lambda * expression, which doesn't interplay well with type inference in lambda expressions. * * @param consumer a callback called for each key/value pair in the map. */ public void longForEach(final LongLongConsumer consumer) { final long[] entries = this.entries; for (int i = 0; i < entries.length; i += 2) { final long key = entries[i]; if (key != missingValue) { consumer.accept(entries[i], entries[i + 1]); } } }
/** * {@inheritDoc} */ @SuppressWarnings("unchecked") public boolean contains(final Object o) { return contains.test(o); }
@Override public void accept(Packet packet) { // ConnectionManager is only available after the NodeEngineImpl is available Consumer<Packet> packetConsumer = (Consumer<Packet>) node.getConnectionManager(); packetConsumer.accept(packet); } }
@Override @SuppressWarnings("unchecked") @SuppressFBWarnings("BC_UNCONFIRMED_CAST") public boolean test(InternalEventJournalCacheEvent e) { return predicate.test((DeserializingEventJournalCacheEvent<K, V>) e); } },
@Override public void accept(Packet packet) { // ConnectionManager is only available after the NodeEngineImpl is available Consumer<Packet> packetConsumer = (Consumer<Packet>) node.getConnectionManager(); packetConsumer.accept(packet); } }
private static <T> boolean conjunction(final Collection<T> collection, final Predicate<T> predicate) { checkNotNull(collection); boolean acc = false; for (final T t : collection) { // Deliberate strict evaluation acc |= predicate.test(t); } return acc; }
private void forEachKeyOfNonLeaf(int nodeOrder, Consumer<Object> consumer) { final int leftMostLeaf = MerkleTreeUtil.getLeftMostLeafUnderNode(nodeOrder, depth); final int rightMostLeaf = MerkleTreeUtil.getRightMostLeafUnderNode(nodeOrder, depth); for (int leafOrder = leftMostLeaf; leafOrder <= rightMostLeaf; leafOrder++) { int relativeLeafOrder = leafOrder - leafLevelOrder; for (Object key : leafKeys[relativeLeafOrder]) { consumer.accept(key); } } }
private boolean maybeEmitWm(long timestamp, Predicate<Object> dest) { if (timestamp != NO_NEW_WM) { boolean res = dest.test(new Watermark(timestamp)); assert res : "test result expected to be true"; return true; } return false; }
private void handleMessage(ClientMessage message) { message.index(message.getDataOffset()); message.setConnection(connection); dst.accept(message); } }
private static <E> boolean conjunction(final Collection<E> collection, final Predicate<E> predicate) { checkNotNull(collection); boolean acc = false; for (final E e : collection) { // Deliberate strict evaluation acc |= predicate.test(e); } return acc; }
private void handleMessage(ClientMessage message) { message.index(message.getDataOffset()); message.setConnection(connection); dst.accept(message); } }