All all elements in the collection. Expand if necessary.

@param toAdd
- elements to add.
@return
516297
public boolean addAll(Collection<? extends T> toAdd) {
    boolean changed = false;
    for (T elem : toAdd) {
      changed |= addElem(elem);
    }
    expandIfNecessary();
    return changed;
  }
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;
    }
165852
public Guid append(Guid... guids) throws IOException {
    if (guids == null || guids.length == 0) {
      return this;
    }
    return combine(ArrayUtils.add(guids, this));
  }
1075471
public void addAll(Collection<? extends M> collection) {
        if (collection != null) {
            items.addAll(collection);
            applyFilter();
        }
    }
184123
public int addAll(KTypeContainer<? extends KType> container) {
    ensureCapacity(container.size());
    return addAll((Iterable<? extends KTypeCursor<? extends KType>>) container);
  }
1214316
@NonNull
    Collection<TObj> getAll() {
        Collection<TObj> result = new LinkedList<>();
        for (int countR = mData.size(), i = 0; i < countR; i++) {
            int rowKey = mData.keyAt(i);
            SparseArrayCompat<TObj> columns = mData.get(rowKey);
            for (int countC = columns.size(), j = 0; j < countC; j++) {
                int key = columns.keyAt(j);
                result.add(columns.get(key));
            }
        }
        return result;
    }
299306
static <E> boolean addAllImpl(Multiset<E> self, Collection<? extends E> elements) {
    if (elements.isEmpty()) {
      return false;
    }
    if (elements instanceof Multiset) {
      Multiset<? extends E> that = cast(elements);
      for (Entry<? extends E> entry : that.entrySet()) {
        self.add(entry.getElement(), entry.getCount());
      }
    } else {
      Iterators.addAll(self, elements.iterator());
    }
    return true;
  }
555177
public static List<ScopeListExtension> findAll(Collection<? extends Extension> extensions)
    {
        List<ScopeListExtension> result = new ArrayList<ScopeListExtension>();
        for (Extension extension : extensions)
        {
            if (SCOPE_LIST_EXTENSION_ID == extension.getId())
                result.add((ScopeListExtension)extension);
        }
        return result;
    }
186616
public synchronized List<E> getAll() {
		ArrayList<E> list = new ArrayList<E>();

		for (E element : listElements) {
			if (element != null) {
				list.add(element);
			}
		}

		return list;
	}
589881
public HllUpdate addAll(Collection<String> elements)
    {
        if (elements == null)
        {
            throw new IllegalArgumentException("Elements cannot be null");
        }

        for (String element : elements)
        {
            this.adds.add(BinaryValue.create(element));
        }

        return this;
    }
440676
public static <SOURCE, TARGET> AddAll<SOURCE, TARGET> to(Position.Readable<TARGET> targetPosition,
        Position.Readable<SOURCE> sourcePosition) {
        return new AddAll<>(sourcePosition, targetPosition);
    }
308042
public boolean addAll(final ObjectHashSet<T> coll)
    {
        boolean acc = false;

        for (final T value : coll.values)
        {
            if (value != MISSING_VALUE)
            {
                acc |= add(value);
            }
        }

        return acc;
    }
783840
public void addAll(Set<? extends E> set) {
		if(set.size()<=MAXIMUM_COMBINE_SIZE) {
			if(combined==null) combined = new HashSet<>(set);
			else combined.addAll(set);
		} else {
			added.add(set);
		}
	}
262946
@ReplacedBy("com.google.common.collect.Iterators#addAll()")
    public static <T, C extends Collection<T>> C addAll (C col, Iterator<? extends T> iter)
    {
        while (iter.hasNext()) {
            col.add(iter.next());
        }
        return col;
    }
765013
@Override
  public boolean addAll(Collection<? extends Character> c) {
    ensureCapacity(size + c.size());
    for (char e : c) {
      elements[size++] = e;
    }
    return c.size() > 0;
  }
338661
public MaxHeap<E> addAll(Collection<E> collection)
    {
        for (E e : collection)
        {
            add(e);
        }

        return this;
    }
741440
@Override
	public boolean addAll(final int index, final Collection<? extends V> c) {
		return this.list.addAll(index, c);
	}