Remove listener on A* algorithm events.

@param listener the listener.
509763
public void removeAStarListener(AStarListener<ST, PT> listener) {
		if (this.listeners != null) {
			this.listeners.remove(listener);
			if (this.listeners.isEmpty()) {
				this.listeners = null;
			}
		}
	}
450277
public void removeGroupEventListener(GroupEventListener listener)
   {
      SecurityHelper.validateSecurityPermission(PermissionConstants.MANAGE_LISTENERS);
      listeners.remove(listener);
   }
850455
@Override
    public void removeEventListener(EventListener listener) {
        if (listener instanceof SessionListener) {
            sessionListeners.remove(listener);
        }
        if (listener instanceof SessionAttributeListener) {
            sessionAttributeListeners.remove(listener);
        }
    }
1314175
function removeListener(listener) {
  if (listener) {
    const index = listeners.indexOf(listener);
    if (index >= 0) listeners.splice(index, 1);
  } else {
    listeners.splice(0, listeners.length);
  }
}
919868
public final synchronized void removeListener(EventListener l) {
        if(l ==null) {
            throw new IllegalArgumentException("Listener " + l +
                                               " is null");
        }

        // Is l on the list?
        int index = -1;
        for(int i = listeners.length-1; i>=0; i--) {
            if(listeners[i].equals(l) == true) {
                index = i;
                break;
            }
        }

        // If so,  remove it
        if(index != -1) {
            EventListener[] tmp = new EventListener[listeners.length-1];
            // Copy the list up to index
            System.arraycopy(listeners, 0, tmp, 0, index);
            // Copy from two past the index, up to
            // the end of tmp (which is two elements
            // shorter than the old list)
            if(index < tmp.length)
                System.arraycopy(listeners, index+1, tmp, index, 
                                 tmp.length - index);
            // set the listener array to the new array or null
            listeners = (tmp.length == 0) ? EMPTY_LISTENERS : tmp;
        }
    }
494104
public void removeListener( IDmListener listener ) {

		if( listener != null ) {
			synchronized( this.dmListeners ) {
				this.dmListeners.remove( listener );
			}

			this.logger.info( "The listener '" + listener.getId() + "' is not available anymore in Roboconf's DM." );
		} else {
			this.logger.info( "An invalid DM listener was removed." );
		}

		listListeners();
	}
805321
@Override
  public void removeListener(LifecycleListener listener)
  {
    synchronized(_lock)
    {
      if(_listeners != null && _listeners.contains(listener))
      {
        Set<LifecycleListener> listeners = new HashSet<LifecycleListener>(_listeners);
        listeners.remove(listener);

        // no more listeners... stopping the dispatcher
        if(listeners.size() == 0)
        {
          listeners = null;
          
          if(_stateChangeDispatcher != null)
          {
            _stateChangeDispatcher.end();
            _stateChangeDispatcher = null;
          }
        }

        if(listeners == null)
          _listeners = null;
        else
          _listeners = Collections.unmodifiableSet(listeners);
      }

    }
  }
552146
synchronized Collection<ProbeImpl> removeProbesByListener(ProbeListener listener) {
        Set<ProbeImpl> listenerProbes = probesByListener.remove(listener);
        if (listenerProbes == null) {
            listenerProbes = Collections.emptySet();
        }
        return listenerProbes;
    }
1069408
public void removeListener(EnvLoaderListener listener)
  {
    super.removeListener(listener);
    
    ArrayList<EnvLoaderListener> listeners = _listeners;
    
    if (_listeners == null)
      return;

    synchronized (listeners) {
      for (int i = listeners.size() - 1; i >= 0; i--) {
        EnvLoaderListener oldListener = listeners.get(i);

        if (listener == oldListener) {
          listeners.remove(i);
          return;
        }
        else if (oldListener == null) {
          listeners.remove(i);
        }
      }
    }
  }
1154826
public void removeListener(ILabelProviderListener listener)
	{
		if (fListeners != null)
		{
			fListeners.remove(listener);
			if (fListeners.isEmpty() && fProblemChangedListener != null)
			{
				VdmUIPlugin.getDefault()
						.getProblemMarkerManager()
						.removeListener(fProblemChangedListener);
				fProblemChangedListener = null;
			}
		}
	}
24585
<T extends EventListener> void remove(Class<T> type, T listener) {

        for (TangoListener tangoListener : tangoListeners) {
            if (tangoListener.type==type && tangoListener.listener==listener) {
                tangoListeners.remove(tangoListener);
                break;
            }
        }
    }
1189866
public <T extends CacheSpec<K, V>> T removalListener(RemovalListener<K, V> listener) {
      this.removalListener = listener;
      return Cast.as(this);
   }
631992
public void removeListener(EventListener l) {
        if (l == null) {
            throw new NullPointerException();
        }
        synchronized (notifyLock) {
            if (listeners != null) {
                // identity equality check
                Iterator<EventListener> iter = listeners.iterator();
                while (iter.hasNext()) {
                    if (iter.next() == l) {
                        iter.remove();
                        if (listeners.size() == 0) {
                            listeners = null;
                        }
                        return;
                    }
                }
            }
        }
    }
95886
public void removeListener(UserTransactionListener listener)
   {
      UserTransactionListenerImpl impl = listeners.get(listener);

      if (impl != null)
      {
         delegator.removeListener(impl);
         listeners.remove(listener);
      }
   }
713173
public void removePostSelectionChangedListener(
			ISelectionChangedListener listener)
	{
		if (fOutlineViewer != null)
		{
			fOutlineViewer.removePostSelectionChangedListener(listener);
		} else
		{
			fPostSelectionChangedListeners.remove(listener);
		}
	}
427351
public void removeListener(WindowListener<K,R,P> listener) {
        this.listeners.remove(new UnwrappedWeakReference<WindowListener<K,R,P>>(listener));
    }
840552
synchronized void deleteListener(final AbstractEventListener<?> listener) {
        final String eventType = listener.getEventType();
        if (null == eventType) {
            throw new NullPointerException();
        }

        final List<AbstractEventListener<?>> listenerList = listeners.get(eventType);
        if (null != listenerList) {
            listenerList.remove(listener);
        }
    }