Remove a child to this node
173876
public boolean removeChild(Concept concept) {
        if (concept.parent != this) {
            throw new IllegalArgumentException("Concept to remove is not a child");
        }

        for (int i = 0; i < children.size(); i++) {
            if (children.get(i) == concept) {
                children.remove(i);
                concept.parent = null;
                return true;
            }
        }

        return false;
    }
791913
public function remove()
    {
        foreach ($this as $node) {
            /**
             * @var \DOMNode $node
             */
            if ($node->parentNode instanceof \DOMElement) {
                $node->parentNode->removeChild($node);
            }
        }
        $this->clear();
    }
1237933
function removeChild(node) {
    if (tree.Logical.getParentNode(node) !== this) {
      throw Error('The node to be removed is not a child of this node: ' +
        node);
    }
    if (!mixinImpl.removeNode(node)) {
      // if removing from a shadyRoot, remove form host instead
      var container = isShadyRoot(this) ?
        this.host :
        this;
      // not guaranteed to physically be in container; e.g.
      // undistributed nodes.
      var parent = tree.Composed.getParentNode(node);
      if (container === parent) {
        tree.Composed.removeChild(container, node);
      }
    }
    mixinImpl._scheduleObserver(this, null, node);
    return node;
  }
108338
public function remove_child(Node $child)
	{
		$key = array_search($what, $this->children);

		if($key === false)
			return false;

		$this->children[$key]->set_parent();
		unset($this->children[$key]);
		return true;
	}
184281
function(node) {
                var self = this;
                node.parent && node.remove();
                self.insert(node, self);
                self.remove();
                return self;
            }
977262
function (node, child) {
        var pos = this.childNodes.indexOf(child);
        if (pos < 0) {
            throw new Error('HierarchyRequestError');
        }

        Node.remove(node);
        Node.insert(this, node, pos);

        return node;
    }
1031410
def remove_child(self, child):
        
        child.set_model(None)
        if self._model:
            row = self.childItems.index(child)
            parentindex = self._model.index_of_item(self)
            self._model.removeRow(row, parentindex)
        else:
            self.childItems.remove(child)
515162
public boolean removeChild(Node node) throws ChildNodeException {
    Node currNode = getFirstChild();
    boolean rc = false;

    if (!allowChildren) {
      throw new ChildNodeException();
    }

    if (node != null && !isLeaf()) {
      // Is this the first and only child
      if (node == currNode && node == currNode.getNextSibling()) {
        setFirstChild(null);
        rc = true;
      } else {
        // Verify that this Node is a child here
        do {
          if (currNode == node) {
            // Remove this child
            if (node.getPrevSibling() != null) {
              node.getPrevSibling().setNextSibling(node.getNextSibling());
            }
            if (node == getFirstChild()) {
              setFirstChild(node.getNextSibling());
            }

            rc = true;

            // do not release. Item.resolve expects the 
            // pointers to be intact after a remove
            //node.release();
            break;
          }
          currNode = currNode.getNextSibling();
        } while (currNode != getFirstChild());
      }
    }

    return rc;
  }
1063251
def detach(self):
        
        if self.parent is not None:
            if self in self.parent.children:
                self.parent.children.remove(self)
            self.parent = None
        return self
969791
def remove_child(self, child):
        
        if child in self.children.values() and hasattr(child, 'identifier'):
            for k in self.children.keys():
                if hasattr(self.children[k], 'identifier'):
                    if self.children[k].identifier == child.identifier:
                        if k in self._render_children_list:
                            self._render_children_list.remove(k)
                        self.children.pop(k)
                        # when the child is removed we stop the iteration
                        # this implies that a child replication should not be allowed
                        break
547099
def pop(self):
        
        node = self.nodes.pop()
        self.__keys.remove(node.key)
1309097
function remove() {
  var i, el;
  for(i = 0;i < this.length;i++) {
    el = this.dom[i];
    // if for some reason this point to the document element
    // an exception will occur, pretty hard to reproduce so
    // going to let it slide
    if(el.parentNode) {
      el.parentNode.removeChild(el);
      this.dom.splice(i, 1);
      i--;
    }
  }
  return this;
}
1197161
def removeChild(self, child_id):
        

        self.log.debug("Try to remove a child <Workitem %s> from current "
                       "<Workitem %s>",
                       child_id,
                       self)
        self._removeChildren([child_id])
        self.log.info("Successfully remove a child <Workitem %s> from "
                      "current <Workitem %s>",
                      child_id,
                      self)
1082669
public void removeChild(TreeElement child)
    {

        if (child == null || _children == null)
            return;

        int size = _children.size();
        int removeIndex = -1;
        for (int i = 0; i < size; i++) {
            if (child == (TreeElement) _children.get(i)) {
                _children.remove(i);
                child.setParent(null);
                removeIndex = i;
                break;
            }
        }
        if (removeIndex >= 0) {
            size = _children.size();
            for (int i = removeIndex; i < size; i++) {
                TreeElement thisChild = (TreeElement) _children.get(i);
                thisChild.updateName(this, i);
            }
        }
    }
343445
def delete_child(attribute, instance=nil)
      if self.send(attribute).is_a?(Array)
        deleted = self.send(attribute).delete(instance)
        deleted.parent = nil if deleted
      else
        self.send(attribute).parent = nil if self.send(attribute)
        self.instance_variable_set("@#{attribute}", nil)
      end
    end
1143491
function(){
			var indicator = lib.node(this._prefix+this._id);
			if (indicator) {
				indicator.parentNode.removeChild(indicator);
			}
		}
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