Adds a child node.

@param e
the child node to add
@return <code>true</code>
@see java.util.List#add(java.lang.Object)
356344
public boolean addChild(ClusteringTreeNode e) {
		assert (this.center.length == e.center.length);
		return this.children.add(e);
	}
1185099
public boolean add(TypedEdge<T> e) {
        if (e.from() == rootVertex) 
            return add(edges, e.to(), e.edgeType());
        else if (e.to() == rootVertex) 
            return add(edges, e.from(), e.edgeType());
        return false;
    }
1294421
public boolean add(WeightedDirectedTypedEdge<T> e) {
        if (e.from() == rootVertex) {
            Set<WeightedDirectedTypedEdge<T>> edges = outEdges.get(e.to());
            if (edges.contains(e))
                return false;

            // We can't rely on the edge's equality method since that uses the
            // edge weight, so we'll have to iterate over the edges to see if we
            // have one that matches the type, and if so replace it with the
            // different weight
            if (!edges.isEmpty()) {
                Iterator<WeightedDirectedTypedEdge<T>> iter = edges.iterator();
                WeightedDirectedTypedEdge<T> existing = null;
                while (iter.hasNext()) {
                    WeightedDirectedTypedEdge<T> n = iter.next();
                    if (n.to() == e.to() 
                            && n.edgeType().equals(e.edgeType())) {
                        existing = n;
                        break;
                    }
                }
                if (existing == null) {
                    outEdges.put(e.to(), e);
                    return true;                    
                }
                // Check if has the same weight;
                else if (e.weight() != existing.weight()) {
                    outEdges.remove(e.to(), existing);
                    outEdges.put(e.to(), e);
                    return true;
                }
                else 
                    return false;
            }
            else 
                return  outEdges.put(e.to(), e);
        }

        else if (e.to() == rootVertex) {
            Set<WeightedDirectedTypedEdge<T>> edges = inEdges.get(e.from());
            if (edges.contains(e))
                return false;

            // We can't rely on the edge's equality method since that uses the
            // edge weight, so we'll have to iterate over the edges to see if we
            // have one that matches the type, and if so replace it with the
            // different weight
            if (!edges.isEmpty()) {
                Iterator<WeightedDirectedTypedEdge<T>> iter = edges.iterator();
                WeightedDirectedTypedEdge<T> existing = null;
                while (iter.hasNext()) {
                    WeightedDirectedTypedEdge<T> n = iter.next();
                    if (n.from() == e.from() 
                            && n.edgeType().equals(e.edgeType())) {
                        existing = n;
                        break;
                    }
                }

                if (existing == null) {
                    inEdges.put(e.from(), e);
                    return true;                    
                }
                // Check if has the same weight;
                else if (e.weight() != existing.weight()) {
                    inEdges.remove(e.from(), existing);
                    inEdges.put(e.from(), e);
                    return true;
                }
                return false;
            }
            else 
                return inEdges.put(e.from(), e);
        }
        return false;
    }
987989
public void add(E e) {
    // resize when needed
    if(size + 1 > queue.length) {
      resize(size + 1);
    }
    // final int pos = size;
    this.size += 1;
    heapifyUp(size - 1, e);
    heapModified();
  }
18595
public void addChild(int offset, TreeElement child)
            throws IllegalArgumentException
    {
        child.setSelected(false);
        child.setParent(this);
        if (_children == null)
            _children = new ArrayList();
        _children.add(offset, child);

        //Need to rename all affected!
        int size = _children.size();
        for (int i = offset; i < size; i++) {
            TreeElement thisChild = (TreeElement) _children.get(i);
            thisChild.updateName(this, i);
        }

    }
1151250
public boolean add(Edge e) {
        int toAdd = -1;
        if (e.from() == rootVertex) 
            toAdd = e.to();        
        else if (e.to() == rootVertex)
            toAdd = e.from();
        else
            return false;
        boolean b = edges.add(toAdd);
        return b;
    }
1338500
public void addChild(Node node) throws ChildNodeException {
    if (node != null) {
      if (!allowChildren) {
        throw new ChildNodeException();
      }

      if (getFirstChild() == null) {
        setFirstChild(node);
        getFirstChild().setPrevSibling(firstChild);
        getFirstChild().setNextSibling(firstChild);
      } else {    // Add it to the end of the list
        Node lastChild = getFirstChild().getPrevSibling();
        if (lastChild != null) {
          lastChild.setNextSibling(node);
        }
        node.setNextSibling(getFirstChild());
      }
      node.setParent(this);
    }
  }
71667
public Node<T> addChild(Node<T> child) {
        if (children == null) {
            children = new ArrayList<Node<T>>();
        }
        child.parent = this;
        children.add(child);

        return child;
    }
524386
public void add(Exception e)
    {
        if (e instanceof MultiException)
        {
            MultiException me = (MultiException)e;
            for (int i=0;i<LazyList.size(me.nested);i++)
                nested=LazyList.add(nested,LazyList.get(me.nested,i));
        }
        else
            nested=LazyList.add(nested,e);
    }
574784
<T extends Node> NodeList<T> add(NodeList<T> list, T obj) {
        if (list == null) {
            list = new NodeList<>();
        }
        list.add(obj);
        return list;
    }
60770
public boolean add(E o) {
    	if(o!=null && !contains(o)){
    		return super.add(o);
    	}
    	return false;
    }
107261
@SuppressWarnings("unchecked")
  public void addChildren(List<? extends N> children) {
    // NOTE: if the input list comes from another node, this could cause
    // ConcurrentModificationExceptions as nodes are moved from one parent to another.  To avoid
    // this we make a copy of the input list.
    for (Node child : children.toArray(new Node[0])) {
      addChild((N) child);
    }
  }
620317
public boolean add(SeLionElement element) {
        // if already initialized, add the new elements to the front of the list.
        if (initialized) {
            CodeGeneratorLogger logger = CodeGeneratorLoggerFactory.getLogger();

            // info messages are only displayed after initialization happens
            if (isExactMatch(element.getElementClass())) {
                logger.info("Registering the element " + element + " which is now overwriting a pre-existing element.");
            } else {
                logger.info("Registering the element " + element + " as a valid element.");
            }

            SeLionElementSet elementSet = (SeLionElementSet) clone();
            clear();
            super.add(element);
            elementSet.stream().forEachOrdered(a -> super.add(a));
            return true;
        }
        return super.add(element);
    }
452105
public <T> boolean operator_add(/* @Nullable */ EList<? super T> list, /* @Nullable */ T element) {
		if(list != null && element != null)
			return list.add(element);
		else
			return false;
	}
1099473
private void addChildElements() {
        for (Node node : nodes) {
        	if(node instanceof NestableNode) {
	            List<Node> nl = ((NestableNode) node).getChildren();
	            for (Node n : nl) {
	                if (!(n instanceof Element)) {
	                    continue;
	                }
	                
	                String tag = selector.getTagName();
	                if (tagEquals(tag, ((Element)n).getNormalizedName()) || tag.equals(Selector.UNIVERSAL_TAG)) {
	                    result.add(n);
	                }
	            }
        	}
        }
    }
1119388
public boolean add(Object element) {

        last.next = new Node(element, null);
        last      = last.next;

        elementCount++;

        return true;
    }
1316655
SpanNode addChild(SpanNode child) {
    if (child == null) throw new NullPointerException("child == null");
    if (child == this) throw new IllegalArgumentException("circular dependency on " + this);
    if (children.equals(Collections.emptyList())) children = new ArrayList<>();
    children.add(child);
    child.parent = this;
    return this;
  }