/*---@Override
public void add(int index, Object element) {
list.add(index, element);
}

@Override
public boolean addAll(java.util.Collection c) {
return list.addAll(c);
}
333096
@Override
    public boolean addAll(int index, java.util.Collection c) {
	return list.addAll(index, c);
    }
82937
@Override
    public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: " + index +
                                                    ", Size: " + len);
            Object[] newElements;
            int numMoved = len - index;
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                newElements = new Object[len + 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            newElements[index] = element;
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }
1257180
public void addAll(Collection<T> objects) {
    if (objects != null) {
      for (T obj : objects) {
        add(obj);
      }
    }
  }
566589
@Override
	public boolean addAll(Collection<? extends BooleanTerm> terms) {
		boolean modified = false;
		// a null booleanTerms means that the expression is
		// already true, so no need to modify it
		if (terms == null) {
			modified = booleanTerms != null;
			booleanTerms = null;
		} else if (booleanTerms != null) {
			for (BooleanTerm term : terms) {
				modified |= add(term);
			}
		}
		return modified;
	}
1075471
public void addAll(Collection<? extends M> collection) {
        if (collection != null) {
            items.addAll(collection);
            applyFilter();
        }
    }
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;
	}
822621
@ReplacedBy("java.util.Collections#addAll()")
    public static <T, E extends T, C extends Collection<T>> C addAll (C col, E[] values)
    {
        if (values != null) {
            for (E value : values) {
                col.add(value);
            }
        }
        return col;
    }
1300828
@SafeVarargs
    public final void addAll(E... elements) {
        if (elements == null) throw new NullPointerException();
        addAll(Arrays.asList(elements));
    }
1287718
@Override
    public boolean addAll(Collection<? extends E> c) {
        for (E e : c) {
            discardingOffer(e);
        }
        return !c.isEmpty();
    }
523393
@Override
    public boolean addAll(@NonNull Collection<? extends E> collection) {
        final int size = collection.size();
        if (size > maxSize) {
            collection = new ArrayList<>(collection).subList(size - maxSize, size);
        }
        final int overhead = size() + collection.size() - maxSize;
        if (overhead > 0) {
            removeRange(0, overhead);
        }
        return super.addAll(collection);
    }
7383
public boolean add(Object o) {
		try {
			this.addElement((Element) o);
			return true;
		}
		catch(ClassCastException cce) {
			throw new ClassCastException("You can only add objects that implement the Element interface.");
		}
		catch(BadElementException bee) {
			throw new ClassCastException(bee.getMessage());
		}
	}
942759
protected Object add(Object list, Collection collection)
    {
        Iterator i=collection.iterator();
        while(i.hasNext())
            list=LazyList.add(list,i.next());
        return list;
    }
1266727
public boolean add(Collection<BtrpElement> elems) {
        boolean ret = false;
        for (BtrpElement el : elems) {
            ret |= add(el);
        }
        return ret;
    }
132352
public boolean add(Object o) {
        // find the index where this item should go
        // add the item @ the specified index
        int idx = 0;
        if(!isEmpty()) {
            idx = findInsertionPoint(o);
        }

        try {
            super.add(idx, o);
        }
        catch(IndexOutOfBoundsException e) {
            return false;
        }
        return true;
    }
1229909
@SafeVarargs
  /* #end */
  public final int addAll(KType... elements) {
    ensureCapacity(elements.length);
    int count = 0;
    for (KType e : elements) {
      if (add(e)) {
        count++;
      }
    }
    return count;
  }
705478
public void add(int index, double element)
    {
        if(index == size())//special case, just appending
        {
            add(element);
        }
        else
        {
            boundsCheck(index);
            enlageIfNeeded(1);
            System.arraycopy(array, index, array, index+1, size()-index);
            set(index, element);
            increasedSize(1);
        }
    }
539177
public boolean addAll(int index, Collection<? extends XEvent> c) {
		for (XEvent event : c) {
			try {
				events.insert(event, index);
			} catch (IOException e) {
				e.printStackTrace();
			}
			index++;
		}
		return (c.size() > 0);
	}