Delete this node from the owning document.

        :param bool destroy: if True the child node will be destroyed in
            addition to being removed from the document.

        :returns: the removed child node, or *None* if the child was destroyed.
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
754778
def remove_node(node)
      node.parent.equal? self or
        raise ArgumentError, "node is not a child"
      field = node.instance_variable_get(:@parent_field)
      node.instance_variable_set(:@parent, nil)
      node.instance_variable_set(:@parent_field, nil)
      self.instance_variable_set(field.var, nil)
      return self
    end
1277549
def destroy(name):
    '''
    
    '''
    node = show_instance(name, call='action')
    params = {'SUBID': node['SUBID']}
    result = _query('server/destroy', method='POST', decode=False, data=_urlencode(params))

    # The return of a destroy call is empty in the case of a success.
    # Errors are only indicated via HTTP status code. Status code 200
    # effetively therefore means "success".
    if result.get('body') == '' and result.get('text') == '':
        return True
    return result
400680
def remove(self, obj, commit=True):
        
        database = self._database(writable=True)
        database.delete_document(TERM_PREFIXES[ID] + get_identifier(obj))
        database.close()
1265028
function removeNode(node) {
    // important that we want to do this only if the node has a logical parent
    var logicalParent = tree.Logical.hasParentNode(node) &&
      tree.Logical.getParentNode(node);
    var distributed;
    var ownerRoot = this.ownerShadyRootForNode(node);
    if (logicalParent) {
      // distribute node's parent iff needed
      distributed = this.maybeDistributeParent(node);
      tree.Logical.recordRemoveChild(node, logicalParent);
      // remove node from root and distribute it iff needed
      if (ownerRoot && (this._removeDistributedChildren(ownerRoot, node) ||
        logicalParent.localName === ownerRoot.getInsertionPointTag())) {
        ownerRoot._skipUpdateInsertionPoints = false;
        ownerRoot.update();
      }
    }
    this._removeOwnerShadyRoot(node);
    return distributed;
  }
979475
def remove_nodehandler(self, node):
        
        out = None
        if node in self.node_handlers:
            out = self.node_handlers.pop(node)
        return out
994916
def removeChild(self, child):
		
		for i, childNode in enumerate(self.childNodes):
			if childNode is child:
				del self.childNodes[i]
				child.parentNode = None
				return child
		raise ValueError(child)
100153
def del_node(self, node):
        
        if self.has_node(node):
            for e in self.node_links[node]:
                self.edge_links[e].remove(node)

            self.node_links.pop(node)
            self.graph.del_node((node,'n'))
438041
def delete(node_name):
    
    result = {}
    node = nago.core.get_node(node_name)
    if not node:
        result['status'] = 'error'
        result['message'] = "node not found."
    else:
        node.delete()
        result['status'] = 'success'
        result['message'] = 'node deleted.'
    return result
730012
def delete_node(self, root, key):
        
        if not root: return None

        if root.val == key:
            if root.left:
                # Find the right most leaf of the left sub-tree
                left_right_most = root.left
                while left_right_most.right:
                    left_right_most = left_right_most.right
                # Attach right child to the right of that leaf
                left_right_most.right = root.right
                # Return left child instead of root, a.k.a delete root
                return root.left
            else:
                return root.right
        # If left or right child got deleted, the returned root is the child of the deleted node.
        elif root.val > key:
            root.left = self.deleteNode(root.left, key)
        else:
            root.right = self.deleteNode(root.right, key)
        return root
736460
public boolean remove() {
		if (exists() && !isRemoved()) {
			isRemoved = true;
			node.getParent().removeChild(nodeFqn.getLastElement());
			if (doTraceLogs) {
				logger.trace("removed cache node "+nodeFqn);
			}	
			return true;
		}
		else {
			return false;
		}
	}
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
            })
419802
def remove_child(self, child):
        
        assert isinstance(child, Term)
        self.children.remove(child)
        self.doc.remove_term(child)
813582
public boolean remove(Tree<T> node) {
    return getChild(node)
        .map(function(n -> n.parent = null))
        .map(children::remove)
        .orElse(false);
  }
1013675
public void removeChild(ElementBase child, boolean destroy) {
        if (!children.contains(child)) {
            return;
        }
        
        boolean isLocked = child.isLocked() || child.getDefinition().isInternal();
        
        if (destroy) {
            child.removeChildren();
            
            if (!isLocked) {
                child.destroy();
            }
        }
        
        if (!isLocked) {
            beforeRemoveChild(child);
            children.remove(child);
            child.updateParent(null);
            afterRemoveChild(child);
        }
    }
566221
def __remove_child(self, parent_tree_node, index):
        
        # get parent and item
        parent_item = self.__mapping[id(parent_tree_node)]
        # manage the item model
        self.item_model_controller.begin_remove(index, index, parent_item.row, parent_item.id)
        child_item = parent_item.children[index]
        parent_item.remove_child(child_item)
        self.__mapping.pop(id(child_item.data["tree_node"]))
        self.item_model_controller.end_remove()
860467
def delete_authoring_nodes(self, editor):
        

        editor_node = foundations.common.get_first_item(self.get_editor_nodes(editor))
        file_node = editor_node.parent
        self.unregister_editor(editor_node)
        self.unregister_file(file_node, raise_exception=False)
        return True