Removes the given EventSource listener from the listener list.

@param listener
EventSourceListener to be unregistered
766903
public void removeEventSourceListener(EventSourceListener listener) {
        LOG.entering(CLASS_NAME, "removeEventSourceListener", listener);
        if (listener == null) {
            throw new NullPointerException("listener");
        }
        listeners.remove(listener);
    }
1270055
public static <E extends Event> void unsubscribe(Class<E> event, final Listener<E> listener) {
        getEventBus().unsubscribe(event, listener);
    }
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");
    }
805321
@Override
  public void removeListener(LifecycleListener listener)
  {
    synchronized(_lock)
    {
      if(_listeners != null && _listeners.contains(listener))
      {
        Set<LifecycleListener> listeners = new HashSet<LifecycleListener>(_listeners);
        listeners.remove(listener);

        // no more listeners... stopping the dispatcher
        if(listeners.size() == 0)
        {
          listeners = null;
          
          if(_stateChangeDispatcher != null)
          {
            _stateChangeDispatcher.end();
            _stateChangeDispatcher = null;
          }
        }

        if(listeners == null)
          _listeners = null;
        else
          _listeners = Collections.unmodifiableSet(listeners);
      }

    }
  }
141071
public void unregister(final Object listener) {
		for (Class clazz = listener.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
			this.handlersByEventType.removeAll(clazz);
		}
	}
582549
public void remove(Object listener) {
		checkListenerType(listener);
		synchronized (this) {
			if (listeners == EMPTY_OBJECT_ARRAY)
				return;

			int listenersLength = listeners.length;
			int index = 0;
			for (; index < listenersLength; index++) {
				if (listeners[index] == listener) {
					break;
				}
			}
			if (index < listenersLength) {
				if (listenersLength == 1) {
					listeners = EMPTY_OBJECT_ARRAY;
				}
				else {
					Object[] tmp = new Object[listenersLength - 1];
					System.arraycopy(listeners, 0, tmp, 0, index);
					if (index < tmp.length) {
						System.arraycopy(listeners, index + 1, tmp, index, tmp.length - index);
					}
					listeners = tmp;
				}
			}
		}
	}
1285895
boolean remove(Class<?> eventClass, ListenerReferenceHolder listener) {
		lock.readLock().lock();
		TreeSet<ListenerReferenceHolder> set = listeners.get(eventClass);
		if (set != null) {
			lock.readLock().unlock();
			lock.writeLock().lock();
			try {
				return removeListenerAndSetIfNeeded(eventClass, listener, set);
			} finally {
				lock.writeLock().unlock();
			}
		}
		lock.readLock().unlock();
		return false;
	}
1260488
public final void removeLayerListener(MapLayerListener listener) {
		if (this.listeners != null) {
			this.listeners.remove(MapLayerListener.class, listener);
			if (this.listeners.isEmpty()) {
				this.listeners = null;
			}
		}
	}
450277
public void removeGroupEventListener(GroupEventListener listener)
   {
      SecurityHelper.validateSecurityPermission(PermissionConstants.MANAGE_LISTENERS);
      listeners.remove(listener);
   }
696303
public synchronized boolean removeInvalidationListener(InvalidationListener listener) {
        if (bEnableListener && listener != null) {
            eventSource.removeListener(listener);
            return true;
        }
        return false;
    }
1017200
protected Future<T> removeFromListeners(
    GenericCompletionListener<? extends Future<T>> listener) {
    if (listener == null) {
      throw new IllegalArgumentException("The listener can't be null.");
    }

    if (!isDone()) {
      synchronized(this) {
        listeners.remove(listener);
      }
    }
    return this;
  }
206904
public synchronized void removeForestListener(ForestListener listener) {
		if (this.listeners != null) {
			this.listeners.remove(listener);
			if (this.listeners.isEmpty()) {
				this.listeners = null;
			}
		}
	}
824276
public void removeConnectionEventListener(ConnectionEventListener listener) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();

        if (isTraceOn && tc.isEntryEnabled()) 
            Tr.entry(this, tc, "removeConnectionEventListener", listener);

        if (listener == null) {
            NullPointerException nullX = new NullPointerException(
                            "Cannot remove null ConnectionEventListener.");

            if (isTraceOn && tc.isEntryEnabled())
                Tr.exit(this, tc, "removeConnectionEventListener", nullX); 
            throw nullX; 
        }

        // setting the metrics to null here causes a NPE the metrics cannot be set to null
        // until the end of the destroy method.

        // Not synchronized because of the contract that add/remove event listeners will only
        // be used on ManagedConnection create/destroy, when the ManagedConnection is not
        // used by any other threads. 

        // Find matching listener in the array -- then remove it, adjust entries as
        // necessary, and adjust the counter

        // loop through the listeners
        for (int i = 0; i < numListeners; i++)
            // look for matching listener
            if (listener == ivEventListeners[i]) {
                // remove the matching listener, but don't leave a gap in the array -- the order of
                // the listeners in the array doesn't matter, so move the last listener to fill the
                // gap left by the remove, if necessary
                ivEventListeners[i] = ivEventListeners[--numListeners];
                ivEventListeners[numListeners] = null;

                if (isTraceOn && tc.isEntryEnabled())
                    Tr.exit(this, tc, "removeConnectionEventListener"); 
                return;
            }

        if (isTraceOn && tc.isEntryEnabled()) 
            Tr.exit(this, tc, "removeConnectionEventListener", "Listener not found for remove.");
    }
620644
public final void removeListener(
            @NonNull final Listener<DataType, KeyType, ViewType, ParamType> listener) {
        listeners.remove(listener);
    }
741093
public PermitsPool removeListener(AvailabilityListener listener) {
        synchronized (listeners) {
            for (Iterator<WeakReference<AvailabilityListener>> iter
                = listeners.iterator(); iter.hasNext();) {
                WeakReference<AvailabilityListener> item = iter.next();
                if (item.get() == null || item.get() == listener) {
                    iter.remove();
                }
            }
        }
        return this;
    }
980918
public synchronized void removeEventListener(EventListener listener)
    {
        _contextListeners= LazyList.remove(_contextListeners, listener);
        super.removeEventListener(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);
  }
}