Unload the event list.

@param wave the wave received
491287
public void doUnload(final Wave wave) {
        this.eventList = new ArrayList<>();

        final Collection<BallModel> list = new ArrayList<>(this.ballMap.values());

        for (final BallModel ballModel : list) {
            unregisterBall(ballModel);
        }
    }
641035
public void unload() {
        deactivate();
        if (getAntecedent() != null) {
            getAntecedent().unload();
        }
        if (getConsequent() != null) {
            getConsequent().unload();
        }
    }
486617
@MainThread
    private void handleUnRegistration(Object targetObj) {
        if (targetObj == null) {
            throw new NullPointerException("Target cannot be null");
        }

        EventTarget target = null;

        for (Iterator<EventTarget> iterator = targets.iterator(); iterator.hasNext(); ) {
            EventTarget listTarget = iterator.next();
            if (listTarget.targetObj == targetObj) {
                iterator.remove();
                target = listTarget;
                target.targetObj = null;
                break;
            }
        }

        if (target == null) {
            Utils.logE(targetObj, "Was not registered");
        }

        Utils.log(targetObj, "Unregistered");
    }
926015
private void performHandle(final Wave wave, final Method method) throws WaveException {

        // Build parameter list of the searched method
        final List<Object> parameterValues = new ArrayList<>();

        // Don't add WaveType parameters if we us the default processWave method
        if (!AbstractComponent.PROCESS_WAVE_METHOD_NAME.equals(method.getName())) {
            for (final WaveData<?> wd : wave.waveDatas()) {
                // Add only wave items defined as parameter
                if (wd.key().isParameter()) {
                    parameterValues.add(wd.value());
                }
            }
        }

        // Add the current wave to process
        parameterValues.add(wave);

        try {

            ClassUtility.callMethod(method, getWaveReady(), parameterValues.toArray());

        } catch (final CoreException e) {
            LOGGER.error(WAVE_DISPATCH_ERROR, e);
            // Propagate the wave exception
            throw new WaveException(wave, e);
        }

    }
656097
function unregister() {
    if (!applicationCurrent) {
        return;
    }
    applicationCurrent.stop();

    EVENTS.forEach(function (event) {
        process.removeListener(event, currentHandlers[event]);
    });

    applicationCurrent = null;
    currentHandlers = {};
}
356393
def unload(self):
        
        self.is_loaded = False
        for evt in self._event_cache:
            self.context.unregister(
                evt['event'], evt['callback'], evt['selector'])
        self._event_cache = {}
198175
def unhandle(self, handler):
        
        with self._hlock:
            try:
                self._handler_list.remove(handler)
            except ValueError:
                raise ValueError("Handler is not handling this event, so cannot unhandle it.")
        return self
410119
function () {
            var map = this._getInitialListenersList();
            for (var i = 0; i < map.length; i++) {
                this._removeListener(map[i].evt, map[i].cb);
            }
            this.eventsAlreadyAttached = false;
        }
51030
public function tearDown()
    {
        foreach ($this->eventSubscriberPlugins as list($plugin, $eventSubscriber)) {
            $this->removeListeners($plugin, $eventSubscriber);
        }
    }
789517
public void onDestroy() {
    stopNavigation();
    removeOffRouteListener(null);
    removeProgressChangeListener(null);
    removeMilestoneEventListener(null);
    removeNavigationEventListener(null);
    removeFasterRouteListener(null);
    removeRawLocationListener(null);
  }
1189583
private void unclaim(String subscription, Collection<EventList> eventLists) {
        List<String> eventIdsToUnclaim = Lists.newArrayList();
        for (EventList unclaimEvents : eventLists) {
            for (Pair<String, UUID> eventAndChangeId : unclaimEvents.getEventAndChangeIds()) {
                eventIdsToUnclaim.add(eventAndChangeId.first());
            }
        }
        _eventStore.renew(subscription, eventIdsToUnclaim, Duration.ZERO, false);

    }
401482
private void fireOnUnbind(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onUnbind(e);
        }
    }
1171627
protected function unload()
    {
        foreach ($this->ial as $entry) {
            if (isset($entry['TIMER'])) {
                $this->removeTimer($entry['TIMER']);
            }
        }
    }
948068
protected static <E extends Event> void unsubscribeEvent(Class<E> eventClass, final Listener<E> listener) {
        getEventBus().unsubscribe(eventClass, listener);
    }
9319
@Override
	protected void doUnload() {
		Iterator<EObject> allContents = getAllProperContents(unloadingContents);
		// This guard is needed to ensure that clear doesn't make the resource become loaded.
		//
		if (!doGetContents().isEmpty()) {
			doGetContents().clear();
		}
		getErrors().clear();
		getWarnings().clear();
		while (allContents.hasNext()) {
			unloaded((InternalEObject) allContents.next());
		}
		setParseResult(null);
		setIsLoadedFromStorage(false);
	}
361967
public static function flushEventListeners(): void
    {
        if (! isset(static::$dispatcher)) {
            return;
        }

        $instance = new static();
        $className = static::class;

        foreach ($instance->getObservableEvents() as $event) {
            $event = $instance->getObservableKey($event);

            static::$dispatcher->forget("{$event}: {$className}");
        }
    }
719090
function dispose() {
            if (!this.disposed) {
                if (this.removeListener) {
                    this.removeListener.call(this);
                    this.removeListener = void 0;
                }

                if (this.targetUrl && this.target || this.removeDispose) {
                    try {
                        if (this.targetContainer) {
                            this.targetContainer.removeChild(this.target);
                        }
                        else {
                            document.body.removeChild(this.target);
                        }
                    }
                    catch(ex) {
                        /* istanbul ignore next  */
                        PostMessageUtilities.log("Error while trying to remove the iframe from the container", "ERROR", "PostMessageChannel");
                    }
                }

                // Remove load handler if needed
                _removeTimer.call(this);

                // Remove timer if needed
                _removeLoadedHandler.call(this);

                this.messageQueue.length = 0;
                this.messageQueue = void 0;
                this.channel = void 0;
                this.onready = void 0;
                this.disposed = true;
            }
        }