Unregisters a condition set with the manager.

        >>> gargoyle.unregister(condition_set) #doctest: +SKIP
173124
def unregister(self, condition_set):
        
        if callable(condition_set):
            condition_set = condition_set()
        self._registry.pop(condition_set.get_id(), None)
393058
public void unregister(Collector m) {
    synchronized (collectorsToNames) {
      List<String> names = collectorsToNames.remove(m);
      for (String name : names) {
        namesToCollectors.remove(name);
      }
    }
  }
5859
def unregister_child(self, child):
        
        self._children.remove(child)
        child.on_closed.disconnect(self.unregister_child)
56610
public void unregister(String name) {
        HealthCheck healthCheck;
        synchronized (lock) {
            healthCheck = healthChecks.remove(name);
            if (healthCheck instanceof AsyncHealthCheckDecorator) {
                ((AsyncHealthCheckDecorator) healthCheck).tearDown();
            }
        }
        if (healthCheck != null) {
            onHealthCheckRemoved(name, healthCheck);
        }
    }
360385
def unregister(self, thread):
        
        if thread not in self.threads.keys():
            self.log.warning("Can not unregister thread %s" % thread)
        else:
            del (self.threads[thread])
            self.__log.debug("Thread %s got unregistered" % thread)
244519
public static void unregister(ApiFeature apiFeature) {
        JavaScriptObject scriptObject = features.get(apiFeature);
        if (scriptObject != null) {
            if (scriptObject.cast() instanceof Element) {
                Element scriptElement = scriptObject.cast();
                scriptElement.removeFromParent();
            }
        }
        features.remove(apiFeature);
    }
755436
def unregister(self):
        """"""
        uuid = self.metadata["tracker"]["uuid"]
        # connect to server
        result = requests.delete(urljoin(self.tracker, 'models' + "/" + uuid))
        logger.debug("unregistered at server %s with %s: %s", self.tracker, uuid, result)
598737
def unregister(self, entity_class, entity):
        
        EntityState.release(entity, self)
        self.__entity_set_map[entity_class].remove(entity)
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)
467304
static void unregister(final Object value) {
        Set<IDKey> registry = getRegistry();
        if (registry != null) {
            registry.remove(new IDKey(value));
            synchronized (HashCodeBuilder.class) {
                //read again
                registry = getRegistry();
                if (registry != null && registry.isEmpty()) {
                    REGISTRY.remove();
                }
            }
        }
    }
1021434
def unregisterHandler(self, fh):

        

        try:
            self.fds.remove(fh)

        except KeyError:
            pass

        self.lock.acquire()

        try:
            self.data.rollover() # rollover data on close.

        finally:
            self.lock.release()

        if self.closing and not self.fds:
            self.data.close()
906693
public void unregister() {
    context.unregisterReceiver(networkConnectionChangeReceiver);
    context.unregisterReceiver(internetConnectionChangeReceiver);
    if (wifiAccessPointsScanEnabled) {
      context.unregisterReceiver(wifiSignalStrengthChangeReceiver);
    }
  }
917749
def unbind(self, callback: typing.Union[typing.Callable, AbstractFilter]):
        
        for record in self._registered:
            if record.callback == callback:
                self._registered.remove(record)
1105791
public void unregister(ICalComponentScribe<? extends ICalComponent> scribe) {
		experimentalCompByName.remove(scribe.getComponentName().toUpperCase());
		experimentalCompByClass.remove(scribe.getComponentClass());
	}
1065573
public static void unregister() {
    synchronized (monitor) {
      checkState(handler != null, "Zipkin exporter is not registered.");
      unregister(Tracing.getExportComponent().getSpanExporter());
      handler = null;
    }
  }
302292
function unregister() {
      for (var p = d.wrapper.parentNode; p && p != document.body; p = p.parentNode) {}
      if (p) setTimeout(unregister, 5000);
      else off(window, "resize", onResize);
    }
1127768
def unregister_module(self, module):
        

        if module not in self._modules:
            raise NoRegisteredError("Module '{0}' is not registered on loader.".format(module))

        self._modules.remove(module)