The same as ``ee.on``, except that the listener is automatically
        removed after being called.
179531
def once(self, event, f=None):
        
        def _wrapper(f):
            def g(*args, **kwargs):
                self.remove_listener(event, f)
                # f may return a coroutine, so we need to return that
                # result here so that emit can schedule it
                return f(*args, **kwargs)

            self._add_event_handler(event, f, g)
            return f

        if f is None:
            return _wrapper
        else:
            return _wrapper(f)
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;
	}
837047
function (el, event, fn) {
				if (typeof el.removeEventListener === "function") {
					el.removeEventListener(event, fn, false);
				} else if (el.detachEvent) {
					el.detachEvent("on" + event, fn);
				}
			}
471424
function(elem, listener) {
        var normalizedListener = function(e) {
            listener(normalizeWheelEvent(e));
        };

        EVENT_NAMES.forEach(function(name) {
            elem.addEventListener(name, normalizedListener);
        });

        return function() {
            EVENT_NAMES.forEach(function(name) {
                elem.removeEventListener(name, normalizedListener);
            });
        };

    }
709324
def remove_service_listener(self, listener):
        """"""
        for browser in self.browsers:
            if browser.listener == listener:
                browser.cancel()
                del(browser)
918477
def remove_listener(registry, listener):
    
    if listener is not None and listener in registry:
        registry.remove(listener)
        return True

    return False
1288795
protected final <T extends EventListener> void removeListener(Class<T> listenerType, T listener) {
		if (this.listeners != null) {
			this.listeners.remove(listenerType, listener);
			if (this.listeners.isEmpty()) {
				this.listeners = null;
			}
		}
	}
552146
synchronized Collection<ProbeImpl> removeProbesByListener(ProbeListener listener) {
        Set<ProbeImpl> listenerProbes = probesByListener.remove(listener);
        if (listenerProbes == null) {
            listenerProbes = Collections.emptySet();
        }
        return listenerProbes;
    }
577775
public void removeListener(RunListener listener) {
        if (listener == null) {
            throw new NullPointerException("Cannot remove a null listener");
        }
        listeners.remove(wrapIfNotThreadSafe(listener));
    }
610760
public void removeListener(LifecycleListener listener)
  {
    synchronized (this) {
      if (_listeners == null)
        return;

      for (int i = _listeners.size() - 1; i >= 0; i--) {
        LifecycleListener oldListener = _listeners.get(i).get();

        if (listener == oldListener) {
          _listeners.remove(i);

          return;
        }
        else if (oldListener == null)
          _listeners.remove(i);
      }
    }
  }
1165734
public void removeListener(KeyMatcher matcher,
            VehicleMessage.Listener listener) {
        mNotifier.unregister(matcher, listener);
    }
1235997
public void removeListener(ChangeListener listener) {
        synchronized (hsChangeListeners) {
            hsChangeListeners.remove(listener);
            changeListenerCount = hsChangeListeners.size();
            bUpdateChangeListener = true;
        }
    }
388195
def remove_listener(self, callback):
        
        listeners = filter(lambda x: x['callback'] == callback, self.listeners)
        for l in listeners:
            self.listeners.remove(l)
1274689
public static synchronized void removeListener(int fileDescriptor) {
        if (listeners.containsKey(fileDescriptor)) {
            listeners.remove(fileDescriptor);
            disableSerialDataReceiveCallback(fileDescriptor);
        }
    }
427351
public void removeListener(WindowListener<K,R,P> listener) {
        this.listeners.remove(new UnwrappedWeakReference<WindowListener<K,R,P>>(listener));
    }
1020584
def off(self, name, callback, once=False):
        

        if name not in self.event_listeners:
            return

        self.event_listeners[name].remove((callback, once))
395697
public void deattach(JainMgcpListener listener) {
        int identifier = -1;
        
        //search identifier of the specified listener 
        Set<Integer> IDs = txListeners.keySet();        
        for (Integer id : IDs) {
            if (txListeners.get(id) == listener) {
                identifier = id;
                break;
            }
        }
        
        //remove it from list if found
        if (identifier != -1) {
            txListeners.remove(identifier);
        }
    }