Unregisters a named object from the store
327967
function(obj, type, name) {
    var nameMap = this._store[type]
      , objList = nameMap ? nameMap[name] : null
      , ind
    if (!objList) return
    ind = objList.indexOf(obj)
    if (ind === -1) return 
    objList.splice(ind, 1)
    exports.emitter.emit('namedObjects:unregistered:' + type, obj)
  }
854380
def unregister_factory(self, factory_name):
        # type: (str) -> bool
        
        if not factory_name or not is_string(factory_name):
            # Invalid name
            return False

        with self.__factories_lock:
            try:
                # Remove the factory from the registry
                factory_class = self.__factories.pop(factory_name)
            except KeyError:
                # Unknown factory
                return False

            # Trigger an event
            self._fire_ipopo_event(
                constants.IPopoEvent.UNREGISTERED, factory_name
            )

            # Invalidate and delete all components of this factory
            with self.__instances_lock:
                # Compute the list of __instances to remove
                to_remove = self.__get_stored_instances(factory_name)

                # Remove instances from the registry: avoids dependencies \
                # update to link against a component from this factory again.
                for instance in to_remove:
                    try:
                        # Kill the instance
                        self.kill(instance.name)
                    except ValueError:
                        # Unknown instance: already killed by the invalidation
                        # callback of a component killed in this loop
                        # => ignore
                        pass

                # Remove waiting component
                names = [
                    name
                    for name, (context, _) in self.__waiting_handlers.items()
                    if context.factory_context.name == factory_name
                ]
                for name in names:
                    del self.__waiting_handlers[name]

            # Clear the bundle context of the factory
            _set_factory_context(factory_class, None)

        return True
169977
function(obj, name, callback) {
      var listeners = this._listeners;
      if (!listeners) return this;
      var deleteListener = !name && !callback;
      if (typeof name === 'object') callback = this;
      if (obj) (listeners = {})[obj._listenerId] = obj;
      for (var id in listeners) {
        listeners[id].off(name, callback, this);
        if (deleteListener) delete this._listeners[id];
      }
      return this;
    }
321033
public static void unregister(String name) {
    try {
      ManagementFactory.getPlatformMBeanServer().unregisterMBean(new ObjectName(name));
    } catch (Exception e) {
      LoggerFactory.getLogger(Jmx.class).warn("Can not unregister MBean [{}]", name, e);
    }
  }
409339
def unregister(self, alias):
        
        if alias not in self._service_objects:
            raise Error(self._device,
                        'No service is registered with alias "%s".' % alias)
        service_obj = self._service_objects.pop(alias)
        if service_obj.is_alive:
            with expects.expect_no_raises(
                    'Failed to stop service instance "%s".' % alias):
                service_obj.stop()
1151015
@SuppressWarnings({})
    public synchronized void removeStoreFromSession(List<String> storeNameToRemove) {

        logger.info("closing the Streaming session for a few stores");

        commitToVoldemort(storeNameToRemove);
        cleanupSessions(storeNameToRemove);

    }
1334828
function removeHandler(store, name, callback, context) {
  var event = store[name];
  if (
     (!callback || (callback === event.callback || callback === event.callback._callback)) &&
     (!context || (context === event.context))
  ) {
    delete store[name];
    return true;
  }
}
915585
def _remove_non_serializable_store_entries(store: dict):
    
    removed_key_list = []
    for key, value in store.items():
        if not (_is_serializable(key) and _is_serializable(value)):
            _logger.info("Remove non-serializable item from the global script store. Key: '{}', Value: '{}'. "
                         "This item cannot be saved and therefore will be lost.".format(key, value))
            removed_key_list.append(key)
    for key in removed_key_list:
        del store[key]
1057322
def unregister_transform(self, node_class, transform, predicate=None):
        """"""
        self.transforms[node_class].remove((transform, predicate))
1198419
def _unregister(self, cls):
        
        if not issubclass(cls, self._registerable_class):
            raise ValueError('Only %s classes or subclasses may be '
                             'unregistered.' % self._registerable_class)

        if cls not in self._registry:
            raise NotRegistered('%s is not registered' % cls)

        del self._registry[cls]

        return True
612630
public static void unregister (PerformanceObserver obs, String name)
    {
        // get the observer's action hashtable
        Map<String, PerformanceAction> actions = _observers.get(obs);
        if (actions == null) {
            log.warning("Attempt to unregister by unknown observer " +
                        "[observer=" + obs + ", name=" + name + "].");
            return;
        }

        // attempt to remove the specified action
        PerformanceAction action = actions.remove(name);
        if (action == null) {
            log.warning("Attempt to unregister unknown action " +
                        "[observer=" + obs + ", name=" + name + "].");
            return;
        }

        // if the observer has no actions left, remove the observer's action
        // hash in its entirety
        if (actions.size() == 0) {
            _observers.remove(obs);
        }
    }
1095895
public final <T> void unbindFrom(Class<T> clazz, T object) throws ObjectNotAssociatedException {
        LifecycleManagerStore.getCurrentStore().unbind(this, clazz, object);
    }
918261
void revokeDbObject(HsqlName name) {

        directRightsMap.remove(name);
        grantedRightsMap.remove(name);
        fullRightsMap.remove(name);
    }
1067157
def unregister(self, model_or_iterable):
        
        if isinstance(model_or_iterable, ModelBase):
            model_or_iterable = [model_or_iterable]
        for model in model_or_iterable:
            # Check if the model is actually registered (``get_options_for_model``
            # throws an exception if it's not).
            self.get_options_for_model(model)
            # Invalidate all submodels options and forget about
            # the model itself.
            for desc, desc_opts in list(self._registry.items()):
                if not issubclass(desc, model):
                    continue
                if model != desc and desc_opts.registered:
                    # Allowing to unregister a base would necessitate
                    # repatching all submodels.
                    raise DescendantRegistered(
                        'You need to unregister descendant "%s" before'
                        ' unregistering its base "%s"' %
                        (desc.__name__, model.__name__))
                del self._registry[desc]
458518
def unregister(self):
        """"""
        self.names.remove(self.uniquename)
        super(ConfigurableMeta, self).unregister()
1128109
def unregister(self, id):
        '''
        
        '''
        result = self.rr.table(self.table).get(id).delete().run()
        if result != {
                'deleted':1, 'errors':0,'inserted':0,
                'replaced':0,'skipped':0,'unchanged':0}:
            self.logger.warn(
                    'unexpected result attempting to delete id=%s from '
                    'rethinkdb services table: %s', id, result)
656097
function unregister() {
    if (!applicationCurrent) {
        return;
    }
    applicationCurrent.stop();

    EVENTS.forEach(function (event) {
        process.removeListener(event, currentHandlers[event]);
    });

    applicationCurrent = null;
    currentHandlers = {};
}