public boolean removeListener(Runnable listener) { return listeners.remove(listener); }
public boolean removeListener(Runnable listener) { return listeners.remove(listener); }
public TransferCompletionHandler removeTransferListener(TransferListener t) { listeners.remove(t); return this; }
/** * Removes an animation listener * * @param listener animation listener to be removed * @return true if listener collection has been modified */ public boolean removeAnimationListener(AnimationListener listener) { return mListeners.remove(listener); }
@Override public MetaBroadcaster removeBroadcasterListener(BroadcasterListener b) { broadcasterListeners.remove(b); return this; }
@Override public AtmosphereResource removeEventListener(AtmosphereResourceEventListener e) { listeners.remove(e); return this; }
/** * Un-register {@link ChunkedOutput} from this {@code Broadcaster} instance. * * This method does not close the {@link ChunkedOutput} being unregistered. * * @param chunkedOutput {@link ChunkedOutput} instance to un-register from this broadcaster. * @return {@code true} if the instance was unregistered, {@code false} otherwise. */ public <OUT extends ChunkedOutput<T>> boolean remove(final OUT chunkedOutput) { return chunkedOutputs.remove(chunkedOutput); }
synchronized public void sync(){ if(pendingSyncs.size() ==0){ LOG.warn("Not expecting a sync."); return; } Request r = pendingSyncs.remove(); commitProcessor.commit(r); }
@Override public void onEntryRemove(HashEntry<K, V> e) { remove( e ); // we could have multiple instances of e in accessQueue; remove them all while ( accessQueue.remove( e ) ) { continue; } }
@Override public BroadcasterFactory removeBroadcasterListener(BroadcasterListener l) { broadcasterListeners.remove(l); for (Broadcaster b : store.values()) { b.removeBroadcasterListener(l); } return this; }
private void cleanup(String id) { OutstandingRequest req = _requests.remove(id); if (req != null && !req.wasFetched()) { _queues.get(req.getFunction()).remove(req); } }
void evictExpiredWorkers() { if (!expiringWorkerQueue.isEmpty()) { long currentTimestamp = now(); for (ThreadWorker threadWorker : expiringWorkerQueue) { if (threadWorker.getExpirationTime() <= currentTimestamp) { if (expiringWorkerQueue.remove(threadWorker)) { allWorkers.remove(threadWorker); } } else { // Queue is ordered with the worker that will expire first in the beginning, so when we // find a non-expired worker we can stop evicting. break; } } } }
@Override public BroadcasterCache clearCache(String broadcasterId, String uuid, CacheMessage message) { ConcurrentLinkedQueue<CacheMessage> clientQueue = messages.get(uuid); if (clientQueue != null) { logger.trace("Removing for broadcaster {} AtmosphereResource {} cached message {}", broadcasterId, uuid, message.getMessage()); notifyRemoveCache(broadcasterId, message); clientQueue.remove(message); } return this; }
@Override public void clear() { // super.clear(); for (ATask t : tasks) { if (t.task.actualListener.equals(collapseTask)) { tasks.remove(t); } } }
synchronized public void sync(){ if(pendingSyncs.size() == 0) { LOG.warn("Not expecting a sync."); return; } Request r = pendingSyncs.remove(); if (r instanceof LearnerSyncRequest) { LearnerSyncRequest lsr = (LearnerSyncRequest)r; lsr.fh.queuePacket(new QuorumPacket(Leader.SYNC, 0, null, null)); } commitProcessor.commit(r); }
public BroadcasterTracker remove(Broadcaster b) { logger.trace("Removing {}", b.getID()); broadcasterIds.remove(b.getID()); return this; }
private synchronized QuorumPacket removeProposedPacket(long zxid) { QuorumPacket pkt = proposedPkts.peek(); if (pkt == null || pkt.getZxid() > zxid) { LOG.debug("ignore missing proposal packet for {}", Long.toHexString(zxid)); return null; } if (pkt.getZxid() != zxid) { final String m = String.format("Unexpected proposal packet on commit ack, expected zxid 0x%d got zxid 0x%d", zxid, pkt.getZxid()); LOG.error(m); throw new RuntimeException(m); } proposedPkts.remove(); return pkt; }
private void rotateClients() { PacemakerClient c = getWriteClient(); String server = servers.peek(); // Servers should be rotated **BEFORE** the old client is removed from clientForServer // or a race with getWriteClient() could cause it to be put back in the map. servers.add(servers.remove()); clientForServer.remove(server); c.shutdown(); c.close(); }
void evictExpiredWorkers() { if (!expiringWorkerQueue.isEmpty()) { long currentTimestamp = now(); for (ThreadWorker threadWorker : expiringWorkerQueue) { if (threadWorker.getExpirationTime() <= currentTimestamp) { if (expiringWorkerQueue.remove(threadWorker)) { allWorkers.remove(threadWorker); } } else { // Queue is ordered with the worker that will expire first in the beginning, so when we // find a non-expired worker we can stop evicting. break; } } } }