/*

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.classscan.util;

 import java.lang.reflect.Array;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Iterator;

 import java.util.NoSuchElementException;

 import java.util.Set;

 /**

  * Set of immutable instances.

  * 

  * @param <V>

  *            The contained type

  */

 public class ReadOnlySet<V> implements Set<V> {

     protected V[] values;

     public ReadOnlySet(V[] values) {

         if(values==null) {

             throw new UnsupportedOperationException();

         }

         else {

             this.values = values;

         }

     }

     /**

      * Subclasses may use this constructor to delay initialization of values.

      * The derived class must call setValues before general use.

      */

     protected ReadOnlySet() {

     }

     /**

      * @param values

      *            The array to view

      */

     protected void setValues(V[] values) {

         this.values = values;

     }

     @Override

     public boolean contains(Object o) {

         for (V t : values) {

             if (t.equals(o)) {

                 return true;

             }

         }

         return false;

     }

     @Override

     public boolean containsAll(Collection<?> collection) {

         for (Object single : collection) {

             if (!contains(single)) {

                 return false;

             }

         }

         return true;

     }

     @Override

     public boolean isEmpty() {

         return values.length == 0;

     }

     @Override

     public Iterator<V> iterator() {

         return new Iterator<V>() {

             int i;

             @Override

             public boolean hasNext() {

                 return i < values.length;

             }

             @Override

             public V next() {

                 if (i == values.length) {

                     throw new NoSuchElementException("Reading past end of iterator");

                 }

                 return values[i++];

             }

             @Override

             public void remove() {

                 throw new UnsupportedOperationException("Read only iterator");

             }

         };

     }

     @Override

     public int size() {

         return values.length;

     }

     @Override

     public Object[] toArray() {

         return values.clone();

     }

     @Override

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

         int numberToNull = a.length - values.length;

         if (numberToNull >= 0) {

             System.arraycopy(values, 0, a, 0, values.length);

             if (numberToNull > 0) {

                 Arrays.fill(a, values.length, a.length, null);

             }

             return a;

         }

         @SuppressWarnings("unchecked")

         T[] rv = (T[]) Array.newInstance(a.getClass().getComponentType(), values.length);

         System.arraycopy(values, 0, rv, 0, values.length);

         return rv;

     }

     @Override

     final public boolean add(V e) {

         throw new UnsupportedOperationException("Set is readonly");

     }

     @Override

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

         throw new UnsupportedOperationException("Set is readonly");

     }

     @Override

     final public void clear() {

         throw new UnsupportedOperationException("Set is readonly");

     }

     @Override

     final public boolean remove(Object e) {

         throw new UnsupportedOperationException("Set is readonly");

     }

     @Override

     final public boolean removeAll(Collection<?> c) {

         throw new UnsupportedOperationException("Set is readonly");

     }

     @Override

     final public boolean retainAll(Collection<?> c) {

         throw new UnsupportedOperationException("Set is readonly");

     }

 }