Remove a collector from the registry.
775298
def unregister(self, collector):
        """"""
        with self._lock:
            for name in self._collector_to_names[collector]:
                del self._names_to_collectors[name]
            del self._collector_to_names[collector]
1150219
def _delete(collection_name, spec, opts, flags):
    """"""
    encoded = _dict_to_bson(spec, False, opts)  # Uses extensions.
    return b"".join([
        _ZERO_32,
        _make_c_string(collection_name),
        _pack_int(flags),
        encoded]), len(encoded)
849659
def unregister(self, svc_ref):
        # type: (ServiceReference) -> Any
        
        with self.__svc_lock:
            try:
                # Try in pending services
                return self.__pending_services.pop(svc_ref)
            except KeyError:
                # Not pending: continue
                pass

            if svc_ref not in self.__svc_registry:
                raise BundleException("Unknown service: {0}".format(svc_ref))

            # Get the owner
            bundle = svc_ref.get_bundle()

            # Get the service instance
            service = self.__svc_registry.pop(svc_ref)

            for spec in svc_ref.get_property(OBJECTCLASS):
                spec_services = self.__svc_specs[spec]
                # Use bisect to remove the reference (faster)
                idx = bisect.bisect_left(spec_services, svc_ref)
                del spec_services[idx]
                if not spec_services:
                    del self.__svc_specs[spec]

            # Remove the service factory
            if svc_ref.is_factory():
                # Call unget_service for all client bundle
                factory, svc_reg = self.__svc_factories.pop(svc_ref)
                for counter in self.__factory_usage.values():
                    counter.cleanup_service(factory, svc_reg)
            else:
                # Delete bundle association
                bundle_services = self.__bundle_svc[bundle]
                bundle_services.remove(svc_ref)
                if not bundle_services:
                    # Don't keep empty lists
                    del self.__bundle_svc[bundle]

            return service
1355875
@Deprecated
    public final void remove(MeterRegistry registry) {
        for (; ; ) {
            if (childrenGuard.compareAndSet(false, true)) {
                try {
                    Map<MeterRegistry, T> newChildren = new IdentityHashMap<>(children);
                    newChildren.remove(registry);
                    this.children = newChildren;
                    break;
                } finally {
                    childrenGuard.set(false);
                }
            }
        }
    }
493030
def drop(self, items):
        
        self._manager.leaser.remove(items)
        self._manager.maybe_resume_consumer()
615263
public static void unregisterApplicationNodeInCollectServer() throws IOException {
		if (unregisterApplicationNodeInCollectServerUrl != null) {
			new LabradorRetriever(unregisterApplicationNodeInCollectServerUrl).post(null);
			LOG.info("application node removed from the collect server");
		}
	}
540729
def delete(self, **kwargs):
        
        self.reload_context(es_based=False, **kwargs)
        return super(ESCollectionView, self).delete(**kwargs)
606102
public function remove()
    {
        $this->debug->groupCollapsed(__METHOD__);
        $name = $this->data['name'];
        $this->trashCollectFiles($this->data);
        $this->data = array();
        unset($_SESSION['form_persist'][$name]);
        if (empty($_SESSION['form_persist'])) {
            unset($_SESSION['form_persist']);
        }
        $this->debug->groupEnd();
    }
236286
protected final void unregisterConsumer( AbstractMessageConsumer consumerToRemove )
    {
        if (consumersMap.remove(consumerToRemove.getId()) == null)
            log.warn("Unknown consumer : "+consumerToRemove);
    }
215840
def unregister(self, observers):
        
        """

        if isinstance(observers, list) or isinstance(observers, tuple):
            for observer in observers:
                try:
                    index = self._observers.index(observer)
                    self._observers.remove(self._observers[index])
                except ValueError:
                    # logging
                    print('{observer} not in list...'.format(observer))

        elif isinstance(observers, base.Observer):
            try:
                index = self._observers.index(observers)
                self._observers.remove(self._observers[index])
            except ValueError:
                # logging
                print('{observer} not in list...'.format(observers))

        else:
            err_message = ('ConfigReader.register support'
                           'ListType, TupleType and {observer} Object.'
                           ''.format(base.Observer.__name__)
                           )

            raise ValueError(err_message)
810614
public void unregisterConsumer( LocalMessageConsumer consumer )
    {
    	consumersLock.writeLock().lock();
    	try
    	{
    		localConsumers.remove(consumer);
    	}
    	finally
    	{
    		consumersLock.writeLock().unlock();
    	}
    }
240482
def remove(self, value, _sa_initiator=None):
        """"""

        key = self.keyfunc(value)
        # Let self[key] raise if key is not in this collection
        # testlib.pragma exempt:__ne__
        if not self.__contains__(key) or value not in self[key]:
            raise sa_exc.InvalidRequestError(
                "Can not remove '%s': collection holds '%s' for key '%s'. "
                "Possible cause: is the MappedCollection key function "
                "based on mutable properties or properties that only obtain "
                "values after flush?" %
                (value, self[key], key))
        self.__getitem__(key, _sa_initiator).remove(value)
813748
static void unregister(Object value) {
        if (value != null) {
            Map<Object, Object> m = getRegistry();
            if (m != null) {
                m.remove(value);
                if (m.isEmpty()) {
                    REGISTRY.remove();
                }
            }
        }
    }
458518
def unregister(self):
        """"""
        self.names.remove(self.uniquename)
        super(ConfigurableMeta, self).unregister()
1240908
function( model ) {
			model.unbind( 'destroy', this.unregister );
			var coll = this.getCollection( model );
			coll && coll.remove( model );
		}
71979
public void removeResultCollector(ResultCollector<?, DPO> resultCollector) {
        if (resultCollector != null) {
            removeTrigger(resultCollector);
            removeDataProvider(resultCollector);
        }
    }
1187152
public void remove()
  {
    if (tc.isEntryEnabled()) 
      SibTr.entry(tc, "remove");
    
    if (anycastIHIterator != null)
    {  
      anycastIHIterator.remove();
    }
    
    if (tc.isEntryEnabled()) 
      SibTr.exit(tc, "remove");
  }