Calls `_clear` abstract method which must be implemented by descendants.

        :raises: GPflowError exception when parent of the node is built.
322672
def clear(self):
        
        parent = self.parent
        if parent is not self and parent.is_built_coherence(self.graph) is Build.YES:
            raise GPflowError('Clear method cannot be started. Upper nodes are built.')
        self._clear()
1038398
protected void clearTreeLevel(CmsUUID parentId) {

        // create a new list to avoid concurrent modifications
        Collection<?> children = m_treeContainer.getChildren(parentId);
        // may be null when monkey clicking
        if (children != null) {
            List<Object> childIds = new ArrayList<Object>(m_treeContainer.getChildren(parentId));
            for (Object childId : childIds) {
                m_treeContainer.removeItemRecursively(childId);
            }
        }
    }
234676
def clean(self):
        
        super(CTENode, self).clean()
        if self.parent and self.pk in getattr(self.parent, self._cte_node_path):
            raise ValidationError(_("A node cannot be made a descendant of itself."))
1150587
private void rollingRemove() throws TTException {
        final ITreeData startNode = mDelegate.getCurrentNode();
        long hashToRemove = startNode.getHash();
        long hashToAdd = 0;
        long newHash = 0;
        // go the path to the root
        do {
            synchronized (mDelegate.getCurrentNode()) {
                getPtx().getData(mDelegate.getCurrentNode().getDataKey());
                if (mDelegate.getCurrentNode().getDataKey() == startNode.getDataKey()) {
                    // the begin node is always null
                    newHash = 0;
                } else if (mDelegate.getCurrentNode().getDataKey() == startNode.getParentKey()) {
                    // the parent node is just removed
                    newHash = mDelegate.getCurrentNode().getHash() - (hashToRemove * PRIME);
                    hashToRemove = mDelegate.getCurrentNode().getHash();
                } else {
                    // the ancestors are all touched regarding the modification
                    newHash = mDelegate.getCurrentNode().getHash() - (hashToRemove * PRIME);
                    newHash = newHash + hashToAdd * PRIME;
                    hashToRemove = mDelegate.getCurrentNode().getHash();
                }
                mDelegate.getCurrentNode().setHash(newHash);
                hashToAdd = newHash;
                getPtx().setData(mDelegate.getCurrentNode());
            }
        } while (moveTo(mDelegate.getCurrentNode().getParentKey()));

        mDelegate.setCurrentNode(startNode);
    }
880547
function applyParentNode (args) {
            if (isEmptyString(nodeName)) { return undefined; }

            let nextParentName = CLASS[nodeName].prototype.$parentName;

            // Keep reference of the node's name just in case the chain gets reset.
            let tmpName = nodeName;

            // If there are no more parent nodes then reset the chain.
            if (isEmptyString(nextParentName)) {
                resetNames();
            }

            CLASS[tmpName].apply(this, args);
        }
1000350
def _clear(self, node, left, right):
        
        if self.lazyset[node] is not None:  # first do the pending set
            val = self.lazyset[node]
            self.minval[node] = val
            self.maxval[node] = val
            self.sumval[node] = val * (right - left)
            self.lazyset[node] = None
            if left < right - 1:            # not a leaf
                self.lazyset[2 * node] = val    # propagate to direct descendents
                self.lazyadd[2 * node] = 0
                self.lazyset[2 * node + 1] = val
                self.lazyadd[2 * node + 1] = 0
        if self.lazyadd[node] != 0:        # then do the pending add
            val = self.lazyadd[node]
            self.minval[node] += val
            self.maxval[node] += val
            self.sumval[node] += val * (right - left)
            self.lazyadd[node] = 0
            if left < right - 1:            # not at a leaf
                self.lazyadd[2 * node] += val     # propagate to direct descendents
                self.lazyadd[2 * node + 1] += val
1173231
def remove_certain_leaves(tr, to_remove=lambda node: False):
    

    tips = [tip for tip in tr if to_remove(tip)]
    for node in tips:
        if node.is_root():
            return None
        parent = node.up
        parent.remove_child(node)
        # If the parent node has only one child now, merge them.
        if len(parent.children) == 1:
            brother = parent.children[0]
            brother.dist += parent.dist
            if parent.is_root():
                brother.up = None
                tr = brother
            else:
                grandparent = parent.up
                grandparent.remove_child(parent)
                grandparent.add_child(brother)
    return tr
76020
void markSuccess() {
    // It's possible that the dag is killed before this method is called.
    assertRunningOrKilling();
    changeStatus(Status.SUCCESS);
    for (final Node child : this.children) {
      child.runIfAllowed();
    }
    this.dag.updateDagStatus();
  }
533831
public void deleteMax() {
	if (isEmpty())
	    throw new NoSuchElementException("BST underflow");

	// if both children of root are black, set root to red
	if (!isRed(root.getLeft()) && !isRed(root.getRight()))
	    root.setColor(RED);

	root = deleteMax(root);
	if (!isEmpty()) {
	    root.setParent(null);
	    root.setColor(BLACK);
	}
	// assert check();
    }
830159
final void remove(AbstractCompiler compiler) {
    if (isDetached()) {
      return;
    }
    Node statement = getRemovableNode();
    NodeUtil.deleteNode(statement, compiler);
    statement.removeChildren();
  }
836398
protected void nodeCompleted(Object parent, Object node) {
        getProxyBuilder().getCurrentFactory().onNodeCompleted(getProxyBuilder().getChildBuilder(), parent, node);
    }
738933
def flush(self):
        # type: () -> None
        
        if self._closed:
            raise IOError('tried to flush closed connection')
        assert self._parentout is not None
        self._parentout.flush()
1082358
private void removeUnneededPolyfills(Node parent, Node runtimeEnd) {
    Node node = parent.getFirstChild();
    while (node != null && node != runtimeEnd) {
      Node next = node.getNext();
      if (NodeUtil.isExprCall(node)) {
        Node call = node.getFirstChild();
        Node name = call.getFirstChild();
        if (name.matchesQualifiedName("$jscomp.polyfill")) {
          FeatureSet nativeVersion =
              FeatureSet.valueOf(name.getNext().getNext().getNext().getString());
          if (languageOutIsAtLeast(nativeVersion)) {
            NodeUtil.removeChild(parent, node);
          }
        }
      }
      node = next;
    }
  }
859309
def inherit(self):
        
        # Preserve original data and merge parent
        # (original data needed for custom inheritance extensions)
        self.original_data = self.data
        self.merge()
        log.debug("Data for '{0}' inherited.".format(self))
        log.data(pretty(self.data))
        #  to all children
        for child in self.children.values():
            child.inherit()
1301386
def clear(self):
        
        self._delete_child_storage(self.root_node)
        self._delete_node_storage(self.root_node)
        self.root_node = BLANK_NODE
444789
def clear(self):
        
        self.adj.clear()
        self.node.clear()
        self.graph.clear()
557338
private void updateCurrentFunction(AbstractFunctionExpression parentExpr) {
        GroovyExpression expr = parentExpr.getCaller();
        if (expr instanceof AbstractFunctionExpression) {
            AbstractFunctionExpression exprAsFunction = (AbstractFunctionExpression) expr;
            GroovyExpression exprCaller = exprAsFunction.getCaller();
            parentExpr.setCaller(exprCaller);
            updateCurrentFunctionDefintion(exprAsFunction);
        }
    }