Unregister an existing chaincode event listener.

@param handle Chaincode event listener handle to be unregistered.
@return True if the chaincode handler was found and removed.
@throws InvalidArgumentException
770510
public boolean unregisterChaincodeEventListener(String handle) throws InvalidArgumentException {
        boolean ret;

        if (shutdown) {
            throw new InvalidArgumentException(format("Channel %s has been shutdown.", name));
        }

        checkHandle(CHAINCODE_EVENTS_TAG, handle);

        synchronized (chainCodeListeners) {
            ret = null != chainCodeListeners.remove(handle);

        }

        synchronized (this) {
            if (null != blh && chainCodeListeners.isEmpty()) {

                unregisterBlockListener(blh);
                blh = null;
            }
        }

        return ret;

    }
307660
function off (state, eventName, handler) {
  if (arguments.length === 2) {
    state.emitter.removeAllListeners(eventName)
  } else {
    state.emitter.removeListener(eventName, handler)
  }

  return state.api
}
878073
boolean unregisterConnection(ConnectionManager cm, ConnectionListener cl, Object c)
   {
      if (clToC != null && clToC.get(cl) != null)
      {
         List<Object> l = clToC.get(cl);
         return l.remove(c);
      }

      return false;
   }
41320
public static ConnectionHandler register(final String id, 
                                             final ConnectionHandler handler) {

        if (id == null || id.length() == 0) {
            throw new IllegalArgumentException("Invalid ID: " + id);
        } // end of if

        if (handler == null) {
            throw new IllegalArgumentException("Invalid handler: " + handler);
        } // end of if

        // ---

        return handlers.put(id, handler);
    }
565601
@Override
    public synchronized void destroyChain(ChainData chaindata) throws ChannelException, ChainException {
        String chainName = (null != chaindata) ? chaindata.getName() : null;
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "destroyChain: " + chainName);
        }

        if (null == chaindata) {
            throw new InvalidChainNameException("Null chain");
        }
        // Ensure we have an inbound chain.
        if (FlowType.OUTBOUND.equals(chaindata.getType())) {
            throw new InvalidChainNameException("Outbound chain cannot use this interface.");
        }

        // Verify the chain is in the runtime.
        Chain chain = getRunningChain(chainName);
        if (null == chain) {
            // Due to timing windows (i.e. multiple channel providers going away), there is
            // a race to destroy chains. This is not a notable condition: the chain can only be destroyed
            // once.
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "destroyChain: " + chainName + " does not exist -- may already have been destroyed");
            }
            return;
        }

        destroyChainInternal(chain);
    }
1364690
public synchronized void removeHandler(String handlerId) {
		handlerEventMap.remove(handlerId);
		Tr.event(tc, "Removed Asynchronous Handler: " + handlerId);
		if (handlerEventMap.isEmpty()) {
			ringBuffer = null;
			Tr.event(tc, "ringBuffer for this BufferManagerImpl has now been set to null");
		}
	}
288978
public void removeHandler(Handler handler) throws SecurityException {
        checkPermission();
        if (handler == null) {
            return;
        }
        handlers.remove(handler);
    }
427751
public void remove(Handle handle)
                    throws RemoteException,
                    RemoveException
    {
        homeEnabled();

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled(); // d532639.2

        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "remove", handle);

        EJBObject ejb = handle.getEJBObject();
        ejb.remove();

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "remove");
    }
763709
public final boolean register(final SelectableChannel channel, final EventsHandler handler)
    {
        return register(channel, handler, IN | OUT | ERR);
    }
186075
protected static <E extends LogRecordHandler> boolean removeHandler(Class<E> toRemove) {
    boolean rtn = false;
    Iterator<LogRecordHandler> iter = handlers.iterator();
    while(iter.hasNext()){
      if(iter.next().getClass().equals(toRemove)){
        rtn = true;
        iter.remove();
      }
    }
    return rtn;
  }
141071
public void unregister(final Object listener) {
		for (Class clazz = listener.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
			this.handlersByEventType.removeAll(clazz);
		}
	}
696303
public synchronized boolean removeInvalidationListener(InvalidationListener listener) {
        if (bEnableListener && listener != null) {
            eventSource.removeListener(listener);
            return true;
        }
        return false;
    }
961934
public void removeNotificationHandler(String serviceName, NotificationHandler handler){
        if(handler == null || serviceName == null || serviceName.isEmpty()){
            throw new IllegalArgumentException();
        }

        synchronized(notificationHandlers){
            if(notificationHandlers.containsKey(serviceName)){
                List<NotificationHandler> list = notificationHandlers.get(serviceName);
                if(list.contains(handler)){
                    list.remove(handler);
                }
                if(list.size() == 0){
                    notificationHandlers.remove(serviceName);
                }
            }
        }
    }
739384
public void removeHandler() {

        clearShowing();
        if (m_overHandlerRegistration != null) {
            m_overHandlerRegistration.removeHandler();
            m_overHandlerRegistration = null;
        }
        m_target = null;
    }
94152
@Override
  public void unregister(final Identifier id) throws IOException {
    final Link<NamingMessage> link = transport.open(serverSocketAddr, codec,
        new LoggingLinkListener<NamingMessage>());
    link.write(new NamingUnregisterRequest(id));
  }
505732
def del_handler(self, handle):
        
        _, _, _, respondent = self._handle_map.pop(handle)
        if respondent:
            self._handles_by_respondent[respondent].discard(handle)
275461
public function removeHandler( IHandler $handler = NULL )
    {
        if ( NULL !== $handler && $this->handler == $handler )
        {
            $this->handler = NULL;
        }
        else
        {
            $this->handler = NULL;
        }
    }