Remove child from ``Node`` object

        Args:
            ``child`` (``Node``): The child to remove
193749
def remove_child(self, child):
        '''
        '''
        if not isinstance(child, Node):
            raise TypeError("child must be a Node")
        try:
            self.children.remove(child); child.parent = None
        except:
            raise RuntimeError("Attempting to remove non-existent child")
1320930
public function removeChild($child)
    {
        $index = $this->resolveChildIndex($child);
        if ($index === false) {
            return $this;
        }

        $node         = $this->children[$index];
        $node->parent = null;

        array_splice($this->children, $index, 1);

        return $this;
    }
1354689
def remove(self, *args):
        
        for x in args:
            self.children.remove(x)
        return self.children
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)
1263432
public void remove(DepTreeNode child) {
		if (children != null) {
			DepTreeNode node = children.get(child.getName());
			if (node == child) {
				children.remove(child.getName());
			}
		}
		child.setParent(null);
	}
1304468
function makeRemove(child, node) {
  // NOTE: Null values reduce hidden classes.
  return {
    type: 'REMOVE_NODE',
    content: null,
    fromIndex: child._mountIndex,
    fromNode: node,
    toIndex: null,
    afterNode: null
  };
}
796111
def delete_node(self, node: str):
        
        if self.has_node(node):
            self.remove_node(node)
1014590
public static <T extends MutableTreeNode<T>> void removeChild(T parent, T child) {
        checkArgNotNull(parent, "parent");
        int index = parent.getChildren().indexOf(child);
        checkElementIndex(index, parent.getChildren().size());
        parent.removeChild(index);
    }
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
27575
function (child, node) {
	      var update = this.removeChild(child, node);
	      child._mountIndex = null;
	      return update;
	    }
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()
493262
def remove(self, item):
        
        for index, child in enumerate(self._root.getchildren()):
            if child is item._root:
                del self[index]
                return item
        raise WSDLParseError("Non existing item in tag '%s'" %
                               self._schema.tag)
188199
def delete(self, destroy=True):
        
        removed_child = self.adapter.remove_node_child(
            self.adapter.get_node_parent(self.impl_node), self.impl_node,
            destroy_node=destroy)
        if removed_child is not None:
            return self.adapter.wrap_node(removed_child, None, self.adapter)
        else:
            return None
5859
def unregister_child(self, child):
        
        self._children.remove(child)
        child.on_closed.disconnect(self.unregister_child)
1022869
def remove(self):
        
        if self.parent is not None:
            for i, child in enumerate(self.parent.children):
                if id(child) == id(self):
                    self.parent.remove_child(i)
                    self.parent = None
                    break
1095544
def _unset_child(self, name, child):
        
        if name not in self._children or self._children[name] is not child:
            msg = 'Child {child} with name "{name}" is not found'
            raise ValueError(msg.format(child=child, name=name))
        child._set_parent(None)
        self._remove_child(name, child)
884432
def remove_child(self, index):
        
        if index < 0:
            index = index + len(self)
        self.__children = self.__children[0:index] + self.__children[(index + 1):]