Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.util;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.NoSuchElementException;

/**

 *

 * @author jjdelcerro

 * @param <T>

 */

public class UnmodifiableBasicListToListAdapter<T> implements List<T> {

    private final UnmodifiableBasicList<T> basiclist;

    public UnmodifiableBasicListToListAdapter(UnmodifiableBasicList<T> basiclist) {

        this.basiclist = basiclist;

    }

    @Override

    public int size() {

        return this.basiclist.size();

    }

    @Override

    public boolean isEmpty() {

        return this.basiclist.isEmpty();

    }

    @Override

    public boolean contains(Object o) {

        return indexOf(o) >= 0;

    }

    @Override

    public Iterator<T> iterator() {

        return this.basiclist.iterator();

    }

    @Override

    public Object[] toArray() {

        int size = this.size();

        Object[] result = new Object[size];

        int i = 0;

        for (int j = 0; j < size; j++) {

            result[i++] = this.get(j);

        }

        return result;

    }

    @Override

    public <T> T[] toArray(T[] a) {

        int size = this.size();

        if (a.length < size)

            a = (T[])java.lang.reflect.Array.newInstance(

                a.getClass().getComponentType(), size

            );

        int i = 0;

        Object[] result = a;

        for (int j = 0; j < size; j++) {

            result[i++] = this.get(j);

        }

        if (a.length > size)

            a[size] = null;

        return a;

    }

    @Override

    public boolean add(T e) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean remove(Object o) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean containsAll(Collection<?> c) {

        for (Object e : c)

            if (!contains(e))

                return false;

        return true;

    }

    @Override

    public boolean addAll(Collection<? extends T> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean addAll(int index, Collection<? extends T> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean removeAll(Collection<?> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public boolean retainAll(Collection<?> c) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public void clear() {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public T get(int index) {

        return this.basiclist.get(index);

    }

    @Override

    public T set(int index, T element) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public void add(int index, T element) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public T remove(int index) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public int indexOf(Object o) {

        int size = this.basiclist.size();

        if (o == null) {

            for (int i = 0; i < size; i++)

                if (this.basiclist.get(i)==null)

                    return i;

        } else {

            for (int i = 0; i < size; i++)

                if (o.equals(this.basiclist.get(i)))

                    return i;

        }

        return -1;

    }

    @Override

    public int lastIndexOf(Object o) {

        int size = this.basiclist.size();

        if (o == null) {

            for (int i = size-1; i >= 0; i--)

                if (this.basiclist.get(i)==null)

                    return i;

        } else {

            for (int i = size-1; i >= 0; i--)

                if (o.equals(this.basiclist.get(i)))

                    return i;

        }

        return -1;

    }

    @Override

    public ListIterator<T> listIterator() {

        return new ListItr(0);

    }

    @Override

    public ListIterator<T> listIterator(int index) {

        if (index < 0 || index > size())

            throw new IndexOutOfBoundsException("Index: "+index);

        return new ListItr(index);

    }

    @Override

    public List<T> subList(int fromIndex, int toIndex) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    private class Itr implements Iterator<T> {

        int cursor;       // index of next element to return

        Itr() {}

        @Override

        public boolean hasNext() {

            return cursor != size();

        }

        @Override

        public T next() {

            int i = cursor;

            if (i >= size())

                throw new NoSuchElementException();

            cursor = i + 1;

            return basiclist.get(i);

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

    }

    private class ListItr extends Itr implements ListIterator<T> {

        ListItr(int index) {

            super();

            cursor = index;

        }

        @Override

        public boolean hasPrevious() {

            return cursor != 0;

        }

        @Override

        public int nextIndex() {

            return cursor;

        }

        @Override

        public int previousIndex() {

            return cursor - 1;

        }

        @Override

        public T previous() {

            int i = cursor - 1;

            if (i < 0)

                throw new NoSuchElementException();

            cursor = i;

            return  (T)basiclist.get(i);

        }

        @Override

        public void set(T e) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        @Override

        public void add(T e) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

    }

}