Add all elements of the given enumeration into the given collection.
342335
public static <T> void addAll(Collection<T> col, Enumeration<T> e) {
		while (e.hasMoreElements())
			col.add(e.nextElement());
	}
526522
public void add(Iterable<XElement> elements) {
        for (XElement e : elements) {
            e.parent = this;
            children.add(e);
        }
    }
1194189
public static <T> Iterable<T> iterable(Enumeration<T> enumeration) {
		LinkedList<T> list = new LinkedList<>();
		while (enumeration.hasMoreElements()) list.add(enumeration.nextElement());
		return list;
	}
1014031
public static <T> Collection<T> addAll(Collection<T> collection, Iterator<T> iterator) {
		if (null != collection && null != iterator) {
			while (iterator.hasNext()) {
				collection.add(iterator.next());
			}
		}
		return collection;
	}
378886
public static <K, V> Collection<V> addAllValuesTo(Map<K, V> map, Collection<V> targetCollection)
    {
        MapIterate.forEachValue(map, CollectionAddProcedure.on(targetCollection));
        return targetCollection;
    }
1214232
protected void addEnumList(String key, List<? extends Enum> list) {
        optionsMap.put(key, list.stream().map(i -> i.toString()).collect(Collectors.toList()));
    }
204442
@Override
    public boolean addAll(int location, Collection<? extends E> collection) {
        // int totalNeededSize = size() + collection.size();
        // int overhead = totalNeededSize - maxSize;
        // if(overhead > 0) {
        // removeRange(0, overhead);
        // }
        // return super.addAll(location, collection);
        if(location == size()){
            return super.addAll(location, collection);
        }
        throw new UnsupportedOperationException();
    }
910572
public void addAll(Iterable<? extends E> elements) {
        if (elements == null) throw new NullPointerException();
        for (E element : elements) {
            add(element);
        }
    }
828185
@ReplacedBy("com.google.common.collect.Iterators#addAll(Collection, com.google.common.collect.Iterators#forEnumeration(Enumeration))")
    public static <T, C extends Collection<T>> C addAll (C col, Enumeration<? extends T> enm)
    {
        while (enm.hasMoreElements()) {
            col.add(enm.nextElement());
        }
        return col;
    }
817240
@Override
	@SuppressWarnings("unchecked")
	public boolean addAll(Collection<? extends E> c) {
		if(c.isEmpty()) return false;
		if(c instanceof Set) return addAll((Set<? extends E>)c);
		else throw new UnsupportedOperationException("May only add sets");
	}
387873
public static <T> boolean addAll(Collection<T> self, Iterator<T> items) {
        boolean changed = false;
        while (items.hasNext()) {
            T next =  items.next();
            if (self.add(next)) changed = true;
        }
        return changed;
    }
891717
public function addAll(array $elements)
    {
        if (is_array($elements)) {
            foreach ($elements as $element) {
                $this->_items[] = $element;
            }
            $this->_iterator = null;
        } else {
            throw new CollectionException('Given array can not added to collection, because it is no array.', E_NOTICE);
        }
    }
1349086
public static <T> ArrayList<T> newArrayList(Enumeration<T> enumration) {
		return (ArrayList<T>) list(false, enumration);
	}
164313
void addAll(Hashset set) {
    for (Enumeration e = set.table.keys(); e.hasMoreElements();)
      add(e.nextElement());
  }

  /**
   * Removes all the objects from this set.
   */
  void clear() {
    table.clear();
  }

  /**
   * Get an enumeration will all the objects from this set.
   * @return an enumeration with all the objects from this set.
   */
  Enumeration members() {
    return table.keys();
  }
}
333096
@Override
    public boolean addAll(int index, java.util.Collection c) {
	return list.addAll(index, c);
    }
1031576
def add(self, elem):
        
        if isinstance(elem, self._allowedTypes):
            self._collection.add(elem)
            self._collectedTypes.add(type(elem).__name__)
        else:
            raise CollectionTypeError("{} can only contain '{}', '{}' is not allowed.".format(type(self).__name__, self._allowedTypes, elem))
710753
public ElementsBuilder addAll(HTMLElement... elements) {
        for (HTMLElement element : elements) {
            add(element);
        }
        return that();
    }