removeStepListener(traci.StepListener) -> bool

    Remove the step listener from traci's step listener container.
    Returns True if the listener was removed successfully, False if it wasn't registered.
545099
def removeStepListener(listener):
    
    if listener in _stepListeners:
        _stepListeners.remove(listener)
        return True
    warnings.warn(
        "removeStepListener(listener): listener %s not registered as step listener" % str(listener))
    return False
413024
def remove_framework_listener(self, listener):
        
        with self.__fw_lock:
            try:
                self.__fw_listeners.remove(listener)
                return True
            except ValueError:
                return False
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;
	}
307099
function removeListener(event, listener) {
  this._events = this._events || {};
  if(event in this._events) {
    this._events[event].splice(this._events[event].indexOf(listener), 1);
  }
  return this;
}
727226
private synchronized boolean removeWrapperFromList(EventListenerWrapper<K, V> wrapper, List<EventListenerWrapper<K, V>> listenersList) {
    int index = listenersList.indexOf(wrapper);
    if (index != -1) {
      EventListenerWrapper<K, V> containedWrapper = listenersList.remove(index);
      if(containedWrapper.isOrdered() && --orderedListenerCount == 0) {
        storeEventSource.setEventOrdering(false);
      }
      if (--listenersCount == 0) {
        storeEventSource.removeEventListener(eventListener);
      }
      return true;
    }
    return false;
  }
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);
        }
    }
1010339
def remove_listener(self, registration_id):
        
        try:
            self._listeners.pop(registration_id)
            return True
        except KeyError:
            return False
415845
public void removeProgressListener(ProgressListener pListener) {
        if (pListener == null) {
            return;
        }

        if (listeners == null) {
            return;
        }

        listeners.remove(pListener);
    }
1216935
function () {
                this.$assert(838, this._listenersStopped !== true);
                this._listenersStopped = true;
                var bindings = this._bindings;
                if (bindings) {
                    // remove binding
                    for (var index = 0, bind; bind = bindings[index]; index++) {
                        // remove the recursive listener
                        this.__json.removeListener(bind.inside, bind.to, bind.callback, bind.recursive);
                    }
                }
            }
1338089
def remove_listener(self, registration_id):
        
        try:
            self.listeners.pop(registration_id)
            return True
        except KeyError:
            return False
298764
public synchronized boolean removeStateListener(@Nonnull EndpointStateListener<VALUE_TYPE, ARG_TYPE> listener) throws IllegalArgumentException {
        checkListenerNonNull(listener);
        return fieldStateListeners.remove(listener);
    }
214286
function removeListener(uid) {
		var removedListener = false;
		if(typeof(dashboardListeners[uid]) !== 'undefined') {
			dashboardListeners[uid] = undefined;
			delete dashboardListeners[uid];
			removedListener = true;
		}
		return removedListener;
	}
730284
public boolean removeDisconnectedEventListener(PeerDisconnectedEventListener listener) {
        boolean result = ListenerRegistration.removeFromList(listener, peerDisconnectedEventListeners);
        for (Peer peer : getConnectedPeers())
            peer.removeDisconnectedEventListener(listener);
        for (Peer peer : getPendingPeers())
            peer.removeDisconnectedEventListener(listener);
        return result;
    }
537377
def remove_listener(self, uid):
        """"""
        self.listeners[:] = (listener for listener in self.listeners
                             if listener['uid'] != uid)
850455
@Override
    public void removeEventListener(EventListener listener) {
        if (listener instanceof SessionListener) {
            sessionListeners.remove(listener);
        }
        if (listener instanceof SessionAttributeListener) {
            sessionAttributeListeners.remove(listener);
        }
    }
12104
function deleteListener(event, callback, idx) {
  if ((idx = event.listeners.indexOf(callback)) >= 0) {
    event.listeners.splice(idx, 1);
    event.meta.delete(callback);
    return true;
  }
  return false;
}
451507
public function remove() {
        global $DB;

        if ($this->id === null) {
            return;
        }

        $DB->delete_records('tool_usertours_steps', array('id' => $this->id));
        $this->get_tour()->reset_step_sortorder();

        // Notify of a change to the step configuration.
        // This must be done separately to tour change notifications.
        cache::notify_step_change($this->get_id());

        // Notify the cache that a tour has changed.
        // Tours are only stored in the cache if there are steps.
        // If there step count has changed for some reason, this will change the potential cache results.
        cache::notify_tour_change();
    }