Unregisters specified handler.

@param id Handler ID
@return Handler, or null if none
@see #register
13217
public static ConnectionHandler unregister(final String id) {
        if (id == null || id.length() == 0) {
            return null; // Not possible
        } // end of if

        return handlers.remove(id);
    }
276247
@Override
    public void removeSession(String id) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            String s = id + appNameForLogging;
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, "removeSession", s);
        }
        Object removedEntry = _sessions.remove(id);
        if (removedEntry != null) {
            _storeCallback.sessionLiveCountDec(removedEntry);
        }
    }
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
688804
public void unregisterService(String serviceName, String providerId) {
        getServiceDirectoryClient().unregisterInstance(serviceName, providerId, disableOwnerError);
    }
614086
public final synchronized void removeId(long id)
	{
		if (tc.isEntryEnabled()) Tr.entry(tc, "removeId", new Long(id));

		_idMap.remove(id);

		if (tc.isEntryEnabled()) Tr.exit(tc, "removeId");
	}
1112930
public function unregisterActionId($id)
    {
        if (is_array($id)) {
            foreach ($id as $each) {
                $this->unregisterActionId($each);
            }
            return $this;
        }

        foreach ($this->_actionhandler as $i => &$handlerinfo) {
            if ($handlerinfo['id'] == $id) {
                unset($this->_actionhandler[$i]);

                $this->log(SMARTIRC_DEBUG_ACTIONHANDLER, 'DEBUG_ACTIONHANDLER: '
                    .'actionhandler('.$id.') unregistered', __FILE__, __LINE__
                );
                $this->_actionhandler = array_values($this->_actionhandler);
                return $this;
            }
        }

        $this->log(SMARTIRC_DEBUG_ACTIONHANDLER, 'DEBUG_ACTIONHANDLER: could '
            .'not find actionhandler id: '.$id.' _not_ unregistered',
            __FILE__, __LINE__
        );
        return false;
    }
40574
public function unregister($event=null)
    {
        if(!empty($event) && $event != '*')
            $this->_handlers[$event] = array();
        else
            $this->_handlers = array();

        return $this;
    }
504280
@Override
    public void deleted(String pid) {
        final ServiceRegistration<T> registration = registrations.get(pid);
        if (registration != null) {
            LOGGER.info("Unregistering OSGi service for pid \"{}\"...", pid);
            final T service = bundleContext.getService(registration.getReference());
            registration.unregister();
            LOGGER.info("Destroying service object for pid \"{}\"...", pid);
            destroy(pid, service);
        }
    }
372891
void unregisterUse() {
		final int value = this.uses.decrementAndGet();
		if (value == 0) {
			uninstall(UninstallationStage.PRE_DESTROY_EVENT);
			uninstall(UninstallationStage.POST_DESTROY_EVENT);
		}
	}
185635
def unregister_handler(self, handler_or_func):
        
        index = -1
        for i, handler in enumerate(self._direct_handlers):
            if handler is handler_or_func or handler._original_func is handler_or_func:
                index = i
                break
        if index >= 0:
            self._direct_handlers.pop(index)
            self._cached_handlers = None

        elif self.parent_class_hook is not None and self.parent_class_hook.has_handler(handler_or_func):
            self.parent_class_hook.unregister_handler(handler_or_func)
            self._cached_handlers = None

        elif self.instance_class_hook is not None and self.instance_class_hook.has_handler(handler_or_func):
            self.instance_class_hook.unregister_handler(handler_or_func)
            self._cached_handlers = None

        else:
            raise ValueError('{} is not a registered handler of {}'.format(handler_or_func, self))
238195
@DeleteOperation(produces = {ActuatorMediaType.V2_JSON, "application/vnd.cas.services+yaml", MediaType.APPLICATION_JSON_VALUE})
    public RegisteredService deleteService(@Selector final String id) {
        if (NumberUtils.isDigits(id)) {
            val svc = this.servicesManager.findServiceBy(Long.parseLong(id));
            if (svc != null) {
                return this.servicesManager.delete(svc);
            }
        } else {
            val svc = this.servicesManager.findServiceBy(id);
            if (svc != null) {
                return this.servicesManager.delete(svc);
            }
        }
        LOGGER.warn("Could not locate service definition by id [{}]", id);
        return null;
    }
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");
    }
606670
public boolean removeHandler(PacketHandler handler) {
        synchronized (this.handlers) {
            boolean removed = this.handlers.remove(handler);
            if (removed) {
                this.count.decrementAndGet();
            }
            return removed;
        }
    }
1176149
void unregister(AbstractAppHandle handle) {
    for (Map.Entry<String, AbstractAppHandle> e : secretToPendingApps.entrySet()) {
      if (e.getValue().equals(handle)) {
        String secret = e.getKey();
        secretToPendingApps.remove(secret);
        break;
      }
    }

    unref();
  }
994219
public function registerEventHandler($id, $handler)
    {
        if ($handler === null) {
            unset($this->handlerMap[$id]);
        } else {
            $this->handlerMap[$id] = $handler;
        }
    }
1333968
public void unregister(Object eventListener) throws MangooEventBusException {
        Objects.requireNonNull(eventListener, Required.EVENT_LISTENER.toString());
        
        try {
            this.eventBus.unregister(eventListener);
        } catch (IllegalArgumentException e) {
            throw new MangooEventBusException(e);
        }

        if (this.listeners.get() > 0) {
            this.listeners.getAndDecrement();            
        }
    }
44071
private void unregisterTask(final ExecutionVertexID id) {

		// Task de-registration must be atomic
		synchronized (this) {

			final Task task = this.runningTasks.remove(id);
			if (task == null) {
				LOG.error("Cannot find task with ID " + id + " to unregister");
				return;
			}

			// remove the local tmp file for unregistered tasks.
			for (Entry<String, String> e: DistributedCache.getCachedFile(task.getEnvironment().getJobConfiguration())) {
				this.fileCache.deleteTmpFile(e.getKey(), task.getJobID());
			}
			// Unregister task from the byte buffered channel manager
			this.channelManager.unregister(id, task);

			// Unregister task from profiling
			task.unregisterProfiler(this.profiler);

			// Unregister task from memory manager
			task.unregisterMemoryManager(this.memoryManager);

			// Unregister task from library cache manager
			try {
				LibraryCacheManager.unregister(task.getJobID());
			} catch (IOException e) {
				if (LOG.isDebugEnabled()) {
					LOG.debug("Unregistering the job vertex ID " + id + " caused an IOException");
				}
			}
		}
	}