Adds all entries of the TColor collection to the list (shallow copy only,
manipulating the new list will modify the original colors).
@param {Array} collection
@return itself
332660
function(collection){
		var self = this;
        if( !is.Array(collection) ){
            this.colors.push(collection);
        } else {
            each(collection,function(color){
                self.colors.push(color);
            });
        }
		return this;
	}
794074
public Option color(Object... colors) {
        if (colors == null || colors.length == 0) {
            return this;
        }
        this.color().addAll(Arrays.asList(colors));
        return this;
    }
670244
public static <T> boolean addAll(
      Collection<T> addTo, Iterator<? extends T> iterator) {
    checkNotNull(addTo);
    checkNotNull(iterator);
    boolean wasModified = false;
    while (iterator.hasNext()) {
      wasModified |= addTo.add(iterator.next());
    }
    return wasModified;
  }
942759
protected Object add(Object list, Collection collection)
    {
        Iterator i=collection.iterator();
        while(i.hasNext())
            list=LazyList.add(list,i.next());
        return list;
    }
620675
public static <T> List<T> convertCollectionToList(final Collection<T> collection) {

        if(List.class.isAssignableFrom(collection.getClass())) {
            return (List<T>)collection;
        }

        return new ArrayList<>(collection);

    }
148649
public function addCollection(Collection $collection)
    {
        $metadata = $collection->getDocumentMetadata();
        $this->collectionMapping[$metadata->getName()] = $collection;
    }
62169
@SuppressWarnings({ "rawtypes", "unchecked" })
	public boolean addAll(Collection<? extends T> values)
	{
		boolean wasAllAdded = true;
		for (Iterator iterator = values.iterator(); iterator.hasNext();)
		{
			if(!add((T)iterator.next()))
				wasAllAdded = false;
			
		}
		
		return wasAllAdded;
	}
887377
public static <T extends CharSequence> Collection<T> removeBlank(Collection<T> collection) {
		return filter(collection, new Filter<T>() {
			@Override
			public boolean accept(T t) {
				return false == StrUtil.isBlank(t);
			}
		});
	}
732328
public Collection<V> put(K key, Collection<V> collection) {
    return map.put(key, collection);
  }
127681
public boolean addAll(Collection<T> items)
	{
		boolean wasAllAdded = true;
		for (T item : items)
		{
			if(!add(item))
				wasAllAdded = false;
		}
		
		return wasAllAdded;
	}
1052999
public static <T, C extends Collection<? super T>> C toCollection(
        Iterator<T> iterator, C collection)
    {
        Objects.requireNonNull(iterator, "The iterator is null");
        Objects.requireNonNull(iterator, "The collection is null");
        while (iterator.hasNext())
        {
            collection.add(iterator.next());
        }
        return collection;
    }
28827
public static function addCollection($collection)
  {
    static::checkConnexion();
    $r = self::$db->createCollection($collection);
    if (gettype($r) == 'object' && get_class($r) == 'MongoCollection') {
      return true;
    }
    return false;
  }
896290
public JcCollection<JcValue> addAll(Collection<?> coll) {
		JcCollection<JcValue> ret = new JcCollection<JcValue>(null, coll, this,
				OPERATOR.Collection.ADD_ALL);
		QueryRecorder.recordInvocationConditional(this, "addAll", ret, QueryRecorder.literal(coll));
		return ret;
	}
480536
public final RiakIndex<T> add(Collection<T> values)
    {
        for (T value : values)
        {
            add(value);
        }

        return this;
    }
720321
public boolean addAll(Collection<? extends Character> c) {
        boolean retVal = false;
        final Iterator<? extends Character> i = c.iterator();
        int n = c.size();
        while (n-- != 0)
            if (add(i.next())) retVal = true;
        return retVal;
    }
841388
function fillCollection(collection, max, callback) {
    collection.count(function(err,count) {
        console.log(collection+" count = "+count)
        while (count < max) {
            var toInsert = []
            while (count < max) {
                toInsert.push({ foo: Math.random(), index: count++ })
                if (toInsert.length == 300) {
                    break
                }
            }
            console.log("inserting "+toInsert.length+" document(s) into "+collection)
            collection.insert(toInsert)
        }
        callback()
    })
}
338661
public MaxHeap<E> addAll(Collection<E> collection)
    {
        for (E e : collection)
        {
            add(e);
        }

        return this;
    }