/*
    * File: ImmutableList.java
    * Created: 11-čen-06 7:39:20 
    *
    * Copyright 2006 Michal Burda.
    *
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
   */
  package net.sf.webmancer.util.immutable;
  
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  
  /**
   * @author Michal Burda
   * @param <T>
   */
  public final class ImmutableList<T> implements List<T> {
      private List<? extends T> list;
  
      /**
       * 
       */
      public ImmutableList(final List<? extends T> list) {
          super();
          this.list = list;
      }
  
      /**
       * @see java.util.List#containsAll(java.util.Collection)
       */
      public boolean containsAll(final Collection<?> c) {
          return this.list.containsAll(c);
      }
  
      /**
       * @see java.util.List#contains(java.lang.Object)
       */
      public boolean contains(final Object o) {
          return this.list.contains(o);
      }
  
      /**
       * @see java.util.List#equals(java.lang.Object)
       */
      @Override
      public boolean equals(final Object o) {
          return this.list.equals(o);
      }
  
      /**
       * @see java.util.List#get(int)
       */
      public T get(final int index) {
          return this.list.get(index);
      }
  
      /**
       * @see java.util.List#hashCode()
       */
      @Override
      public int hashCode() {
          return this.list.hashCode();
      }
  
      /**
       * @see java.util.List#indexOf(java.lang.Object)
       */
      public int indexOf(final Object o) {
          return this.list.indexOf(o);
      }
  
      /**
       * @see java.util.List#isEmpty()
       */
      public boolean isEmpty() {
          return this.list.isEmpty();
      }
  
      /**
       * @see java.util.List#lastIndexOf(java.lang.Object)
       */
      public int lastIndexOf(final Object o) {
          return this.list.lastIndexOf(o);
      }
 
     /**
      * @see java.util.List#size()
      */
     public int size() {
         return this.list.size();
     }
 
     /**
      * @see java.util.List#subList(int, int)
      */
     public List<T> subList(final int fromIndex, final int toIndex) {
         return new ImmutableList<T>(this.list.subList(fromIndex, toIndex));
     }
 
     /**
      * @see java.util.List#toArray(T[])
      */
     public <K> K[] toArray(final K[] a) {
         return this.list.toArray(a);
     }
 
     /**
      * @see java.util.List#toArray()
      */
     public Object[] toArray() {
         return this.list.toArray();
     }
 
     /**
      * @see java.util.List#iterator()
      */
     public Iterator<T> iterator() {
         return new ImmutableIterator<T>(this.list.iterator());
     }
 
     /**
      * @see java.util.List#add(E)
      */
     public boolean add(final T o) {
         throw new UnsupportedOperationException("ImmutableList.add");
     }
 
     /**
      * @see java.util.List#remove(java.lang.Object)
      */
     public boolean remove(final Object o) {
         throw new UnsupportedOperationException("ImmutableList.remove");
     }
 
     /**
      * @see java.util.List#addAll(java.util.Collection)
      */
     public boolean addAll(final Collection<? extends T> c) {
         throw new UnsupportedOperationException("ImmutableList.addAll");
     }
 
     /**
      * @see java.util.List#addAll(int, java.util.Collection)
      */
     public boolean addAll(final int index, final Collection<? extends T> c) {
         throw new UnsupportedOperationException("ImmutableList.addAll");
     }
 
     /**
      * @see java.util.List#removeAll(java.util.Collection)
      */
     public boolean removeAll(final Collection<?> c) {
         throw new UnsupportedOperationException("ImmutableList.removeAll");
     }
 
     /**
      * @see java.util.List#retainAll(java.util.Collection)
      */
     public boolean retainAll(final Collection<?> c) {
         throw new UnsupportedOperationException("ImmutableList.retainAll");
     }
 
     /**
      * @see java.util.List#clear()
      */
     public void clear() {
         throw new UnsupportedOperationException("ImmutableList.clear");
     }
 
     /**
      * @see java.util.List#set(int, E)
      */
     public T set(final int index, final T element) {
         throw new UnsupportedOperationException("ImmutableList.set");
     }
 
     /**
      * @see java.util.List#add(int, E)
      */
     public void add(final int index, final T element) {
         throw new UnsupportedOperationException("ImmutableList.add");
     }
 
     /**
      * @see java.util.List#remove(int)
      */
     public T remove(final int index) {
         throw new UnsupportedOperationException("ImmutableList.remove");
     }
 
     /**
      * @see java.util.List#listIterator()
      */
     public ListIterator<T> listIterator() {
         return new ImmutableListIterator<T>(this.list.listIterator());
     }
 
     /**
      * @see java.util.List#listIterator(int)
      */
     public ListIterator<T> listIterator(final int index) {
         return new ImmutableListIterator<T>(this.list.listIterator(index));
     }
 
 }