SortedQueue

package puppy.hanii.library.collections;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Queue;
import org.apache.commons.lang.NullArgumentException;
import puppy.hanii.library.handling.lists.SortedListHandler;
import puppy.hanii.library.misc.Lambda;

public class SortedQueue<T> implements Queue<T>
{
    //<editor-fold defaultstate="collapsed" desc="Constructors">
    public SortedQueue(Lambda<T, Comparable> keyGetter)
    {
        members = new ArrayList<T>();
        this.keyGetter = keyGetter;
        membersHandler = new SortedListHandler<T>(keyGetter);
    }

    public SortedQueue(Lambda<T, Comparable> keyGetter, T... members)
    { this(keyGetter, Arrays.asList(members)); }

    public SortedQueue(Lambda<T, Comparable> keyGetter, Collection<? extends T> members)
    {
        this.members = new ArrayList<T>(members);
        this.keyGetter = keyGetter;
        membersHandler = new SortedListHandler<T>(keyGetter);
    }

    public SortedQueue(T[] members, Lambda<T, Comparable> keyGetter)
    { this(keyGetter, Arrays.asList(members)); }

    public SortedQueue(Collection<? extends T> members, Lambda<T, Comparable> keyGetter)
    { this(keyGetter, members); }
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Fields">
    final List<T> members;
    final SortedListHandler<T> membersHandler;
    final Lambda<T, Comparable> keyGetter;
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Methods">
    //<editor-fold defaultstate="collapsed" desc="Adders">
    @Override
    public boolean add(T e)
    {
        if(e == null)
            throw new NullArgumentException("e");

        synchronized(members)
        { return membersHandler.insertEvenIfAlreadyPresent(members, e) >= 0; }
    }

    @Override
    public boolean addAll(Collection<? extends T> clctn)
    {
        if(clctn == null)
            throw new NullArgumentException("clctn");

        for(T i : clctn)
            if(i == null)
                throw new NullArgumentException("Member of clctn");

        synchronized(members)
        {
            if(members.addAll(clctn))
            {
                List<T> temp = membersHandler.quickSort(members);
                members.clear();
                members.addAll(temp);
                return true;
            }

            return false;
        }
    }

    @Override
    public boolean offer(T e)
    { return add(e); }
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Getters/Removers">
    public T get(boolean remove)
    {
        synchronized(members)
        {
            if(members.size() <= 0)
                throw new NoSuchElementException();

            if(remove)
                return members.remove(0);
            else
                return members.get(0);
        }
    }

    @Override
    public T remove()
    { return get(true); }

    @Override
    public boolean remove(Object o)
    {
        if(o == null)
            throw new NullArgumentException("o");

        synchronized(members)
        { return members.remove(o); }
    }

    @Override
    public T poll()
    {
        try
        { return get(true); }
        catch(NoSuchElementException e)
        { return null; }
    }

    @Override
    public T element()
    { return get(false); }

    @Override
    public T peek()
    {
        try
        { return get(false); }
        catch(NoSuchElementException e)
        { return null; }
    }

    @Override
    public boolean removeAll(Collection<?> clctn)
    {
        synchronized(members)
        { return members.removeAll(clctn); }
    }

    @Override
    public boolean retainAll(Collection<?> clctn)
    {
        synchronized(members)
        { return members.retainAll(clctn); }
    }

    @Override
    public void clear()
    {
        synchronized(members)
        { members.clear(); }
    }
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Accessors">
    @Override
    public int size()
    {
        synchronized(members)
        { return members.size(); }
    }

    @Override
    public boolean isEmpty()
    {
        synchronized(members)
        { return members.isEmpty(); }
    }

    @Override
    public boolean contains(Object o)
    {
        synchronized(members)
        { return members.contains(o); }
    }

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

    @Override
    public Object[] toArray()
    {
        synchronized(members)
        { return members.toArray(); }
    }

    @Override
    public <T> T[] toArray(T[] ts)
    {
        synchronized(members)
        { return members.toArray(ts); }
    }

    @Override
    public boolean containsAll(Collection<?> clctn)
    {
        synchronized(members)
        { return members.containsAll(clctn); }
    }
    //</editor-fold>
    //</editor-fold>
}