@Override Iterator<QuerySnapshot> doGetData() { return queries.iterator(); }
@Override public Iterator<Event<T>> iterator() { return new Iterator<Event<T>>() { Iterator<Event<T>> it = events.iterator(); @Override public boolean hasNext() { return it.hasNext(); } @Override public Event<T> next() { return it.next(); } @Override public void remove() { it.remove(); size.decrementAndGet(); setModified(); } }; }
public Iterator<ClientRequest> requestIterator(Node node) { ConcurrentLinkedQueue<ClientRequest> requests = unsent.get(node); return requests == null ? Collections.<ClientRequest>emptyIterator() : requests.iterator(); }
/** * Clear the buffered data which are not a part of newly assigned partitions * * @param assignedPartitions newly assigned {@link TopicPartition} */ public void clearBufferedDataForUnassignedPartitions(Collection<TopicPartition> assignedPartitions) { Iterator<CompletedFetch> itr = completedFetches.iterator(); while (itr.hasNext()) { TopicPartition tp = itr.next().partition; if (!assignedPartitions.contains(tp)) { itr.remove(); } } if (nextInLineRecords != null && !assignedPartitions.contains(nextInLineRecords.partition)) { nextInLineRecords.drain(); nextInLineRecords = null; } }
@Override public void run() { Iterator<RecentlyChangedItem> it = recentlyChangedQueue.iterator(); while (it.hasNext()) { if (it.next().getLastUpdateTime() < System.currentTimeMillis() - serverConfig.getRetentionTimeInMSInDeltaQueue()) { it.remove(); } else { break; } } }
private Collection<ClientRequest> removeExpiredRequests(long now) { List<ClientRequest> expiredRequests = new ArrayList<>(); for (ConcurrentLinkedQueue<ClientRequest> requests : unsent.values()) { Iterator<ClientRequest> requestIterator = requests.iterator(); while (requestIterator.hasNext()) { ClientRequest request = requestIterator.next(); long elapsedMs = Math.max(0, now - request.createdTimeMs()); if (elapsedMs > request.requestTimeoutMs()) { expiredRequests.add(request); requestIterator.remove(); } else break; } } return expiredRequests; }
@Override public void trimExpired(long deadlineMillis) { Iterator<SchedulerQueryContext> iter = pendingQueries.iterator(); while (iter.hasNext()) { SchedulerQueryContext next = iter.next(); if (next.getArrivalTimeMs() < deadlineMillis) { iter.remove(); } } }
@Override public void internalTick(DynamicsWorld dw, float f) { for (Iterator<PhysicsTickListener> it = tickListeners.iterator(); it.hasNext();) { PhysicsTickListener physicsTickCallback = it.next(); physicsTickCallback.physicsTick(space, f); } } };
private void removeOldSpans(ConcurrentLinkedQueue<Pair<Long, SpanWrapper>> httpSpans) { for (Iterator<Pair<Long, SpanWrapper>> iterator = httpSpans.iterator(); iterator.hasNext(); ) { Pair<Long, SpanWrapper> httpSpan = iterator.next(); final long timeInBuffer = System.currentTimeMillis() - httpSpan.getA(); if (timeInBuffer > MAX_REQUEST_TRACE_BUFFERING_TIME) { iterator.remove(); } } }
/** * Callback invoked just after the physics is stepped. * <p> * This method is invoked from native code. * * @param timeStep the time per physics step (in seconds, ≥0) */ private void postTick_native(float f) { for (Iterator<PhysicsTickListener> it = tickListeners.iterator(); it.hasNext();) { PhysicsTickListener physicsTickCallback = it.next(); physicsTickCallback.physicsTick(this, f); } }
private void cleanUpCancelled() { // TODO: attempt to remove the cancelled from the beginning only (need atomic cas of head) Iterator<RegisteredSignal> iter = queue.iterator(); while (iter.hasNext()) { RegisteredSignal s = iter.next(); if (s.isCancelled()) iter.remove(); } }
/** * Returns an iterator over all non-null values in this queue. The values should be * returned in the order they were added. */ @Override public Iterator<T> iterator() { return new Itr(queue.iterator()); }
/** * Dynamically tune subscription only for the topic that dependencies need. */ @VisibleForTesting synchronized void consumerSubscriptionRebalance() { log.debug("Subscribed Topics " + this.consumer.subscription()); if (!this.subscribedTopics.isEmpty()) { final Iterator<String> iter = this.subscribedTopics.iterator(); final List<String> topics = new ArrayList<>(); while (iter.hasNext()) { topics.add(iter.next()); } this.subscribedTopics.clear(); //re-subscribe topics that are needed this.consumer.subscribe(topics); } }
@Override public void run() { synchronized (this) { removeTaskScheduled = false; } int oldSubCount = subscribers.size(); for (Iterator<WriteStreamSubscriber> iterator = subscribers.iterator(); iterator.hasNext(); ) { WriteStreamSubscriber subscriber = iterator.next(); if (subscriber.isUnsubscribed()) { iterator.remove(); } } int newSubCount = subscribers.size(); recalculateMaxPerSubscriber(oldSubCount, newSubCount); }
/** * Return how many threads are waiting * @return */ public int getWaiting() { if (!hasWaiters()) return 0; Iterator<RegisteredSignal> iter = queue.iterator(); int count = 0; while (iter.hasNext()) { Signal next = iter.next(); if (!next.isCancelled()) count++; } return count; }
public void processRequest(Request request) throws RequestProcessorException { next.processRequest(request); // The only requests that should be on toBeApplied are write // requests, for which we will have a hdr. We can't simply use // request.zxid here because that is set on read requests to equal // the zxid of the last write op. if (request.getHdr() != null) { long zxid = request.getHdr().getZxid(); Iterator<Proposal> iter = leader.toBeApplied.iterator(); if (iter.hasNext()) { Proposal p = iter.next(); if (p.request != null && p.request.zxid == zxid) { iter.remove(); return; } } LOG.error("Committed request not found on toBeApplied: " + request); } }
private void forEachOutput(final Task<ChunkedOutput<T>> t) { for (Iterator<ChunkedOutput<T>> iterator = chunkedOutputs.iterator(); iterator.hasNext(); ) { ChunkedOutput<T> chunkedOutput = iterator.next(); if (!chunkedOutput.isClosed()) { try { t.run(chunkedOutput); } catch (Exception e) { fireOnException(chunkedOutput, e); } } if (chunkedOutput.isClosed()) { iterator.remove(); fireOnClose(chunkedOutput); } } }
private void forEachOutput(final Task<ChunkedOutput<T>> t) { for (Iterator<ChunkedOutput<T>> iterator = chunkedOutputs.iterator(); iterator.hasNext(); ) { ChunkedOutput<T> chunkedOutput = iterator.next(); if (!chunkedOutput.isClosed()) { try { t.run(chunkedOutput); } catch (Exception e) { fireOnException(chunkedOutput, e); } } if (chunkedOutput.isClosed()) { iterator.remove(); fireOnClose(chunkedOutput); } } }
boolean revalidateLearnerSession(QuorumPacket qp) throws IOException { ByteArrayInputStream bis = new ByteArrayInputStream(qp.getData()); DataInputStream dis = new DataInputStream(bis); long id = dis.readLong(); boolean valid = dis.readBoolean(); Iterator<Revalidation> itr = pendingRevalidations.iterator(); if (!itr.hasNext()) { // not a learner session, handle locally return false; } Revalidation revalidation = itr.next(); if (revalidation.sessionId != id) { // not a learner session, handle locally return false; } itr.remove(); LearnerHandler learnerHandler = revalidation.handler; // create a copy here as the qp object is reused by the Follower and may be mutated QuorumPacket deepCopy = new QuorumPacket(qp.getType(), qp.getZxid(), Arrays.copyOf(qp.getData(), qp.getData().length), qp.getAuthinfo() == null ? null : new ArrayList<>(qp.getAuthinfo())); learnerHandler.queuePacket(deepCopy); // To keep consistent as leader, touch the session when it's // revalidating the session, only update if it's a valid session. if (valid) { touch(revalidation.sessionId, revalidation.timeout); } return true; }
@Override public void updateAccount(final Account account, final CallContext context) { final Iterator<Account> iterator = accounts.iterator(); while (iterator.hasNext()) { final Account account1 = iterator.next(); if (account.getId().equals(account1.getId())) { iterator.remove(); break; } } try { createAccount(account, context); } catch (final AccountApiException e) { Assert.fail(e.toString()); } }