Unregister an existing child that is no longer to be owned by the
        current instance.

        :param child: The child instance.
5859
def unregister_child(self, child):
        
        self._children.remove(child)
        child.on_closed.disconnect(self.unregister_child)
1366689
def _unregister_lookup(cls, lookup, lookup_name=None):
        
        if lookup_name is None:
            lookup_name = lookup.lookup_name
        del cls.class_lookups[lookup_name]
1289466
def remove_child(self, widget):
        
        raw = list(filter(lambda x: x[0] == widget, self._items))
        if raw:
            itm, wrapped = raw[0]
            self._items.remove(raw[0])
            super(List, self).remove_child(wrapped)
        else:
            raise ValueError("Child not in list.")
173124
def unregister(self, condition_set):
        
        if callable(condition_set):
            condition_set = condition_set()
        self._registry.pop(condition_set.get_id(), None)
598737
def unregister(self, entity_class, entity):
        
        EntityState.release(entity, self)
        self.__entity_set_map[entity_class].remove(entity)
517981
def unregister_all(self, name):
        
        try:
            templatehook = self._registry[name]
        except KeyError:
            return

        templatehook.unregister_all()
708253
def remove_child(self, child):
        
        self.children.remove(child)
        child.parent = None

        if self.view and self.view.is_loaded:
            self.view.dispatch({
                'name': 'remove',
                'selector': '#' + child.id
            })
315384
final void removeChildLogger(LogManager.LoggerWeakRef child) {
        synchronized (treeLock) {
            for (Iterator<LogManager.LoggerWeakRef> iter = kids.iterator(); iter.hasNext(); ) {
                LogManager.LoggerWeakRef ref = iter.next();
                if (ref == child) {
                    iter.remove();
                    return;
                }
            }
        }
    }
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()
1238416
def unregister(self):
        
        if self.registered:
            #Only if we have not received any message recently.
            if datetime.datetime.now()-datetime.timedelta(seconds=self.unregister_timeout) > self.lastmsg:
                self.registered = False
                if self.parent:
                    self.parent.unregister(self)
64505
def remove(self, child):
        """"""
        if not isinstance(child, AbstractElement):
            raise ValueError("Expected AbstractElement, got " + str(type(child)))
        if child.parent == self:
            child.parent = None
        self.data.remove(child)
        #delete from index
        if child.id and self.doc and child.id in self.doc.index:
            del self.doc.index[child.id]
1215663
def unregister(model_or_iterable, fail_silently=False):
    '''
    
    '''
    from django.db import models
    from .compat import get_model

    if issubclass(model_or_iterable, models.Model):
        model_or_iterable = [model_or_iterable]
    for model in model_or_iterable:
        if isinstance(model, string_types):
            model = get_model(*model.split('.', 1))
        try:
            del REGISTRY[model]
        except KeyError:
            if fail_silently:
                continue
            raise ValueError(
                u'The model %s.%s is not registered.' % (
                    model._meta.app_label,
                    model._meta.object_name,
                ))
405578
def unregister(self, handler):
        
        for handler_obj in self.handlers:
            registered = handler_obj.handler
            if handler is registered:
                self.handlers.remove(handler_obj)
                return True
        raise ValueError('This handler is not registered!')
428843
def unregister(self, condition_set):
        
        if callable(condition_set):
            condition_set = condition_set()
        registry.pop(condition_set.get_id(), None)
        registry_by_namespace.pop(condition_set.get_namespace(), None)
521666
function removeChild(parent, child) {
        var parentChildIdx = parent._children.indexOf(child)
        parent._children.splice(parentChildIdx, 1)
        incChildrenVersion(parent)
        return parent
    }
356578
def remove(self, child):
        
        if isinstance(child, Element):
            return child.detach()
        if isinstance(child, Attribute):
            self.attributes.remove(child)
        return None
168274
def unregister_action(self, name):
        

        name = self.__normalize_name(name)
        action = self.get_action(name)
        if not action:
            return False

        action.triggered.disconnect(self.__actions_signals_slots.pop(action))

        category = foundations.namespace.get_namespace(name)
        name = foundations.namespace.remove_namespace(name)
        self.remove_from_category(category, name)
        return True