Free this listener (and remove the dependencies).
762466
public void free()                            
    {
        for (BaseListener dependentListener : m_BehaviorList)
        {
            if (dependentListener.getDependentListener() != null) // Don't delete the one that is deleting itself (and calling this method!)
            {
                dependentListener.setDependentListener(null);   // Tell listener not to delete me!
                dependentListener.free();   // Remove the listener that is dependent on "this"
            }            
        }
        super.free();
    }
806541
function()
	{
		// Cleans all objects where listeners have been added
		for (var i = 0; i < mxEvent.objects.length; i++)
		{
			if (mxEvent.objects[i].mxListenerList != null)
			{
				mxEvent.removeAllListeners(mxEvent.objects[i]);
			}
		}
	}
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;
  }
1314175
function removeListener(listener) {
  if (listener) {
    const index = listeners.indexOf(listener);
    if (index >= 0) listeners.splice(index, 1);
  } else {
    listeners.splice(0, listeners.length);
  }
}
1289993
def _remove_dependency(self, dependlist, i, isSubroutine, anexec):
        """"""
        if dependlist[i] in anexec.dependencies:
            all_depends = anexec.dependencies[dependlist[i]]
            if len(all_depends) > 0:
                clean_args = all_depends[0].clean(dependlist[i + 1])
                for idepend in range(len(all_depends)):
                    #Make sure we match across all relevant parameters
                    if (all_depends[idepend].argslist == clean_args
                        and all_depends[idepend].isSubroutine == isSubroutine):
                        del anexec.dependencies[dependlist[i]][idepend]
                        #We only need to delete one, even if there are multiple
                        #identical calls from elsewhere in the body.
                        break
80903
@Override
  public void destroy()
  {
    Thread thread = Thread.currentThread();
    ClassLoader oldLoader = thread.getContextClassLoader();
    
    try {
      thread.setContextClassLoader(this);
      
      WeakStopListener stopListener = _stopListener;
      _stopListener = null;

      super.destroy();
      
      thread.setContextClassLoader(oldLoader);

      ClassLoader parent = getParent();
      for (; parent != null; parent = parent.getParent()) {
        if (parent instanceof EnvironmentClassLoader) {
          EnvironmentClassLoader loader = (EnvironmentClassLoader) parent;

          loader.removeListener(stopListener);
        }
      }
    } finally {
      thread.setContextClassLoader(oldLoader);
      
      //_owner = null;
      _attributes = null;
      _listeners = null;
      //_scanListeners = null;
      //_stopListener = null;

      /*
      EnvironmentAdmin admin = _admin;
      _admin = null;

      if (admin != null)
        admin.unregister();
        */
    }
  }
588394
function(){

            var self = this;
            self.pause();

            // notify before
            this.emit('destroy');

            // remove all listeners
            self.off( true );
            // remove everything
            self.remove( self.getBodies() );
            self.remove( self.getBehaviors() );
            self.integrator( null );
            self.renderer( null );
        }
948660
public void free()
    {
        BaseMessageManager messageManager = null;
        if (this.getTask() != null) // May have been freed already.
            if (this.getTask().getApplication() != null)
                messageManager = (BaseMessageManager)((Application)this.getTask().getApplication()).getMessageManager(false);
        if (messageManager != null)
            messageManager.freeFiltersWithListener(this);
        if (m_messageStack != null)
            m_messageStack.free();
        m_messageStack = null;
        super.free();
    }
123443
public function killSoftDeletableListener()
    {
        foreach ($this->em->getEventManager()->getListeners() as $event => $listeners) {
            foreach ($listeners as $hash => $listener) {
                if ($listener instanceof SoftDeleteableListener) {
                    $listenerInst = $listener;
                    break 2;
                }
            }
        }

        $this->em->getEventManager()->removeEventListener(array('onFlush'), $listenerInst);
    }
678273
def removeReliableListener(self, listener):
        
        self.store.query(_ReliableListener,
                         attributes.AND(_ReliableListener.processor == self,
                                        _ReliableListener.listener == listener)).deleteFromStore()
        self.store.query(BatchProcessingError,
                         attributes.AND(BatchProcessingError.processor == self,
                                        BatchProcessingError.listener == listener)).deleteFromStore()
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);
      }
    }
  }
388195
def remove_listener(self, callback):
        
        listeners = filter(lambda x: x['callback'] == callback, self.listeners)
        for l in listeners:
            self.listeners.remove(l)
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);
                    }
                }
            }
1249974
public void unload()
    {
        if (mAudioListener != null)
        {
            Log.d("SOUND", "unloading audio source %d %s", getSourceId(), getSoundFile());
            mAudioListener.getAudioEngine().unloadSoundFile(getSoundFile());
        }
        mSoundFile = null;
        mSourceId = GvrAudioEngine.INVALID_ID;
    }
132389
public function cleanup()
    {
        $this->listeners = null;
        $this->producer = null;
        $this->args = [];
        $this->parent = null;
    }
621375
synchronized public void removeListener(Object listener)
    {
        if (!_listeners.contains(listener))
            throw new IllegalStateException("Invalid listener, not currently registered");

        _listeners.remove(listener);
    }
1284691
public void removeListener(AnimatorListener listener) {
        if (mListeners == null) {
            return;
        }
        mListeners.remove(listener);
        if (mListeners.size() == 0) {
            mListeners = null;
        }
    }