source: other-projects/the-macronizer/trunk/src/java/util/FixedLinkedList.java@ 35719

package util;

import java.util.Collection;
import java.util.LinkedList;

/**
 * A fixed sized linked list implementation. 
 * Insertions at the front and back result in overflow being removed from the
 * back and front respectively.
 *
 * @author University of Waikato - Te Whare Wānanga o Waikato
 * @version 1.0
 * @since   2014-11-20 
 */
public class FixedLinkedList<T> extends LinkedList<T> {

    private int fixedSize;

    public FixedLinkedList(int fixedSize) {
        this.fixedSize = fixedSize;
    }

    /**
     *add T to the front of the link list 
     * @param T 
     */
    @Override
    public void addFirst(T e) {
        super.addFirst(e);
        if (size() > fixedSize) {
            super.removeLast();
        }
    }
    /**
     *add T to the end of the link list 
     * @param T e
     */
    @Override
    public void addLast(T e) {
        super.addLast(e);
        if (size() > fixedSize) {
            super.removeFirst();
        }
    }

     /**
     *add T to the list with super.add the test to see if the list is bigger then its fixed size if so it removes the first item from the list.
     * @param T e
     */
    @Override
    public boolean add(T e) {
        boolean result = super.add(e);
        if (size() > fixedSize) {
            super.removeFirst();
        }
        return result;
    }

     /**
     *add T to the list at given index with super.add then test to see if the list is bigger then its fixed size if so it removes the last item from the end of the list.
     * @param int index to be add at
     * @param T e 
     */
    @Override
    public void add(int index, T element) {
        super.add(index, element);
        if (size() > fixedSize) {
            super.removeLast();
        }
    }

    /**
     *Adds all items in a collection to the list with super.addAll. Then test to see is the list is bigger then the its fixed size. If so it removed the fist item in the list into the list is of size fixedSize.
     * @param Collectiont Collection of items to be add to the list.
     */
    @Override
    public boolean addAll(Collection<? extends T> c) {
        boolean result = super.addAll(c);
        while (size() > fixedSize) {
            super.removeFirst();
        }
        return result;
    }

    /**
     *add T to the front of the link list 
     * @param T e
     */
    @Override
    public void push(T e) {
        addFirst(e);
    }

    /**
     *add T to the end of the link list 
     * @param T e
     */
    @Override
    public boolean offer(T e) {
        boolean result = super.offer(e);
        if (size() > fixedSize) {
            super.removeFirst();
        }
        return result;
    }
  /**
     *Inserts the specified element at the front of this list.
     * @param T e
     */
    @Override
    public boolean offerFirst(T e) {
        boolean result = super.offerFirst(e);
        if (size() > fixedSize) {
            super.removeLast();
        }
        return result;
    }
  /**
     *Inserts the specified element at the end of this list.
     * @param T e
     */
    @Override
    public boolean offerLast(T e) {
        boolean result = super.offerLast(e);
        if (size() > fixedSize) {
            super.removeFirst();
        }
        return result;
    }



}