Removes a child instance from the Tag's children.

        Args:
            child (Tag): The child to be removed.
969791
def remove_child(self, child):
        
        if child in self.children.values() and hasattr(child, 'identifier'):
            for k in self.children.keys():
                if hasattr(self.children[k], 'identifier'):
                    if self.children[k].identifier == child.identifier:
                        if k in self._render_children_list:
                            self._render_children_list.remove(k)
                        self.children.pop(k)
                        # when the child is removed we stop the iteration
                        # this implies that a child replication should not be allowed
                        break
376137
def remove(self):
        
        if self.parent:
            for i, node in enumerate(self.parent.children):
                if node is self:
                    self.parent.changed()
                    del self.parent.children[i]
                    self.parent = None
                    return i
173588
public void removeChildren() {
        log.trace("removeChildren of {}", name);
        for (IBasicScope child : children.keySet()) {
            removeChildScope(child);
        }
    }
179796
public void removeChildObjectFromCamera(final Widget child, int camera) {
        switch (camera) {
            case LEFT_CAMERA:
                mLeftCameraRootWidget.removeChild(child);
                break;
            case RIGHT_CAMERA:
                mRightCameraRootWidget.removeChild(child);
                break;
            default:
                mMainCameraRootWidget.removeChild(child);
                break;
        }
    }
114702
def remove_child(self, child_pid):
        """"""
        with db.session.begin_nested():
            if not isinstance(child_pid, PersistentIdentifier):
                child_pid = resolve_pid(child_pid)
            relation = PIDRelation.query.filter_by(
                parent=self._resolved_pid,
                child=child_pid,
                relation_type=self.relation_type.id).one()
            db.session.delete(relation)
108338
public function remove_child(Node $child)
	{
		$key = array_search($what, $this->children);

		if($key === false)
			return false;

		$this->children[$key]->set_parent();
		unset($this->children[$key]);
		return true;
	}
578720
def removeChild(self, position):
        
        assert 0 <= position <= len(self.childItems), \
            "position should be 0 < {} <= {}".format(position, len(self.childItems))

        self.childItems[position].finalize()
        self.childItems.pop(position)
879661
def close(self, child):
        
        c = self.children[child]
        # flatten if children not None
        if c.children is not None and len(c.children) != 0:
            c.flatten()

        if c.value != 0. and not np.isnan(c.value):
            c.allocate(-c.value)
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.")
299812
def remove_child(child)
      @scheduler.delete(child)
      idx = @children.index { |x| child.equal?(x) }
      @children.delete_at(idx).parent = nil if idx
    end
683177
def remove_child(self, child_pid):
        
        if child_pid.status == PIDStatus.RESERVED:
            raise PIDRelationConsistencyError(
                "Version PIDs should not have status 'RESERVED'. Use "
                "remove_draft_child to remove a draft PID.")
        with db.session.begin_nested():
            super(PIDNodeVersioning, self).remove_child(child_pid,
                                                        reorder=True)
            self.update_redirect()
456532
def remove_child(self, child_pid, reorder=False):
        """"""
        super(PIDNodeOrdered, self).remove_child(child_pid)
        child_relations = self._resolved_pid.child_relations.filter(
            PIDRelation.relation_type == self.relation_type.id).order_by(
                PIDRelation.index).all()
        if reorder:
            for idx, c in enumerate(child_relations):
                c.index = idx
784591
public function removeChild($child)
    {
        if ($this->children->contains($child)) {
            $this->children->remove($child);
        }
    }
885342
public void removeChild(final Node child) {
        if (child instanceof Level) {
            levels.remove(child);
            nodes.remove(child);
            child.setParent(null);
        } else if (child instanceof SpecTopic) {
            removeSpecTopic((SpecTopic) child);
        } else if (child instanceof CommonContent) {
            commonContents.remove(child);
            nodes.remove(child);
            child.setParent(null);
        } else {
            nodes.remove(child);
            child.setParent(null);
        }
    }
1267988
def remove_child_object(identifier)
      found_child = children.find {|child| child.identifier == identifier }
      @properties['children'].delete identifier
      save!
      found_child
    end
840129
public void removeChild(HierarchicalFormModel child) {
		Assert.notNull(child, "child");
		child.removeParent();
		children.remove(child);
		child.removePropertyChangeListener(DIRTY_PROPERTY, childStateChangeHandler);
		child.removePropertyChangeListener(COMMITTABLE_PROPERTY, childStateChangeHandler);
		// when dynamically adding/removing childModels take care of
		// dirtymessages:
		// removing child that was dirty: remove from dirty map and update dirty
		// state
		if (dirtyValueAndFormModels.remove(child))
			dirtyUpdated();
	}
673655
public void extractChild( AstNode child ) {
        if (child.getChildCount() == 0) {
            removeChild(child);
        } else {
            AstNode grandChild = child.getFirstChild();
            replaceChild(child, grandChild);
        }
    }