// java.util.Vector -- an implementation of the Java Language Spec sec 21.11
// Written by Charles Briscoe-Smith; refer to the file LEGAL for details.

package java.util;

class VectorEnumeration implements Enumeration {

	private int nextElement=0;
	private Object[] elements;
	private int elementCount;

	VectorEnumeration(Object[] elems, int count)
	{
		elements=elems;
		elementCount=count;
	}

	public boolean hasMoreElements()
	{
		return nextElement<elementCount;
	}

	public Object nextElement() throws NoSuchElementException
	{
		if (!hasMoreElements())
			throw new NoSuchElementException();
		return elements[nextElement++];
	}

}

public class Vector implements Cloneable {

	// SUBCLASS INTERFACE
	protected Object[] elementData;
	protected int elementCount;
	protected int capacityIncrement;

	// CONSTRUCTORS
	public Vector(int initialCapacity, int capacityIncrement)
	{
		elementData=new Object[initialCapacity];
		this.capacityIncrement=capacityIncrement;
		elementCount=0;
	}
	public Vector(int initialCapacity)
	{
		this(initialCapacity, 0);
	}
	public Vector()
	{
		this(10, 0);
	}

	// PUBLIC INTERFACE
	public final synchronized String toString()
	{
		StringBuffer output=new StringBuffer();
		output.append('[');
		for (int i=0; i<elementCount; i++) {
			if (i>0) output.append(", ");
			output.append(elementData[i]);
		}
		output.append(']');
		return output.toString();
	}

	public synchronized Object clone()
	{
		Vector v=new Vector();
		v.capacityIncrement=capacityIncrement;
		v.elementCount=elementCount;
		v.elementData=new Object[elementData.length];
		for (int i=0; i<elementData.length; i++) {
			v.elementData[i]=elementData[i];
		}
		return v;
	}

	public final synchronized Object elementAt(int index)
			throws IndexOutOfBoundsException
	{
		if (index<0 || index>=elementCount)
			throw new IndexOutOfBoundsException();
		else
			return elementData[index];
	}

	public final synchronized void setElementAt(Object obj, int index)
			throws IndexOutOfBoundsException
	{
		if (index<0 || index>=elementCount)
			throw new IndexOutOfBoundsException();
		else
			elementData[index]=obj;
	}

	public final synchronized Object firstElement()
			throws NoSuchElementException
	{
		if (elementCount==0)
			throw new NoSuchElementException();
		else
			return elementData[0];
	}

	public final synchronized Object lastElement()
			throws NoSuchElementException
	{
		if (elementCount==0)
			throw new NoSuchElementException();
		else
			return elementData[elementCount-1];
	}

	public final synchronized void addElement(Object o)
	{
		ensureCapacity(elementCount+1);
		elementData[elementCount++]=o;
	}

	public final synchronized void insertElementAt(Object o, int index)
			throws IndexOutOfBoundsException
	{
		if (index<0 || index>elementCount)
			throw new IndexOutOfBoundsException();
		ensureCapacity(elementCount+1);
		for (int i=elementCount-1; i>=index; i++) {
			elementData[i+1]=elementData[i];
		}
		elementData[index]=o;
		elementCount++;
	}

	public final synchronized boolean removeElement(Object o)
	{
		int i=indexOf(o);
		if (i>=0) {
			removeElementAt(i);
			return true;
		} else {
			return false;
		}
	}

	public final synchronized void removeElementAt(int index)
			throws IndexOutOfBoundsException
	{
		if (index<0 || index>=elementCount)
			throw new IndexOutOfBoundsException();
		for (int i=index+1; i<elementCount; i++) {
			elementData[i-1]=elementData[i];
		}
		elementCount--;
	}

	public final synchronized void removeAllElements()
	{
		elementCount=0;
	}

	public final synchronized boolean isEmpty()
	{
		return elementCount==0;
	}

	public final synchronized int size()
	{
		return elementCount;
	}

	public final synchronized void setSize(int newsize)
	{
		ensureCapacity(newsize);
		for (int i=elementCount; i<newsize; i++) {
			elementData[i]=null;
		}
		elementCount=newsize;
	}

	public final synchronized int capacity()
	{
		return elementData.length;
	}

	// Private helper method for ensureCapacity() and trimToSize()
	private void adjustSize(int newcap)
	{
		Object[] newdata=new Object[newcap];
		copyInto(newdata);
		elementData=newdata;
	}

	public final synchronized void ensureCapacity(int mincap)
	{
		if (mincap<=elementData.length)
			return;
		int newcap=elementData.length;
		if (capacityIncrement==0) {
			newcap*=2;
		} else {
			newcap+=capacityIncrement;
		}
		if (mincap>newcap) newcap=mincap;
		adjustSize(newcap);
	}

	public final synchronized void trimToSize()
	{
		adjustSize(elementCount);
	}

	public final synchronized void copyInto(Object[] anarray)
			throws IndexOutOfBoundsException
	{
		for (int i=0; i<elementCount; i++) {
			anarray[i]=elementData[i];
		}
	}

	public final synchronized Enumeration elements()
	{
		return new VectorEnumeration(elementData, elementCount);
	}

	public final boolean contains(Object elem)
	{
		return indexOf(elem, 0)!=-1;
	}

	public final int indexOf(Object elem)
	{
		return indexOf(elem, 0);
	}

	public final synchronized int indexOf(Object elem, int index)
	{
		for (int i=index; i<elementCount; i++) {
			if (elem.equals(elementData[i])) {
				return i;
			}
		}
		return -1;
	}

	public final int lastIndexOf(Object elem)
	{
		return lastIndexOf(elem, elementCount-1);
	}

	public final synchronized int lastIndexOf(Object elem, int index)
	{
		for (int i=index; i>=0; i--) {
			if (elem.equals(elementData[i])) {
				return i;
			}
		}
	}

}