Removes node by label
328812
def remove_child(self, label):
        
        ind = None
        for i,c in enumerate(self.children):
            if c.label==label:
                ind = i

        if ind is None:
            logging.warning('No child labeled {}.'.format(label))
            return
        self.children.pop(ind)
        self._clear_all_leaves()
1223637
public boolean remove(String label) {
        if (!isDeclared(label)) {
            return false;
        }
        level.remove(label);
        type.remove(label);
        return true;
    }
1317166
def remove_element(self, e):
        
        
        if e.label is not None: self.elementdict.pop(e.label)
        self.elementlist.remove(e)
318124
def delete_node(self, name):
        

        name = self._validate_name(name)
        if name in self.nodes:
            del self.nodes[name]
564268
def del_node(self, n):
        '''
        
        '''
        parent = self.get_node_attr(n, 'parent')
        if self.get_node_attr(n, 'direction') == 'R':
            self.set_node_attr(parent, 'Rchild', None)
        else:
            self.set_node_attr(parent, 'Lchild', None)
        Graph.del_node(self, n)
220079
public function removeLabel(CINLabel $label) {
        $remove = -1;
        $c = count($this->labels);
        for ($i = 0; $i < $c; $i++) {
            if ($this->labels[$i] === $label) {
                $remove = $i;
                break;
            }
        }

        if ($remove > -1) {
            array_splice($this->labels, $remove, 1);
        }
    }
1304749
public void remove(Node<T> node) {
    	if (first == node) {
    		removeMin();
    		return;
    	}
    	if (last == node) {
    		removeMax();
    		return;
    	}
    	// if both children of root are black, set root to red
    	if ((root.left == null || !root.left.red) && (root.right == null || !root.right.red))
            root.red = true;

        root = remove(root, node);
        if (root != null) root.red = false;
        else first = last = null;
    }
922823
def remove_col_label(self, event=None, col=None):
        
        if event:
            col = event.GetCol()
        if not col:
            return
        label = self.grid.GetColLabelValue(col)
        if '**' in label:
            label = label.strip('**')
        elif '^^' in label:
            label = label.strip('^^')
        if label in self.reqd_headers:
            pw.simple_warning("That header is required, and cannot be removed")
            return False
        else:
            print('That header is not required:', label)
            # remove column from wxPython grid
            self.grid.remove_col(col)
            # remove column from DataFrame if present
            if self.grid_type in self.contribution.tables:
                if label in self.contribution.tables[self.grid_type].df.columns:
                    del self.contribution.tables[self.grid_type].df[label]
        # causes resize on each column header delete
        # can leave this out if we want.....
        self.main_sizer.Fit(self)
979475
def remove_nodehandler(self, node):
        
        out = None
        if node in self.node_handlers:
            out = self.node_handlers.pop(node)
        return out
235090
void removeInternal(Node<K, V> node, boolean unlink) {
    if (unlink) {
      node.prev.next = node.next;
      node.next.prev = node.prev;
    }

    Node<K, V> left = node.left;
    Node<K, V> right = node.right;
    Node<K, V> originalParent = node.parent;
    if (left != null && right != null) {

      /*
       * To remove a node with both left and right subtrees, move an
       * adjacent node from one of those subtrees into this node's place.
       *
       * Removing the adjacent node may change this node's subtrees. This
       * node may no longer have two subtrees once the adjacent node is
       * gone!
       */

      Node<K, V> adjacent = (left.height > right.height) ? left.last() : right.first();
      removeInternal(adjacent, false); // takes care of rebalance and size--

      int leftHeight = 0;
      left = node.left;
      if (left != null) {
        leftHeight = left.height;
        adjacent.left = left;
        left.parent = adjacent;
        node.left = null;
      }

      int rightHeight = 0;
      right = node.right;
      if (right != null) {
        rightHeight = right.height;
        adjacent.right = right;
        right.parent = adjacent;
        node.right = null;
      }

      adjacent.height = Math.max(leftHeight, rightHeight) + 1;
      replaceInParent(node, adjacent);
      return;
    } else if (left != null) {
      replaceInParent(node, left);
      node.left = null;
    } else if (right != null) {
      replaceInParent(node, right);
      node.right = null;
    } else {
      replaceInParent(node, null);
    }

    rebalance(originalParent, false);
    size--;
    modCount++;
  }
397196
def remove_node(self, node):
        """"""
        try:
            self._nodes.remove(node)
            del self._weights[node]
        except (KeyError, ValueError):
            pass
        self._rebuild_circle()
486229
function(id) {
      var elem = this.getLabel(id);
      if(elem && elem.parentNode) {
        elem.parentNode.removeChild(elem);
      }
    }
127156
public Axis removeLabel(String label) {
        if (labels == null) {
            throw new IllegalStateException();
        }

        labels.remove(label);
        setSlice();
        initGridLabels();
        return this;
    }
824101
def remove_node(self, node):
        
        try:
            self._nodes.remove(node)
            del self._weights[node]
        except (KeyError, ValueError):
            pass
        self._hashring = dict()
        self._sorted_keys = []

        self._build_circle()
1181730
def remove_label(self, doc, label, update_index=True):
        
        doc = doc.clone()  # make sure it's serializable
        r = self.index.remove_label(doc, label, update_index=update_index)
        return r
70480
def _remove_node(self, node):
        

        self.graph.remove_node(node)
        if node.addr in self._nodes:
            del self._nodes[node.addr]

        # We wanna remove the function as well
        if node.addr in self.kb.functions:
            del self.kb.functions[node.addr]

        if node.addr in self.kb.functions.callgraph:
            self.kb.functions.callgraph.remove_node(node.addr)
1121403
def remove_label(self, label):
        
        works_to_delete = []
        for work, work_label in self.items():
            if work_label == label:
                works_to_delete.append(work)
        for work in works_to_delete:
            del self[work]
        if self._ordered_labels:
            self._ordered_labels.remove(label)