Clear event by name.

@param {EventEmitter} emitter Reference to the `EventEmitter` instance.
@param {(string|Symbol|number)} evt The Event name.
@private
494163
function clearEvent(emitter, evt) {
  if (--emitter._eventsCount === 0) emitter._events = new Events();
  else delete emitter._events[evt];
}
307660
function off (state, eventName, handler) {
  if (arguments.length === 2) {
    state.emitter.removeAllListeners(eventName)
  } else {
    state.emitter.removeListener(eventName, handler)
  }

  return state.api
}
108302
function (evt) {
    const clearedEls = evt.detail[this.data.colliderEndEventProperty]
    if (clearedEls) {
      if (Array.isArray(clearedEls)) {
        clearedEls.forEach(el => this._unHover(el))
      } else {
        this._unHover(clearedEls)
      }
    }
  }
1243283
function eventToPromise (emitter, event, opts) {
  var cancel
  var promise = new Promise(function (resolve, reject) {
    var addEvent = makeEventAdder(emitter, opts && opts.array)
    cancel = function () {
      cancel = noop
      addEvent.cleanUp()
    }

    addEvent(event, resolve)

    if (!opts || !opts.ignoreErrors) {
      addEvent((opts && opts.error) || 'error', reject)
    }
  })
  promise.cancel = function () { return cancel() }

  return promise
}
856548
function _off(sel, evt, fn) {
    $each(_bound(sel, evt, fn), (e) => {
        if (`on${e.evt}` in _doc) {
            e.el.removeEventListener(e.evt, e.cb);
        } else if (custom[e.evt]) {
            custom[e.evt][1](e.el, e.cb);
        }

        bound.splice(bound.indexOf(e), 1);
    });
}
484581
function (evt) {
                var args = mapReadyHandlerArgs[evt.mapId];
                if (args) {
                    this._triggerLoadingIndicator(args.container, false);
                    delete mapReadyHandlerArgs[evt.mapId];
                    this._listeners--;
                    if (this._listeners === 0) {
                        this.mapManager.$removeListeners({
                            "mapReady" : {
                                fn : this._removeLoadingIndicator,
                                scope : this
                            }
                        });
                    }

                }
            }
1064001
def remove_event(self, name=None, time=None, chan=None):
        """"""
        self.annot.remove_event(name=name, time=time, chan=chan)
        self.update_annotations()
619316
function Emitter(constructor) {
  if("function" == typeof constructor) {
    constructor(emit)
  }else{
    constructor = null
  }
  
  var listeners = []

  // emitter(listener:Function) -> removeListener:Function
  // emitter() -> emitter:function
  var emitter = function (listener) {
    // emitter() -> emitter:function
    if(!listener) {
      return emitter
    }
    // emitter(listener:Function) -> removeListener:Function
    if("function" !== typeof listener) {
      throw new Error('Listener must be a function')
    }
    var newLength = listeners.push(listener)
      , index = newLength-1
      , removed = false
    
    return function removeListener() {
      if(removed) return
      removed = true
      listeners.splice(index, 1)
    }
  }
  
  if(!constructor) {
    // emitter.emit(args...)
    emitter.emit = emit
  }
  
  return emitter
  
  function emit() {
    var args = arguments
    listeners.forEach(function(listener) {
      listener.apply(null, args)
    })
  }
}
137661
public void cancel(final String eventName) {

        BurstEvent oe = m_memory.remove(eventName);
        if (oe != null) {
            // disable the old event.
            oe.getTimer().cancel();
        }
    }
471781
function(object, events, callback) {
      var listeners = this._listeners;
      if (!listeners) return;
      if (object) {
        object.off(events, callback, this);
        if (!events && !callback) delete listeners[object._listenerId];
      } else {
        for (var id in listeners) {
          listeners[id].off(null, null, this);
        }
        this._listeners = {};
      }
      return this;
    }
1051507
function (evt) {
      var evh = this.evtHandlers, et = evt.type;
      if (evh) {
          for (var i = 0, sz = evh.length; sz > i; i++) {
              if (evh[i].evtType === et) {
                  evh[i].executeCb(evt, this.eh, this.parent.vscope);
                  break;
              }
          }
      }
  }
28675
public function removeAllListeners($event_name = null) {
	        if (!is_null($event_name)) {
	            unset($this->listeners[$event_name]);
	        } else {
	            $this->listeners = array();
	        }
	    }
197130
function mergeListeners(emitter) {
      var events = emitter._events;
      _.each(events, function (fns, type) {
        if (Array.isArray(fns)) {
          _.each(fns, function (fn) {
            if (_.isFunction(fn)) {
              self.on(type, fn);
            }
          });
        } else if (_.isFunction(fns)) {
          self.on(type, fns);
        }
      });
    }
577570
function eventEmitter(ctor) {
  for (var prop in EventEmitter.prototype) {
    if (EventEmitter.prototype.hasOwnProperty(prop)) {
      ctor.prototype[prop] = EventEmitter.prototype[prop];
    }
  }
}
346497
function removeEvent ( namespacedEvent ) {

            var event = namespacedEvent && namespacedEvent.split('.')[0];
            var namespace = event && namespacedEvent.substring(event.length);

            Object.keys(scope_Events).forEach(function( bind ){

                var tEvent = bind.split('.')[0],
                    tNamespace = bind.substring(tEvent.length);

                if ( (!event || event === tEvent) && (!namespace || namespace === tNamespace) ) {
                    delete scope_Events[bind];
                }
            });
        }
7675
function(target, events) {
      for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) {
        this.removeEvent(target, e);
      }
    }
5519
function eventData(emitter) {
	return emitter[eventEmitter.EVENT_DATA_PROPERTY] || Object.defineProperty(emitter, eventEmitter.EVENT_DATA_PROPERTY, {
		value: {},
		enumerable: false
	})[eventEmitter.EVENT_DATA_PROPERTY];
}