Removes the element from this container

If the reference object is not given, the element will be appended.

@param    HTML_QuickForm2_Node     Element to remove
@return   HTML_QuickForm2_Node     Removed object
172538
public function removeChild(HTML_QuickForm2_Node $element)
    {
        $element = parent::removeChild($element);
        if ($this->prependsName()) {
            $name = preg_replace('/^' . $this->getName() . '\[([^\]]*)\]/', '\1', $element->getName());
            $element->setName($name);
        }
        return $element;
    }
867097
def forget(element_id)
      unless is_parent_layout?
        return parent_layout.remove(element_id)
      end
      removed = nil
      context(self.view) do
        removed = all(element_id)
        @elements[element_id] = nil
      end
      removed
    end
921999
public LeftTupleSinkNode removeLast() {
        if ( this.lastNode == null ) {
            return null;
        }
        final LeftTupleSinkNode node = this.lastNode;
        this.lastNode = node.getPreviousLeftTupleSinkNode();
        node.setPreviousLeftTupleSinkNode( null );
        if ( this.lastNode != null ) {
            this.lastNode.setNextLeftTupleSinkNode( null );
        } else {
            this.firstNode = this.lastNode;
        }
        this.size--;
        return node;
    }
1094741
public static void removeAllChildren(final Node node) {
        assert node != null;
        assert node.getNodeType() != Node.ATTRIBUTE_NODE;
        if (node.getNodeType() == Node.DOCUMENT_TYPE_NODE) {
            Element documentElement = ((Document) node).getDocumentElement();
            if (documentElement != null) {
                ((Document) node).removeChild(documentElement);
            }
            return;
        }
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            Element element = (Element) node;
            for (Node n = element.getFirstChild(); n != null; n = element.getFirstChild()) {
                element.removeChild(n);
            }
        }
    }
102537
public void remove() {

    BasicDoubleLinkedNode<V> next = getNext();
    if (next != null) {
      next.previous = this.previous;
    }
    if (this.previous != null) {
      this.previous.setNext(next);
    }
  }
587124
public boolean remove(T element) {
		for (Iterator<Node<T>> it = nodes.iterator(); it.hasNext(); )
			if (ObjectUtil.equalsOrNull(it.next().element, element)) {
				it.remove();
				return true;
			}
		return false;
	}
225519
function() {
      
      // Remove from DOM
      if(Dom.inDocument(this.el)) {
         this.el.parentNode.removeChild(this.el);
      }
      
      // recursively purge element
      Event.purgeElement(this.el, true);
   }
69839
public function renderElement(\HTML_QuickForm2_Node $element) {
        $ary = $this->buildCommonFields($element) + [
                'html'              => $element->__toString(),
                'value'             => $element->getValue(),
                'type'              => $element->getType(),
                'label'             => $element->getLabel(),
                'desc'              => $element->getDesc(),
                'example'           => $element->getExample(),
                'placeholder'       => $element->getPlaceholder(),
                'example_is_append' => $element->getExampleIsAppend(),
                'prepend'           => $element->getPrepend(),
                'append'            => $element->getAppend(),
                'tpl'               => $element->getTpl(),
                'required'          => $element->isRequired(),
                'is_inline'         => $element->getIsInline(),
                'wrap_class'        => $element->getWrapClass(),
                'checked'           => $element->getAttribute('checked'),
            ];
        $this->pushScalar($ary);
    }
813582
public boolean remove(Tree<T> node) {
    return getChild(node)
        .map(function(n -> n.parent = null))
        .map(children::remove)
        .orElse(false);
  }
804709
public function renderElement(HTML_QuickForm2_Node $element)
    {
        $elTpl = $this->prepareTemplate($this->findTemplate($element), $element);
        $this->html[count($this->html) - 1][] = str_replace(array('{element}', '{id}'),
                                                            array($element, $element->getId()), $elTpl);
    }
566181
public boolean remove(Node<E> e) {

        mPutLock.lock();
        mPollLock.lock();
        try {
            if (e == null)
                return false;
    
            if (e.mRemoved)
                return false;
    
            if (mSize.get() == 0)
                return false;

            if (e == mTail) {
                removeTail();
                return true;
            }
            if (e == mHead.mNext) {
                removeHead();
                return true;
            }
            if (mSize.get() < 3)
                return false;

            if (e.mPrev == null || e.mNext == null)
                return false;

            e.mPrev.mNext = e.mNext;
            e.mNext.mPrev = e.mPrev;
            e.mRemoved = true;
            mSize.decrementAndGet();
            mNodePool.returnNode(e);
            return true;
        }
        finally {
            mPollLock.unlock();
            mPutLock.unlock();
        }
    }
846199
public function remove()
    {
        unset($this->_nodes[$this->_pointer]);
        $this->_nodes = array_values($this->_nodes);
        return $this;
    }
1344756
public void elementRemoved(QueryControllerEntity element) {
		if (element instanceof QueryControllerGroup) {
			QueryControllerGroup group = (QueryControllerGroup) element;
			QueryGroupTreeElement ele = new QueryGroupTreeElement(group.getID());
			Enumeration<TreeNode> groups = root.children();
			while (groups.hasMoreElements()) {
				Object temporal = groups.nextElement();
				if (!(temporal instanceof QueryGroupTreeElement)) {
					continue;
				}
				QueryGroupTreeElement groupTElement = (QueryGroupTreeElement) temporal;
				if (groupTElement.getID().equals(ele.getID())) {
					removeNodeFromParent(groupTElement);
					nodeStructureChanged(root);
					break;
				}
			}
		} else if (element instanceof QueryControllerQuery) {
			QueryControllerQuery query = (QueryControllerQuery) element;
			QueryTreeElement elementQuery = new QueryTreeElement(query.getID(), query.getQuery());
			Enumeration<TreeNode> elements = root.children();
			while (elements.hasMoreElements()) {
				TreeNode currentElement = elements.nextElement();
				if (currentElement instanceof QueryGroupTreeElement) {
					continue;
				}
				if (currentElement instanceof QueryTreeElement) {
					QueryTreeElement deleteQuery = (QueryTreeElement) currentElement;
					if (deleteQuery.getID().equals(elementQuery.getID())) {
						removeNodeFromParent(deleteQuery);
						nodeStructureChanged(root);
						break;
					}
				}
			}
		}
	}
148246
public synchronized void removeElement(T element) {
    checkArgument(
        element.getNext() != null || element.getPrev() != null || element == head,
        "Element not in the list.");
    size--;
    T prev = element.getPrev();
    T next = element.getNext();
    if (prev == null) {
      // This is the first element
      head = next;
      if (head != null) {
        // If more than one element in the list.
        head.setPrev(null);
        element.setNext(null);
      }
    } else if (next == null) {
      // This is the last element, and there is at least another element because
      // element.getPrev() != null.
      prev.setNext(null);
      element.setPrev(null);
    } else {
      prev.setNext(element.getNext());
      next.setPrev(element.getPrev());
      element.setNext(null);
      element.setPrev(null);
    }
  }
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;
  }
1206596
public T remove()
    {
        if ( size == 0 ) {
            return null;
        }
        
        //remove the first element
        Entry<T> o = head.next;
        head.next   = o.next;
        o.next.prev = head;
        
        //bakup the data
        T v         = o.data;
        size--;
        index.remove(v.getValue());
        
        o = null;            //Let gc do its work
        
        return v;
    }
178164
@Nullable
  public final Node removeFirstChild() {
    Node child = first;
    if (child != null) {
      removeChild(child);
    }
    return child;
  }