Removes an already registered connection event listener from the ManagedConnection instance.

@param listener already registered connection event listener to be removed
9438
@Override
    public void removeConnectionEventListener( ConnectionEventListener listener ) {
        if (listener == null) {
            throw new IllegalArgumentException("Listener is null");
        }
        listeners.remove(listener);
    }
663075
protected void unregister(IEventListener listener) {
        log.debug("unregister - listener: {}", listener);
        if (listeners.remove(listener)) {
            listenerStats.decrement();
        }
    }
572154
public void removeMouseListener(MouseListener listener) {
		mouseListeners.remove(listener);
		mouseListenersToAdd.remove(listener);
		
		if (!controllerListeners.contains(listener) && !keyListeners.contains(listener)) {
			allListeners.remove(listener);
		}
	}
640982
public void removeEventListener(EventType eventType, Consumer<PrimitiveEvent> listener) {
    executor.execute(() -> eventListeners.computeIfAbsent(eventType.canonicalize(), e -> Sets.newLinkedHashSet()).remove(listener));
  }
755447
public synchronized void removePropertyChangeListener(java.beans.PropertyChangeListener listener)
    {
        if (propertyChange != null)
            propertyChange.removePropertyChangeListener(listener);
    }
45120
public synchronized void removeGeoQueryEventListener(final GeoQueryDataEventListener listener) {
        if (!eventListeners.contains(listener)) {
            throw new IllegalArgumentException("Trying to remove listener that was removed or not added!");
        }
        eventListeners.remove(listener);
        if (!this.hasListeners()) {
            reset();
        }
    }
616339
public boolean removeConnectedEventListener(PeerConnectedEventListener listener) {
        boolean result = ListenerRegistration.removeFromList(listener, peerConnectedEventListeners);
        for (Peer peer : getConnectedPeers())
            peer.removeConnectedEventListener(listener);
        for (Peer peer : getPendingPeers())
            peer.removeConnectedEventListener(listener);
        return result;
    }
521081
public void removeLoggerEventListener(final LoggerEventListener listener) {
    synchronized (loggerEventListeners) {
      HierarchyEventListenerProxy proxy =
              (HierarchyEventListenerProxy) loggerEventListeners.get(listener);
      if (proxy == null) {
        LogLog.warn(
          "Ignoring attempt to remove a non-registered LoggerEventListener.");
      } else {
        loggerEventListeners.remove(listener);
        proxy.disable();
      }
    }
  }
591491
@Override
    public void removeConnectionListener(SICoreConnectionListener listener)
    {
        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
            SibTr.entry(CoreSPIConnection.tc, "removeConnectionListener",
                        new Object[] { this, listener });

        // Synchronize on the _connectionListeners object, 
        synchronized (_connectionListeners)
        {
            _connectionListeners.remove(listener);
        }

        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
            SibTr.exit(CoreSPIConnection.tc, "removeConnectionListener");
    }
840552
synchronized void deleteListener(final AbstractEventListener<?> listener) {
        final String eventType = listener.getEventType();
        if (null == eventType) {
            throw new NullPointerException();
        }

        final List<AbstractEventListener<?>> listenerList = listeners.get(eventType);
        if (null != listenerList) {
            listenerList.remove(listener);
        }
    }
980918
public synchronized void removeEventListener(EventListener listener)
    {
        _contextListeners= LazyList.remove(_contextListeners, listener);
        super.removeEventListener(listener);
    }
1352388
public void removeListener(InstallEventListener listener) {
        if (listenersMap != null) {
            for (Collection<InstallEventListener> listeners : listenersMap.values()) {
                listeners.remove(listener);
            }
        }
    }
683693
public boolean removeEventListener(IEventListener listener) {
        log.debug("removeEventListener - scope: {} {}", getName(), listener);
        if (log.isTraceEnabled()) {
            log.trace("Listeners - check #1: {}", listeners);
        }
        boolean removed = listeners.remove(listener);
        if (!keepOnDisconnect) {
            if (removed && keepAliveJobName == null) {
                if (ScopeUtils.isRoom(this) && listeners.isEmpty()) {
                    // create job to kill the scope off if no listeners join within the delay
                    ISchedulingService schedulingService = (ISchedulingService) parent.getContext().getBean(ISchedulingService.BEAN_NAME);
                    // by default keep a scope around for a fraction of a second
                    keepAliveJobName = schedulingService.addScheduledOnceJob((keepDelay > 0 ? keepDelay * 1000 : 100), new KeepAliveJob(this));
                }
            }
        } else {
            log.trace("Scope: {} is exempt from removal when empty", getName());
        }
        if (log.isTraceEnabled()) {
            log.trace("Listeners - check #2: {}", listeners);
        }
        return removed;
    }
289806
@Override
    public void removeServiceListener(ServiceListener listener) {
        // Note: if unfiltered service listeners are implemented
        // This method needs to look for, and remove, the listener there
        // as well

        // Go through all of the filters, and for each filter
        // remove the listener from the filter's list.
        for(Entry<String, List<ServiceListener>> filteredList : filteredServiceListeners.entrySet()) {
            filteredList.getValue().remove(listener);
        }
    }
1171031
public boolean removeNotificationListener(String mbeanName, NotificationListener listener) throws Exception {
        if (isConnected()) {
            ObjectName objectName = new ObjectName(mbeanName);
            mbsc.removeNotificationListener(objectName, listener, null, null);
            jmxc.removeConnectionNotificationListener(listener);
            return true;
        } else {
            return false;
        }
    }
227499
public synchronized boolean removePreInvalidationListener(PreInvalidationListener listener) {
        if (bEnableListener && listener != null) {
            eventSource.removeListener(listener);
            return true;
        }
        return false;
    }
646677
public void removeConnection(WebSocketConnection conn) {
        conns.remove(conn);
        for (IWebSocketDataListener listener : listeners) {
            listener.onWSDisconnect(conn);
        }
    }