Removes this {@link Source} as a listener to the {@link Backend}s
provided to the constructor.

Must be called by subclasses, or proper cleanup will not occur.
765259
@Override
    public void close() throws SourceCloseException {
        for (Backend backend : this.backends) {
            backend.removeBackendListener(this);
        }
        List<BackendCloseException> exceptions = new ArrayList<>();
        for (Backend backend : this.backends) {
            try {
                backend.close();
            } catch (BackendCloseException ex) {
                exceptions.add(ex);
            } catch (Error | RuntimeException ex) {
                exceptions.add(new BackendCloseException(ex));
            }
        }
        if (!exceptions.isEmpty()) {
            throw new SourceCloseException(exceptions.toArray(new BackendCloseException[exceptions.size()]));
        }
        this.closed = true;
    }
494104
public void removeListener( IDmListener listener ) {

		if( listener != null ) {
			synchronized( this.dmListeners ) {
				this.dmListeners.remove( listener );
			}

			this.logger.info( "The listener '" + listener.getId() + "' is not available anymore in Roboconf's DM." );
		} else {
			this.logger.info( "An invalid DM listener was removed." );
		}

		listListeners();
	}
1270055
public static <E extends Event> void unsubscribe(Class<E> event, final Listener<E> listener) {
        getEventBus().unsubscribe(event, listener);
    }
1314175
function removeListener(listener) {
  if (listener) {
    const index = listeners.indexOf(listener);
    if (index >= 0) listeners.splice(index, 1);
  } else {
    listeners.splice(0, listeners.length);
  }
}
797741
public void removeEventSourceListener(EventSourceListener listener) {
        LOG.entering(CLASS_NAME, "removeEventSourceListener", listener);
        _getDelegate().removeEventSourceListener(listener);
    }
402724
def remove_listener(self, listener):
        
        internal_listener = self._internal_listeners.pop(listener)
        return self._client.remove_listener(internal_listener)
369110
public void removeListener(BaseListener listener, boolean bFreeListener)
    {
        if (m_listener != null)
        {
            if (m_listener == listener)
            {
                m_listener = (FieldListener)listener.getNextListener();
                listener.unlink(bFreeListener);     // remove theBehavior from the linked list
            }
            else
                m_listener.removeListener(listener, bFreeListener);
        } // Remember to free the listener after removing it!
    }
218816
public void removeListener(byte[] listenerId) {
      boolean removed = listeners.removeIf(id -> Arrays.equals(id, listenerId));
      if (trace) {
         log.tracef("Decoder %08X removed? %s listener %s", hashCode(), Boolean.toString(removed), Util.printArray(listenerId));
      }
   }
552146
synchronized Collection<ProbeImpl> removeProbesByListener(ProbeListener listener) {
        Set<ProbeImpl> listenerProbes = probesByListener.remove(listener);
        if (listenerProbes == null) {
            listenerProbes = Collections.emptySet();
        }
        return listenerProbes;
    }
1235997
public void removeListener(ChangeListener listener) {
        synchronized (hsChangeListeners) {
            hsChangeListeners.remove(listener);
            changeListenerCount = hsChangeListeners.size();
            bUpdateChangeListener = true;
        }
    }
1006703
public void removeChangeListener(javax.swing.event.ChangeListener LISTENER) {
        LISTENER_LIST.remove(javax.swing.event.ChangeListener.class, LISTENER);
    }
1274689
public static synchronized void removeListener(int fileDescriptor) {
        if (listeners.containsKey(fileDescriptor)) {
            listeners.remove(fileDescriptor);
            disableSerialDataReceiveCallback(fileDescriptor);
        }
    }
43835
public void removeConnectionEventListener(ConnectionEventListener listener) {
    log.finest("removeConnectionEventListener()");
    if (listener == null)
      throw new IllegalArgumentException("Listener is null");
    listeners.remove(listener);
  }
1229379
@Override
	public void removeListeners(String nodeID) {
		boolean found = false;
		writeLock.lock();
		try {
			Iterator<HashMap<String, Strategy<ListenerEndpoint>>> groupIterator = listeners.values().iterator();
			while (groupIterator.hasNext()) {
				HashMap<String, Strategy<ListenerEndpoint>> groups = groupIterator.next();
				Iterator<Strategy<ListenerEndpoint>> strategyIterator = groups.values().iterator();
				while (strategyIterator.hasNext()) {
					Strategy<ListenerEndpoint> strategy = strategyIterator.next();
					if (strategy.remove(nodeID)) {
						found = true;
						if (strategy.isEmpty()) {
							strategyIterator.remove();
						}
					}
				}
				if (groups.isEmpty()) {
					groupIterator.remove();
				}
			}
		} finally {

			// Clear caches
			if (found) {
				emitterCache.clear();
				broadcasterCache.clear();
				localBroadcasterCache.clear();
			}

			writeLock.unlock();
		}
	}
1373914
public void removeListener(Listener listener) {
    queue.remove(listener);

    if (queue.isEmpty()) {
      synchronized (queue) {
        if (currentScheduledFrequency.get() > 0 && queue.isEmpty()) {
          currentScheduledFrequency.set(-1);
        }
      }

    }
  }
620644
public final void removeListener(
            @NonNull final Listener<DataType, KeyType, ViewType, ParamType> listener) {
        listeners.remove(listener);
    }
756905
public synchronized boolean removeChangeListener(ChangeListener listener) {
        if (bEnableListener && listener != null) {
            eventSource.removeListener(listener);
            return true;
        }
        return false;
    }