MorphicList.java

package edu.udel.cis.vsl.tass.morph;

import java.util.Iterator;
import java.util.LinkedList;

public class MorphicList<T extends Morphic> extends MorphicObject implements
		Iterable<T> {

	LinkedList<T> data = new LinkedList<T>();

	public MorphicList() {
	}

	@Override
	protected void commitChildren() {
		for (T element : data)
			if (element != null)
				element.commit();
	}

	@Override
	protected boolean computeEquals(Morphic component) {
		if (component instanceof MorphicList<?>) {
			return data.equals(((MorphicList<?>) component).data);
		}
		return false;
	}

	@Override
	protected int computeHashCode() {
		return data.hashCode();
	}

	@SuppressWarnings("unchecked")
	void canonicalizeChildren(MorphicFactoryIF<? super T> elementFactory) {
		LinkedList<T> newData = null;

		for (T element : data) {
			T newElement = (T) elementFactory.canonic(element);

			if (newElement != element) {
				if (newData == null) {
					newData = new LinkedList<T>();
					for (T x : data) {
						if (x == element)
							break;
						newData.add(x);
					}
				}
				newData.add(newElement);
			} else if (newData != null) {
				newData.add(element);
			}
		}
		if (newData != null)
			data = newData;
	}

	public void add(T element) {
		assert !isCommitted();
		data.add(element);
	}

	public void add(int index, T element) {
		assert !isCommitted();
		data.add(index, element);
	}

	public void addFirst(T element) {
		assert !isCommitted();
		data.addFirst(element);
	}

	public T getFirst() {
		return data.getFirst();
	}

	public T getLast() {
		return data.getLast();
	}

	public T removeLast() {
		assert !isCommitted();
		return data.removeLast();
	}

	public T removeFirst() {
		assert !isCommitted();
		return data.removeFirst();
	}

	public T remove(int index) {
		assert !isCommitted();
		return data.remove(index);
	}

	public T set(int index, T element) {
		assert !isCommitted();
		return data.set(index, element);
	}

	@Override
	public Iterator<T> iterator() {
		return data.iterator();
	}
}