Fires roster exchange listeners.
165382
private void fireRosterExchangeListeners(Jid from, Iterator<RemoteRosterEntry> remoteRosterEntries) {
        RosterExchangeListener[] listeners;
        synchronized (rosterExchangeListeners) {
            listeners = new RosterExchangeListener[rosterExchangeListeners.size()];
            rosterExchangeListeners.toArray(listeners);
        }
        for (RosterExchangeListener listener : listeners) {
            listener.entriesReceived(from, remoteRosterEntries);
        }
    }
994827
protected void fireAfterPersist() {
        PersistableListener l = _listener;
        
        if(l != null) {
            try {
                l.afterPersist();
            } catch(Exception e) {
                _log.error("failure on calling afterPersist", e);
            }
        }
    }
593067
def _cleanup(self):
        '''
        
        '''
        self._declare_cb = None
        self._delete_cb = None
        super(ExchangeClass, self)._cleanup()
625796
public void sendEventsFromQueue() {
        if (null == queue || stopSending) {
            return;
        }
        LOG.fine("Scheduler called for sending events");

        int packageSize = getEventsPerMessageCall();

        while (!queue.isEmpty()) {
            final List<Event> list = new ArrayList<Event>();
            int i = 0;
            while (i < packageSize && !queue.isEmpty()) {
                Event event = queue.remove();
                if (event != null && !filter(event)) {
                    list.add(event);
                    i++;
                }
            }
            if (list.size() > 0) {
                executor.execute(new Runnable() {
                    public void run() {
                        try {
                            sendEvents(list);
                        } catch (MonitoringException e) {
                            e.logException(Level.SEVERE);
                        }
                    }
                });

            }
        }

    }
433952
public void send(Roster roster, Jid targetUserID) throws NotConnectedException, InterruptedException {
        // Create a new message to send the roster
        Message msg = new Message(targetUserID);
        // Create a RosterExchange Package and add it to the message
        RosterExchange rosterExchange = new RosterExchange(roster);
        msg.addExtension(rosterExchange);

        XMPPConnection connection = weakRefConnection.get();
        // Send the message that contains the roster
        connection.sendStanza(msg);
    }
401482
private void fireOnUnbind(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onUnbind(e);
        }
    }
187772
private void fireMemberRemoved(MemberId exMember) {
        GL.debug(GL.CLUSTER_LOGGER_NAME, "Firing member removed for: {}", exMember);
        for (MembershipEventListener listener : membershipEventListeners) {
            try {
                listener.memberRemoved(exMember);
            } catch (Throwable e) {
                GL.error(GL.CLUSTER_LOGGER_NAME, "Error in member removed event {}", e);
            }
        }
    }
1170062
private void fireOnRecoverBasic(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onRecoverBasic(e);
        }
    }
840630
protected void fireKNNsRemoved(DBIDs removals, DBIDs updates) {
    KNNChangeEvent e = new KNNChangeEvent(this, KNNChangeEvent.Type.DELETE, removals, updates);
    Object[] listeners = listenerList.getListenerList();
    for(int i = listeners.length - 2; i >= 0; i -= 2) {
      if(listeners[i] == KNNListener.class) {
        ((KNNListener) listeners[i + 1]).kNNsChanged(e);
      }
    }
  }
826462
public void fireQueryChanged(String newgroup, String newquery, String newid) {
		for (SavedQueriesPanelListener listener : listeners) {
			listener.selectedQueryChanged(newgroup, newquery, newid);
		}
	}
644816
protected void fireLabelProviderChanged(
			final LabelProviderChangedEvent event)
	{
		Object[] listeners = fListeners.getListeners();
		for (int i = 0; i < listeners.length; ++i)
		{
			final ILabelProviderListener l = (ILabelProviderListener) listeners[i];
			SafeRunner.run(new SafeRunnable()
			{
				public void run()
				{
					l.labelProviderChanged(event);
				}
			});
		}
	}
519625
public void removeAllAppenders() {
        for (Appender appender : aai.getAppenders()) {
            aai.removeAppender(appender);
            fireRemoveAppenderEvent(appender);
        }
    }
537377
def remove_listener(self, uid):
        """"""
        self.listeners[:] = (listener for listener in self.listeners
                             if listener['uid'] != uid)
688783
private void fireCandidatePairSelectedEvent() {
		// Stop the ICE Agent
		this.stop();

		// Fire the event to all listener
		List<IceEventListener> listeners;
		synchronized (this.iceListeners) {
			listeners = new ArrayList<IceEventListener>(this.iceListeners);
		}

		SelectedCandidatesEvent event = new SelectedCandidatesEvent(this);
		for (IceEventListener listener : listeners) {
			listener.onSelectedCandidates(event);
		}
	}
1312532
private void processMessages(int idx) {
        LOG.finest("Processing thread " + idx + " starting...");
        try {
            HTTPExchange exch;
            do {
                exch = nextExchange(idx);
                if (exch == null) {
                    break;
                }

                // Test hook to manipulate what the client sees:
                ExchangeInterceptor interceptor = exchInterceptor.get();
                if (interceptor != null) {
                    HTTPExchange newExch = interceptor.interceptExchange(exch);
                    if (newExch == null) {
                        LOG.log(Level.FINE, "Discarding exchange on request "
                                + "of test hook: RID="
                                + exch.getRequest().getAttribute(
                                    Attributes.RID));
                        lock.lock();
                        try {
                            exchanges.remove(exch);
                        } finally {
                            lock.unlock();
                        }
                        continue;
                    }
                    exch = newExch;
                }

                processExchange(idx, exch);
            } while (true);
        } finally {
            LOG.log(Level.FINEST, "Processing thread exiting: " + idx);
        }

    }
849044
def remove_listener(self, event_name, listener):
        """"""
        self.listeners[event_name].remove(listener)
        return self
564305
public function close(): void
    {
        if ($this->closed) {
            return;
        }

        $this->emit('end', [$this]);
        $this->loop->cancelTimer($this->timer);
        $this->removeAllListeners();
        $this->exchange = null;
        $this->closed = true;
    }