MyThreadProtectedElist implement EList{

public MyThreadProtectedEList ( EList list, Lock highlevellock){
internalList = list;
internalLock = lock;
}

// implement the synchronized calls to the internal list...

}

public class SynchronizedCopyOnWriteAdapterEList<E extends Object & Adapter> extends SynchronizedCopyOnWriteEList<E> implements EObservableAdapterList{

	private static final long serialVersionUID = -3748233483677878593L;

	protected Notifier notifier;

	protected CopyOnWriteArrayList<Listener> listeners;

	public SynchronizedCopyOnWriteAdapterEList(Notifier notifier)
	{
		this.notifier = notifier;
	}

	@Override
	protected boolean canContainNull()
	{
		return false;
	}

	@Override
	protected boolean useEquals()
	{
		return false;
	}

	@Override
	protected Object [] newData(int capacity)
	{
		return new Adapter [capacity];
	}

	@Override
	protected void didAdd(int index, E newObject)
	{
		if (listeners != null)
		{
			for (Listener listener : listeners)
			{
				listener.added(notifier, newObject);
			}
		}
		newObject.setTarget(notifier);
	}

	@Override
	protected void didRemove(int index, E oldObject)
	{
		if (listeners != null)
		{
			for (Listener listener : listeners)
			{
				listener.removed(notifier, oldObject);
			}
		}
		E adapter = oldObject;
		if (notifier.eDeliver())
		{
			Notification notification = 
					new NotificationImpl(Notification.REMOVING_ADAPTER, oldObject, null, index)
			{
				@Override
				public Object getNotifier()
				{
					return notifier;
				}
			};
			adapter.notifyChanged(notification);
		}
		if (adapter instanceof Adapter.Internal)
		{
			((Adapter.Internal)adapter).unsetTarget(notifier);
		}
		else if (adapter.getTarget() == notifier) 
		{
			adapter.setTarget(null);
		}
	}

	public void addListener(Listener listener)
	{
		listeners.add(listener);
	}

	public void removeListener(Listener listener)
	{
		listeners.remove(listener);
	}
	    
}

ublic class SynchronizedCopyOnWriteEList<E> extends BasicEList<E>{

	/**
	 * 
	 */
	private static final long serialVersionUID = 5770072918610284023L;
	final protected ReentrantLock notificationLock = new ReentrantLock(); 
	volatile protected CopyOnWriteArrayList<Object> data = new CopyOnWriteArrayList<Object>(); 

	/**
	 * Creates an empty instance with no initial capacity.
	 * The data storage will be null.
	 */
	public SynchronizedCopyOnWriteEList() 
	{
		super();
	}

	/**
	 * Creates an empty instance with the given capacity.
	 * @param initialCapacity the initial capacity of the list before it must grow.
	 * @exception IllegalArgumentException if the <code>initialCapacity</code> is negative.
	 */
	public SynchronizedCopyOnWriteEList(int initialCapacity) 
	{
		if (initialCapacity < 0)
		{
			throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);  
		}
		//	    data = newData(initialCapacity); 
	}

	/**
	 * Creates an instance that is a copy of the collection.
	 * @param collection the initial contents of the list.
	 */
	public SynchronizedCopyOnWriteEList(Collection<? extends E> collection) 
	{
		data.addAll(collection);  
	}

	/**
	 * Creates an initialized instance that directly uses the given arguments.
	 * @param size the size of the list.
	 * @param data the underlying storage of the list.
	 */
	protected SynchronizedCopyOnWriteEList(int size, Object [] data) 
	{
		this.data.addAll(Arrays.asList(data)); 
	}

	/**
	 * Returns new allocated data storage.
	 * Clients may override this to create typed storage.
	 * The cost of type checking via a typed array is negligible.
	 * @return new data storage.
	 */
	protected Object [] newData(int capacity)
	{
		return new Object [capacity];
	}

	/**
	 * Assigns the object into the data storage at the given index and returns the object that's been stored.
	 * Clients can monitor access to the storage via this method.
	 * @param index the position of the new content.
	 * @param object the new content.
	 * @return the object that's been stored.
	 * 
	 */
	protected E assign(int index, E object)
	{
		data.set(index, object);
		return object;
	}

	/**
	 * Returns the number of objects in the list.
	 * @return the number of objects in the list.
	 */
	@Override
	public int size() 
	{
		return data.size();
	}

	/**
	 * Returns whether the list has zero size.
	 * @return whether the list has zero size.
	 */
	@Override
	public boolean isEmpty() 
	{
		return data.isEmpty();
	}

	/**
	 * Returns whether the list contains the object.
	 * This implementation uses either <code>equals</code> or <code>"=="</code> depending on {@link #useEquals useEquals}.
	 * @param object the object in question.
	 * @return whether the list contains the object.
	 * @see #useEquals
	 */
	@Override
	public boolean contains(Object object) 
	{

		if (useEquals() && object != null)
		{
			return data.contains(object);
		}
		else
		{
			for (Object element : data) if (element == object) return true;
		}

		return false;
	}

	/**
	 * Returns the position of the first occurrence of the object in the list.
	 * This implementation uses either <code>equals</code> or <code>"=="</code> depending on {@link #useEquals useEquals}.
	 * @param object the object in question.
	 * @return the position of the first occurrence of the object in the list.
	 */
	@Override
	public int indexOf(Object object) 
	{

		if (useEquals() && object != null)
		{
			return data.indexOf(object);
		}
		else
		{
			int index = 0;
			for (Object element : data){
				if (element == object) return index;
				index++;
			}
		}

		return -1;
	}

	/**
	 * Returns the position of the last occurrence of the object in the list.
	 * This implementation uses either <code>equals</code> or <code>"=="</code> depending on {@link #useEquals useEquals}.
	 * @param object the object in question.
	 * @return the position of the last occurrence of the object in the list.
	 */
	@Override
	public int lastIndexOf(Object object) 
	{
		return data.lastIndexOf(object);
	}

	/**
	 * Returns an array containing all the objects in sequence.
	 * Clients may override {@link #newData newData} to create typed storage in this case.
	 * @return an array containing all the objects in sequence.
	 * @see #newData
	 */
	@Override
	public Object[] toArray() 
	{
		return data.toArray();
	}

	/**
	 * Returns an array containing all the objects in sequence.
	 * @param array the array that will be filled and returned, if it's big enough;
	 * otherwise, a suitably large array of the same type will be allocated and used instead.
	 * @return an array containing all the objects in sequence.
	 * @see #newData
	 */
	@Override
	public <T> T[] toArray(T[] array) 
	{
		return data.toArray(array);
	}

	/**
	 * Returns direct <b>unsafe</b> access to the underlying data storage.
	 * Clients may <b>not</b> modify this 
	 * and may <b>not</b> assume that the array remains valid as the list is modified.
	 * @return direct <b>unsafe</b> access to the underlying data storage.
	 */
	public Object [] data()
	{
		return data.toArray();
	}

	/**
	 * Updates directly and <b>unsafely</b> the underlying data storage.
	 * Clients <b>must</b> be aware that this subverts all callbacks 
	 * and hence possibly the integrity of the list. 
	 */
	public void setData(int size, Object [] data)
	{
		CopyOnWriteArrayList<Object> newList = new CopyOnWriteArrayList<Object>();
		newList.addAll(Arrays.asList(data));

		CopyOnWriteArrayList<Object> oldList = this.data;
		this.data = newList;
		oldList.clear();
		oldList = null;
	}

	/**
	 * An IndexOutOfBoundsException that constructs a message from the argument data.
	 * Having this avoids having the byte code that computes the message repeated/inlined at the creation site.
	 */
	protected static class BasicIndexOutOfBoundsException extends AbstractEList.BasicIndexOutOfBoundsException
	{
		private static final long serialVersionUID = 1L;

		/**
		 * Constructs an instance with a message based on the arguments.
		 */
		public BasicIndexOutOfBoundsException(int index, int size)
		{
			super(index, size);
		}
	}

	/**
	 * Returns the object at the index.
	 * This implementation delegates to {@link #resolve resolve} 
	 * so that clients may transform the fetched object.
	 * @param index the position in question.
	 * @return the object at the index.
	 * @exception IndexOutOfBoundsException if the index isn't within the size range.
	 * @see #resolve
	 * @see #basicGet
	 */
	@SuppressWarnings("unchecked")
	@Override
	public E get(int index) 
	{
		if (index >= size)
			throw new BasicIndexOutOfBoundsException(index, size);

		return resolve(index, (E)data.get(index));
	}

	/**
	 * Returns the object at the index without {@link #resolve resolving} it.
	 * @param index the position in question.
	 * @return the object at the index.
	 * @exception IndexOutOfBoundsException if the index isn't within the size range.
	 * @see #resolve
	 * @see #get
	 */
	@Override
	public E basicGet(int index)
	{
		if (index >= size)
			throw new BasicIndexOutOfBoundsException(index, size);

		return primitiveGet(index);
	}

	/**
	 * Returns the object at the index without {@link #resolve resolving} it and without range checking the index.
	 * @param index the position in question.
	 * @return the object at the index.
	 * @see #resolve
	 * @see #get
	 * @see #basicGet(int)
	 */
	@SuppressWarnings("unchecked")
	@Override
	protected E primitiveGet(int index)
	{
		return (E)data.get(index);
	}

	/**
	 * Sets the object at the index 
	 * and returns the old object at the index;
	 * it does no ranging checking or uniqueness checking.
	 * This implementation delegates to {@link #assign assign}, {@link #didSet didSet}, and {@link #didChange didChange}.
	 * @param index the position in question.
	 * @param object the object to set.
	 * @return the old object at the index.
	 * @see #set
	 */
	@Override
	public E setUnique(int index, E object)
	{
		notificationLock.lock();
		try{
			@SuppressWarnings("unchecked") E oldObject = (E)data.get(index);
			assign(index, validate(index, object));
			didSet(index, object, oldObject);
			didChange();
			return oldObject;
		}finally{
			notificationLock.unlock();
		}
	}

	/**
	 * Adds the object at the end of the list;
	 * it does no uniqueness checking.
	 * This implementation delegates to {@link #assign assign}, {@link #didAdd didAdd}, and {@link #didChange didChange}.
	 * after uniqueness checking.
	 * @param object the object to be added.
	 * @see #add(Object)
	 */
	@Override
	public void addUnique(E object) 
	{
		notificationLock.lock();
		try{
			int newIndex = data.size();
			data.add(validate(newIndex, object));
			didAdd(newIndex, object);
			didChange();
		}finally{
			notificationLock.unlock();
		}
	}

	/**
	 * Adds the object at the given index in the list;
	 * it does no ranging checking or uniqueness checking.
	 * This implementation delegates to {@link #assign assign}, {@link #didAdd didAdd}, and {@link #didChange didChange}.
	 * @param object the object to be added.
	 * @see #add(int, Object)
	 */
	@Override
	public void addUnique(int index, E object) 
	{
		notificationLock.lock();
		try{
			data.add(index, validate(data.size(), object));
			didAdd(index, object);
			didChange();
		}finally{
			notificationLock.unlock();
		}
	}

	/**
	 * Adds each object of the collection to the end of the list;
	 * it does no uniqueness checking.
	 * This implementation delegates to {@link #assign assign}, {@link #didAdd didAdd}, and {@link #didChange didChange}.
	 * @param collection the collection of objects to be added.
	 * @see #addAll(Collection)
	 */
	@Override
	public boolean addAllUnique(Collection<? extends E> collection) 
	{
		
		for ( E object: collection)
		{
			addUnique(object);
		}
		
		return collection.size() != 0;
	}

	/**
	 * Adds each object of the collection at each successive index in the list 
	 * and returns whether any objects were added;
	 * it does no ranging checking or uniqueness checking.
	 * This implementation delegates to {@link #assign assign}, {@link #didAdd didAdd}, and {@link #didChange didChange}.
	 * @param index the index at which to add.
	 * @param collection the collection of objects to be added.
	 * @return whether any objects were added.
	 * @see #addAll(int, Collection)
	 */
	@Override
	public boolean addAllUnique(int index, Collection<? extends E> collection) 
	{
		int insertIndex = index;
		for ( E object: collection)
		{
			addUnique(insertIndex, object);
			insertIndex++;
		}
		
		return collection.size() != 0;
	}

	/**
	 * Adds each object from start to end of the array at the index of list 
	 * and returns whether any objects were added;
	 * it does no ranging checking or uniqueness checking.
	 * This implementation delegates to {@link #assign assign}, {@link #didAdd didAdd}, and {@link #didChange didChange}.
	 * @param objects the objects to be added.
	 * @param start the index of first object to be added.
	 * @param end the index past the last object to be added.
	 * @return whether any objects were added.
	 * @see #addAllUnique(Object[], int, int)
	 */
	@Override
	public boolean addAllUnique(Object [] objects, int start, int end) 
	{
		for (int i = start; i < end; ++i)
		{
			@SuppressWarnings("unchecked") E object = (E)objects[i];
			addUnique(object);
		}

		return (end - start) != 0;
	}

	/**
	 * Adds each object from start to end of the array at each successive index in the list 
	 * and returns whether any objects were added;
	 * it does no ranging checking or uniqueness checking.
	 * This implementation delegates to {@link #assign assign}, {@link #didAdd didAdd}, and {@link #didChange didChange}.
	 * @param index the index at which to add.
	 * @param objects the objects to be added.
	 * @param start the index of first object to be added.
	 * @param end the index past the last object to be added.
	 * @return whether any objects were added.
	 * @see #addAllUnique(Object[], int, int)
	 */
	@Override
	public boolean addAllUnique(int index, Object [] objects, int start, int end) 
	{
		int insertIndex = index;
		for (int i = start; i < end; ++i)
		{
			@SuppressWarnings("unchecked") E object = (E)objects[i];
			addUnique(insertIndex, object);
			insertIndex++;
		}

		return (end - start) != 0;
	}

	/**
	 * Removes the object at the index from the list and returns it.
	 * This implementation delegates to {@link #didRemove didRemove} and {@link #didChange didChange}.
	 * @param index the position of the object to remove.
	 * @return the removed object.
	 * @exception IndexOutOfBoundsException if the index isn't within the size range.
	 */
	@Override
	public E remove(int index) 
	{
		notificationLock.lock();
		try{
			@SuppressWarnings("unchecked") E oldObject = (E) data.remove(index);
			didRemove(index, oldObject);
			didChange();
			return oldObject;
		}finally{
			notificationLock.unlock();
		}
	}

	/**
	 * Clears the list of all objects.
	 * This implementation discards the data storage without modifying it
	 * and delegates to {@link #didClear didClear} and {@link #didChange didChange}.
	 */
	@Override
	public void clear() 
	{
		notificationLock.lock();
		try{
			Object [] oldData = data.toArray();
			int oldSize = oldData.length;
			data.clear();
			didClear(oldSize, oldData);
			didChange();
		}finally{
			notificationLock.unlock();
		}
	}

	/**
	 * Moves the object at the source index of the list to the target index of the list
	 * and returns the moved object.
	 * This implementation delegates to {@link #assign assign}, {@link #didMove didMove}, and {@link #didChange didChange}.
	 * @param targetIndex the new position for the object in the list.
	 * @param sourceIndex the old position of the object in the list.
	 * @return the moved object.
	 * @exception IndexOutOfBoundsException if either index isn't within the size range.
	 */
	@Override
	public E move(int targetIndex, int sourceIndex)
	{
		notificationLock.lock();
		try{
			@SuppressWarnings("unchecked") E object = (E)data.remove(sourceIndex);
			data.add(targetIndex, object);
			didMove(targetIndex, object, sourceIndex);
			didChange();
			return object;
		}finally{
			notificationLock.unlock();
		}
	}

	/**
	 * Shrinks the capacity of the list to the minimal requirements.
	 * @see #grow
	 */
	public void shrink() 
	{
		// this is done by the arrayList.
	}

	/**
	 * Grows the capacity of the list 
	 * to ensure that no additional growth is needed until the size exceeds the specified minimum capacity.
	 * @see #shrink
	 */
	public void grow(int minimumCapacity) 
	{
		// this is done by the arrayList.
	}

	private synchronized void writeObject(ObjectOutputStream objectOutputStream) throws IOException
	{
		objectOutputStream.defaultWriteObject();
		if (data.isEmpty())
		{
			objectOutputStream.writeInt(0);
		}
		else
		{
			Object [] snapshotData = data.toArray();
			objectOutputStream.writeInt(snapshotData.length);
			for (int i = 0; i < snapshotData.length; ++i)
			{
				objectOutputStream.writeObject(snapshotData[i]);
			}
		}
	}

	private synchronized void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException
	{
		data.clear();
		objectInputStream.defaultReadObject();
		int arrayLength = objectInputStream.readInt();
		if (arrayLength > 0)
		{
			for (int i = 0; i < arrayLength; ++i)
			{
				notificationLock.lock();
				try{
					@SuppressWarnings("unchecked") E object = (E)objectInputStream.readObject();
					data.add(validate(i, object));
					didAdd(i, object);
				}finally{
					notificationLock.unlock();
				}
			}
		}
	}

	/**
	 * Returns a shallow copy of this list.
	 * @return a shallow copy of this list.
	 */
	@Override
	public Object clone() 
	{
		SynchronizedCopyOnWriteEList<E> clone = new SynchronizedCopyOnWriteEList<E>();
		clone.data.addAll(this.data);
		return clone;
	}

	/**
	 * An extensible iterator implementation.
	 * @deprecated 
	 * @see AbstractEList.EIterator
	 */
	@Deprecated
	protected class EIterator<E1> extends AbstractEList<E>.EIterator<E1>
	{
		// Pointless extension
	}

	/**
	 * An extended read-only iterator that does not {@link BasicEList#resolve resolve} objects.
	 * @deprecated
	 * @see AbstractEList.NonResolvingEIterator
	 */
	@Deprecated
	protected class NonResolvingEIterator<E1> extends AbstractEList<E>.NonResolvingEIterator<E1>
	{
		// Pointless extension
	}

	/**
	 * An extensible list iterator implementation.
	 * @deprecated
	 * @see AbstractEList.EListIterator
	 */
	@Deprecated
	protected class EListIterator<E1> extends AbstractEList<E>.EListIterator<E1>
	{
		/**
		 * Creates an instance.
		 */
		public EListIterator() 
		{
			super();
		}

		/**
		 * Creates an instance advanced to the index.
		 * @param index the starting index.
		 */
		public EListIterator(int index) 
		{
			super(index);
			cursor = index;
		}
	}

	/**
	 * An extended read-only list iterator that does not {@link BasicEList#resolve resolve} objects.
	 * @deprecated
	 * @see AbstractEList.NonResolvingEListIterator
	 */
	@Deprecated
	protected class NonResolvingEListIterator<E1> extends AbstractEList<E>.NonResolvingEListIterator<E1>
	{
		/**
		 * Creates an instance.
		 */
		public NonResolvingEListIterator()
		{
			super();
		}

		/**
		 * Creates an instance advanced to the index.
		 * @param index the starting index.
		 */
		public NonResolvingEListIterator(int index) 
		{
			super(index);
		}
	}

	/**
	 * An unmodifiable version of {@link BasicEList}.
	 */
	public static class UnmodifiableEList<E> extends SynchronizedCopyOnWriteEList<E>
	{
		private static final long serialVersionUID = 1L;

		/**
		 * Creates an initialized instance.
		 * @param size the size of the list.
		 * @param data the underlying storage of the list.
		 */
		public UnmodifiableEList(Object [] data) 
		{
			this.data.addAll(Arrays.asList(data));
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public E set(int index, E object) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public boolean add(E object) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public void add(int index, E object) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public boolean addAll(Collection<? extends E> collection) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public boolean addAll(int index, Collection<? extends E> collection) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public boolean remove(Object object) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public E remove(int index) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public boolean removeAll(Collection<?> collection) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public boolean retainAll(Collection<?> collection) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public void clear() 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public void move(int index, E object) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public E move(int targetIndex, int sourceIndex)
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public void shrink() 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Throws an exception.
		 * @exception UnsupportedOperationException always because it's not supported.
		 */
		@Override
		public void grow(int minimumCapacity) 
		{
			throw new UnsupportedOperationException();
		}

		/**
		 * Returns the {@link BasicEList#basicIterator basic iterator}.
		 * @return the basic iterator.
		 */
		@Override
		public Iterator<E> iterator() 
		{
			return basicIterator();
		}

		/**
		 * Returns the {@link #basicListIterator() basic list iterator}.
		 * @return the basic list iterator.
		 */
		@Override
		public ListIterator<E> listIterator() 
		{
			return basicListIterator();
		}

		/**
		 * Returns the {@link #basicListIterator(int) basic list iterator} advanced to the index.
		 * @param index the starting index.
		 * @return the basic list iterator.
		 */
		@Override
		public ListIterator<E> listIterator(int index) 
		{
			return basicListIterator(index);
		}
	}

	/**
	 * Returns an <b>unsafe</b> list that provides a {@link #resolve non-resolving} view of the underlying data storage.
	 * @return an <b>unsafe</b> list that provides a non-resolving view of the underlying data storage.
	 */
	@Override
	protected List<E> basicList()
	{
		if (size == 0)
		{
			return ECollections.emptyEList();
		}
		else
		{
			return new SynchronizedCopyOnWriteEList.UnmodifiableEList<E>(data.toArray());
		}
	}

	/**
	 * A <code>BasicEList</code> that {@link #useEquals uses} <code>==</code> instead of <code>equals</code> to compare members.
	 */
	public static class FastCompare<E> extends BasicEList<E>
	{
		private static final long serialVersionUID = 1L;

		/**
		 * Creates an empty instance with no initial capacity.
		 */
		public FastCompare()
		{
			super();
		}

		/**
		 * Creates an empty instance with the given capacity.
		 * @param initialCapacity the initial capacity of the list before it must grow.
		 * @exception IllegalArgumentException if the <code>initialCapacity</code> is negative.
		 */
		public FastCompare(int initialCapacity)
		{
			super(initialCapacity);
		}

		/**
		 * Creates an instance that is a copy of the collection.
		 * @param collection the initial contents of the list.
		 */
		public FastCompare(Collection<? extends E> collection)
		{
			super(collection.size());
			addAll(collection);
		}

		/**
		 * Returns <code>false</code> because this list uses <code>==</code>.
		 * @return <code>false</code>.
		 */
		@Override
		protected boolean useEquals()
		{
			return false;
		}
	}
	
	  /**
	   * Returns an iterator.
	   * This implementation allocates a {@link AbstractEList.EIterator}.
	   * @return an iterator.
	   * @see AbstractEList.EIterator
	   */
	  @Override
	  public Iterator<E> iterator()
	  {
	    return new SynchronizedCopyOnWriteEIterator();
	  }

	  /**
	   * An extensible iterator implementation.
	   */
	  protected class SynchronizedCopyOnWriteEIterator implements Iterator<E>
	  {
		  int index = -1;
		 Iterator<Object> internalIterator = data.iterator();
		  
		@Override
		public boolean hasNext() {
			return internalIterator.hasNext();
		}

		@SuppressWarnings("unchecked")
		@Override
		public E next() {
			index++;
			E object = (E)internalIterator.next();
			return resolve(index, object);
		}

		@Override
		public void remove() {
			internalIterator.remove();
		}
	  }

	  /**
	   * Returns a read-only iterator that does not {@link #resolve resolve} objects.
	   * This implementation allocates a {@link NonResolvingEIterator}.
	   * @return a read-only iterator that does not resolve objects.
	   */
	  protected Iterator<E> basicIterator()
	  {
	    return new NonResolvingSynchronizedCopyOnWriteEIterator();
	  }

	  /**
	   * An extended read-only iterator that does not {@link AbstractEList#resolve resolve} objects.
	   */
	  protected class NonResolvingSynchronizedCopyOnWriteEIterator extends SynchronizedCopyOnWriteEIterator
	  {
		  @SuppressWarnings("unchecked")
		  @Override
		  public E next() {
			  index++;
			  return (E)internalIterator.next();
		  }

		  /**
		   * Throws and exception.
		   * @exception UnsupportedOperationException always because it's not supported.
		   */
		  @Override
		  public void remove()
		  {
			  throw new UnsupportedOperationException();
		  }
	  }
}