Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.commons.util;
  
  
 import java.util.List;
 import java.util.Set;


A lightweight, read-only copy of a List. Typically used in place of the common idiom: return Collections.unmodifiableList(new ArrayList( myInternalList ));

a it is far more efficient than making a defensive copy and then wrapping the defensive copy in a read-only wrapper.

Also used whenever a read-only reference List is needed.

Author(s):
Manik Surtani (manik@jboss.org)
Since:
4.0
 
 public class ImmutableListCopy<E> extends AbstractList<E> implements ExternalizableImmutables.Immutable {
    private static final long serialVersionUID = 10929568968966L;
    private E[] elements;

   
Constructs a new ImmutableListCopy. Required by Serialization.
 
    public ImmutableListCopy() {
    }

   
Only one copy constructor since the list is immutable.

Parameters:
c collection to copy from
 
    @SuppressWarnings("unchecked")
    public ImmutableListCopy(Collection<? extends E> c) {
       int size = c.size();
       Object[] el = new Object[size]; // no room for growth;
       el = c.toArray(el);
        = (E[]) el;
    }

   
Assumes that the array passed in is "safe", i.e., is not referenced from elsewhere. Use with care!

Parameters:
array to reference
 
    public ImmutableListCopy(E[] array) {
        = array;
    }

   
Utility constructors to allow combining collections

Parameters:
collection1 collection to copy from
collection2 collection to copy from
 
    @SuppressWarnings("unchecked")
    public ImmutableListCopy(Collection<? extends E> collection1Collection<? extends E> collection2) {
       int size = collection1.size() + collection2.size();
        = (E[]) new Object[size]; // no room for growth;
       Object[] c1 = new Object[collection1.size()];
       Object[] c2 = new Object[collection2.size()];
       c1 = collection1.toArray(c1);
       c2 = collection2.toArray(c2);
       System.arraycopy(c1, 0, , 0, c1.length);
       System.arraycopy(c2, 0, c1.lengthc2.length);
    }
 
    @Override
    public final int size() {
       return .;
    }
 
    @Override
    public final boolean isEmpty() {
       return . == 0;
    }
 
    @Override
    public final boolean contains(Object o) {
       return indexOf(o) >= 0;
    }
   public final Iterator<E> iterator() {
      return new ImmutableIterator();
   }
   public final Object[] toArray() {
      int size = .;
      Object[] result = new Object[size];
      System.arraycopy(, 0, result, 0, size);
      return result;
   }
   @SuppressWarnings("unchecked")
   public final <T> T[] toArray(T[] a) {
      int size = .;
      if (a.length < size) {
         a = (T[]) Array.newInstance(a.getClass().getComponentType(), size);
      }
      System.arraycopy(, 0, a, 0, size);
      if (a.length > sizea[size] = null;
      return a;
   }
   public final boolean add(E o) {
      throw new UnsupportedOperationException();
   }
   public final boolean remove(Object o) {
      throw new UnsupportedOperationException();
   }
   public final boolean addAll(Collection<? extends E> c) {
      throw new UnsupportedOperationException();
   }
   public final boolean addAll(int indexCollection<? extends E> c) {
      throw new UnsupportedOperationException();
   }
   public final boolean removeAll(Collection<?> c) {
      throw new UnsupportedOperationException();
   }
   public final boolean retainAll(Collection<?> c) {
      throw new UnsupportedOperationException();
   }
   public final E get(int index) {
      return [index];
   }
   public final int indexOf(Object o) {
      int size = .;
      if (o == null) {
         for (int i = 0; i < sizei++) {
            if ([i] == nullreturn i;
         }
      } else {
         for (int i = 0; i < sizei++) {
            if (o.equals([i])) return i;
         }
      }
      return -1;
   }
   public final int lastIndexOf(Object o) {
      int size = .;
      if (o == null) {
         for (int i = size - 1; i >= 0; i--) {
            if ([i] == nullreturn i;
         }
      } else {
         for (int i = size - 1; i >= 0; i--) {
            if (o.equals([i])) return i;
         }
      }
      return -1;
   }
   public final ListIterator<E> listIterator() {
      return new ImmutableIterator();
   }
   public final ListIterator<E> listIterator(int index) {
      return new ImmutableIterator(index);
   }
   public final List<E> subList(int fromIndexint toIndex) {
      return new ImmutableSubList<E>(fromIndextoIndex);
   }
   public boolean equals(Object o) {
      if (this == o)
         return true;
      if (!(o instanceof ImmutableListCopy))
         return super.equals(o);
      ImmutableListCopy<?> that = (ImmutableListCopy<?>) o;
      return Arrays.equals(that.elements);
   }
   public int hashCode() {
      int result = super.hashCode();
      result = 31 * result + Arrays.hashCode();
      return result;
   }

   
Format: - entry array size (int) - elements (Object)

Parameters:
out stream to write to
Throws:
java.io.IOException
   public void writeExternal(ObjectOutput outthrows IOException {
      out.writeInt(.);
      for (E e : out.writeObject(e);
   }

   
See writeExternal(java.io.ObjectOutput) for serialization format

   @SuppressWarnings("unchecked")
   public void readExternal(ObjectInput inthrows IOExceptionClassNotFoundException {
      int size = in.readInt();
       = (E[]) new Object[size];
      for (int i = 0; i < sizei++) [i] = (E) in.readObject();
   }
   private class ImmutableIterator implements ListIterator<E> {
      int cursor = 0;
      ImmutableIterator(int index) {
         if (index < 0 || index > size()) throw new IndexOutOfBoundsException("Index: " + index);
          = index;
      }
      ImmutableIterator() {
      }
      @Override
      public boolean hasNext() {
         return  != .;
      }
      @Override
      public E next() {
         try {
            return get(++);
         }
         catch (IndexOutOfBoundsException e) {
            throw new NoSuchElementException();
         }
      }
      @Override
      public void remove() {
         throw new UnsupportedOperationException();
      }
      @Override
      public boolean hasPrevious() {
         return  != 0;
      }
      @Override
      public E previous() {
         try {
            return get(--);
         }
         catch (IndexOutOfBoundsException e) {
            throw new NoSuchElementException();
         }
      }
      @Override
      public int nextIndex() {
         return ;
      }
      @Override
      public int previousIndex() {
         return  - 1;
      }
      @Override
      public void set(E o) {
         throw new UnsupportedOperationException();
      }
      @Override
      public void add(E o) {
         throw new UnsupportedOperationException();
      }
   }
   private class ImmutableSubList<E> extends AbstractList<E> {
      private int offset;
      private int size;
      ImmutableSubList(int fromIndexint toIndex) {
         int size = ImmutableListCopy.this..length;
         if (fromIndex < 0 || toIndex > size || fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex + "), toIndex(" + toIndex + "), size (" + size + "), List=" + ImmutableListCopy.this.toString());
          = fromIndex;
         this. = toIndex - fromIndex;
      }
      @Override
      @SuppressWarnings("unchecked")
      public final E get(int index) {
         if (index < 0 || index >= throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + );
         return (E) ImmutableListCopy.this.get(index + );
      }
      @Override
      public final int size() {
         return ;
      }
      @Override
      protected final void removeRange(int fromIndexint toIndex) {
         throw new UnsupportedOperationException();
      }
      @Override
      public final boolean addAll(Collection<? extends E> c) {
         throw new UnsupportedOperationException();
      }
      @Override
      public final boolean addAll(int indexCollection<? extends E> c) {
         throw new UnsupportedOperationException();
      }
      @Override
      public final Iterator<E> iterator() {
         return super.listIterator();
      }
      @Override
      public final ListIterator<E> listIterator(final int index) {
         if (index < 0 || (index != 0 && index >= ))
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + );
         return new ListIterator<E>() {
            private ListIterator<?> i = ImmutableListCopy.this.listIterator(index + );
            @Override
            public boolean hasNext() {
               return nextIndex() < ;
            }
            @Override
            @SuppressWarnings("unchecked")
            public E next() {
               if (hasNext())
                  return (E) .next();
               else
                  throw new NoSuchElementException();
            }
            @Override
            public boolean hasPrevious() {
               return previousIndex() >= 0;
            }
            @Override
            @SuppressWarnings("unchecked")
            public E previous() {
               if (hasPrevious())
                  return (E) .previous();
               else
                  throw new NoSuchElementException();
            }
            @Override
            public int nextIndex() {
               return .nextIndex() - ;
            }
            @Override
            public int previousIndex() {
               return .previousIndex() - ;
            }
            @Override
            public void remove() {
               throw new UnsupportedOperationException();
            }
            @Override
            public void set(E o) {
               throw new UnsupportedOperationException();
            }
            @Override
            public void add(E o) {
               throw new UnsupportedOperationException();
            }
         };
      }
      @Override
      public final List<E> subList(int fromIndexint toIndex) {
         return new ImmutableSubList<E>( + fromIndex + toIndex);
      }
   }
   public static class Externalizer extends AbstractExternalizer<List> {
      @Override
      public void writeObject(ObjectOutput outputList listthrows IOException {
         int size = list.size();
         UnsignedNumeric.writeUnsignedInt(outputsize);
         for (int i = 0; i < sizei++) {
            output.writeObject(list.get(i));
         }
      }
      @Override
      public List readObject(ObjectInput inputthrows IOExceptionClassNotFoundException {
         int size = UnsignedNumeric.readUnsignedInt(input);
         Object[] elements = new Object[size];
         for (int i = 0; i < sizei++)
            elements[i] = input.readObject();
         return new ImmutableListCopy(elements);
      }
      @Override
      public Integer getId() {
         return .;
      }
      @Override
      public Set<Class<? extends List>> getTypeClasses() {
         return Util.<Class<? extends List>>asSet(ImmutableListCopy.classImmutableListCopy.ImmutableSubList.class);
      }
   }
New to GrepCode? Check out our FAQ X