Remove a node.

@param n Node to be added
@throws RuntimeException thrown if this NodeSet is not of
a mutable type.
179157
public void removeNode(Node n)
  {

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    this.removeElement(n);
  }
872300
@Override
	public boolean remove(String nodeID) {
		Endpoint endpoint;
		boolean found = false;
		for (int i = 0; i < endpoints.length; i++) {
			endpoint = endpoints[i];
			if (nodeID.equals(endpoint.getNodeID())) {
				found = true;
				if (endpoints.length == 1) {
					endpoints = new Endpoint[0];
				} else {
					Endpoint[] copy = new Endpoint[endpoints.length - 1];
					System.arraycopy(endpoints, 0, copy, 0, i);
					System.arraycopy(endpoints, i + 1, copy, i, endpoints.length - i - 1);
					endpoints = copy;
					i--;
				}
			}
		}

		// Remove from cache
		if (found) {
			endpointCache.remove(nodeID);
		}
		return found;
	}
136951
public static void removeName(Node n) {
    checkState(n.isFunction() || n.isClass());
    Node originalName = n.getFirstChild();
    Node emptyName = n.isFunction() ? IR.name("") : IR.empty();
    n.replaceChild(originalName, emptyName.useSourceInfoFrom(originalName));
  }
1029691
def remove_node(self, node):
        
        if _debug: Network._debug("remove_node %r", node)

        self.nodes.remove(node)
        node.lan = None
456400
public void addElement(int value)
  {

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESETDTM_NOT_MUTABLE, null)); //"This NodeSetDTM is not mutable!");

    super.addElement(value);
  }
1091268
protected Node removeNode( Node node )
    {
        // Remove node.
        node.previous.next = node.next;
        node.next.previous = node.previous;
        node.removed = true;
        return node;
    }
396483
public void appendNodes(NodeSet nodes)
  {

    int nNodes = nodes.size();

    if (null == m_map)
    {
      m_mapSize = nNodes + m_blocksize;
      m_map = new Node[m_mapSize];
    }
    else if ((m_firstFree + nNodes) >= m_mapSize)
    {
      m_mapSize += (nNodes + m_blocksize);

      Node newMap[] = new Node[m_mapSize];

      System.arraycopy(m_map, 0, newMap, 0, m_firstFree + nNodes);

      m_map = newMap;
    }

    System.arraycopy(nodes.m_map, 0, m_map, m_firstFree, nNodes);

    m_firstFree += nNodes;
  }
591071
public void removeKnot(int n) {
		if (numKnots <= 4)
			return;
		if (n < numKnots-1) {
			System.arraycopy(xKnots, n+1, xKnots, n, numKnots-n-1);
			System.arraycopy(yKnots, n+1, yKnots, n, numKnots-n-1);
		}
		numKnots--;
		rebuildGradient();
	}
1093113
public void remove(String suggestion) {
        Node n = getNode(suggestion);
        if(n == null)
            return;
        n.weight = -1;
        size--;
        Node m = n;
        if(n.mid == null) {
            Node replacement = removeNode(n);
            if(replacement != null)
                replacement.parent = n.parent;
            if(n == root)
                root = replacement;
            else if(n == n.parent.mid)
                n.parent.mid = replacement;
            else{
                if(n == n.parent.left)
                    n.parent.left = replacement;
                else
                    n.parent.right = replacement;
                while(n != root && n != n.parent.mid)
                    n = n.parent;
            }
            n = n.parent;
            if(n == null)
                return;
        }
        if(n.weight == -1 && n.mid.left == null && n.mid.right == null) {
            n = mergeWithChild(n);
            while(n != root && n != n.parent.mid)
                n = n.parent;
            n = n.parent;
            if(n == null)
                return;
        }
        removeFromLists(m, n);
    }
1280153
@Override
  public void removeChildren(Element node) {

    NodeList children = node.getChildNodes();
    for (int i = (children.getLength() - 1); i >= 0; i--) {
      node.removeChild(children.item(i));
    }
  }
102537
public void remove() {

    BasicDoubleLinkedNode<V> next = getNext();
    if (next != null) {
      next.previous = this.previous;
    }
    if (this.previous != null) {
      this.previous.setNext(next);
    }
  }
318124
def delete_node(self, name):
        

        name = self._validate_name(name)
        if name in self.nodes:
            del self.nodes[name]
1100281
void remove() {
        int nLen = length();
        for (int i = nLen - 1; i >= 0; i--) {
            XML xml = getXmlFromAnnotation(i);
            if (xml != null) {
                xml.remove();
                internalRemoveFromList(i);
            }
        }
    }
1372927
public static void removeChildrenFrom(final Element element) {
        if (element != null) {
            while (element.getFirstChild() != null) {
                element.removeChild(element.getFirstChild());
            }
        }
    }
256633
public void remove(int n) {
    assert this.inHeap(n);
    int kPos = this.indices.get(n);
    this.indices.set(n, -1);
    if (kPos < this.heap.size() - 1) {
      this.heap.set(kPos, this.heap.back());
      this.indices.set(this.heap.get(kPos), kPos);
      this.heap.pop();
      this.percolateDown(kPos);
    } else
      this.heap.pop();
  }
172451
public Node removeChild(final String name) {
        final Node node = getSingle(name);
        if (node != null) {
            removeChild(node);
        }
        return node;
    }
1247314
public void removeKnot(int n) {
		if (numKnots <= 4)
			return;
		if (n < numKnots-1) {
			System.arraycopy(xKnots, n+1, xKnots, n, numKnots-n-1);
			System.arraycopy(yKnots, n+1, yKnots, n, numKnots-n-1);
			System.arraycopy(knotTypes, n+1, knotTypes, n, numKnots-n-1);
		}
		numKnots--;
		if (xKnots[1] > 0)
			xKnots[1] = 0;
		rebuildGradient();
	}