Logo
Distributed Genetic Programming Framework
print print

File org.sfc.collections.ArrayCollection.java

Here you can find all the information about the file org.sfc.collections.ArrayCollection.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-05-19 14:35:06
 * Original Filename: org.sfc.collections.ArrayCollection.java
 * Version          : 1.0.0
 * Last modification: 2006-05-19
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */

 
package org.sfc.collections;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collection;

import org.sfc.utils.Typesafe;

/**
 * This class provides immutable collection interfaces for an array. 
 * @param <Type>  The item type.
 * @author Thomas Weise
 */

public class ArrayCollection<Type> extends     BasicList<Type>
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
  
/**
 * The internal array.
 */

  transient Type[]  m_array ;
/**
 * The count of items in the array.
 */

            int     m_count ;
  
  
/**
 * Create a new immutable array collection.
 * @param p_array The array data to mask.
 * @param p_count The count of items stored in the array.
 */

  public  ArrayCollection(final Type[] p_array,
                          final int    p_count)
    {
    super();
    this.m_array = p_array;
    this.m_count = p_count;
    }
  

 
/**
 * Create a new immutable array collection.
 * @param p_array The array data to mask.
 */

  public  ArrayCollection(final Type[] p_array)
    {
    this(p_array, p_array.length);
    }
  
/**
 * Create a new array collection by copying another collection.
 * @param p_collection    The collection to copy.
 * @param p_class         The class of the items.
 */

  public  ArrayCollection (final Collection<Type> p_collection,
                           final Class<Type>      p_class)
    {
    this(p_collection.toArray(Arrays.create(p_class, p_collection.size())));
    }
  

  
/**
 * Returns the number of elements in this list.  If this list contains
 * more than <tt>Integer.MAX_VALUE</tt> elements, returns
 * <tt>Integer.MAX_VALUE</tt>.
 *
 * @return the number of elements in this list.
 */

  @Override
  public  final int size()
    {
    return this.m_count;
    }

/**
 * Returns <tt>true</tt> if this list contains no elements.
 *
 * @return <tt>true</tt> if this list contains no elements.
 */

  @Override
  public  final boolean isEmpty()
    {
    return (this.m_count > 0);
    }
  
  
/**
 * Returns <tt>true</tt> if this list contains the specified element.
 * More formally, returns <tt>true</tt> if and only if this list contains
 * at least one element <tt>e</tt> such that
 * <tt>(p_o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;p_o.equals(e))</tt>.
 *
 * @param p_o element whose presence in this list is to be tested.
 * @return <tt>true</tt> if this list contains the specified element.
 * @throws ClassCastException if the type of the specified element
 *         is incompatible with this list (optional).
 * @throws NullPointerException if the specified element is null and this
 *         list does not support null elements (optional).
 */

  @Override
  public  final boolean contains(final Object p_o)
    {
    int     l_i;
    Type[]  l_a;
    Type    l_t;
    
    l_i = (this.m_count-1);
    l_a = this.m_array;
    
    if(p_o == null)
      {
      for(; l_i >= 0; l_i--)
        {
        if(l_a[l_i] == null) return true;
        }
      return false;
      }
    
    for(; l_i >= 0; l_i--)
      {
      l_t = l_a[l_i];
      if((l_t != null) && (l_t.equals(p_o)))
        {
        return true;
        }
      }
    
    return false;
    }



///**
// * does nothing
// *
// * @param p_o element to be appended to this list.
// * @return never
// * 
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final boolean add(final Type p_o)
//    {
//    throw new UnsupportedOperationException();
//    }
//
///**
// * does nothing
// *
// * @param p_o element to be removed from this list, if present.
// * @return never
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final boolean remove(final Object p_o)
//    {
//    throw new UnsupportedOperationException();
//    }
//
//
//
///** 
// * Returns <tt>true</tt> if this list contains all of the elements of the
// * specified collection.
// *
// * @param  p_c collection to be checked for containment in this list.
// * @return <tt>true</tt> if this list contains all of the elements of the
// *         specified collection.
// * @throws ClassCastException if the types of one or more elements
// *         in the specified collection are incompatible with this
// *         list (optional).
// * @throws NullPointerException if the specified collection contains one
// *         or more null elements and this list does not support null
// *         elements (optional).
// * @throws NullPointerException if the specified collection is
// *         <tt>null</tt>.
// * @see #contains(Object)
// */

//  @Override
//  public  final boolean containsAll(final Collection<?> p_c)
//    {    
//main:
//    for(Object l_p : p_c)
//      {
//      if(!(this.contains(l_p))) return false;
//      }
//    return true;
//    }
//
///**
// * does nothing
// * @param p_c collection whose elements are to be added to this list.
// * @return never
// * 
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final boolean addAll(Collection<? extends Type> p_c)
//    {
//    throw new UnsupportedOperationException();
//    }
//
///**
// * does nothing
// * @param p_index index at which to insert first element from the specified
// *              collection.
// * @param p_c elements to be inserted into this list.
// * @return never
// * 
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final boolean addAll(final  int                         p_index,
//                               final  Collection<? extends Type>  p_c)
//    {
//    throw new UnsupportedOperationException();
//    }
//
///**
// * does nothing
// * @param p_c collection that defines which elements will be removed from
// *          this list.
// * @return never
// * 
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final boolean removeAll(final Collection<?> p_c)
//    {
//    throw new UnsupportedOperationException();
//    }
//
///**
// * does nothing
// *
// * @param p_c collection that defines which elements this set will retain.
// * 
// * @return never
// * 
// * @throws UnsupportedOperationException always
// */

//
//  @Override
//  public  final boolean retainAll(final Collection<?> p_c)
//    {
//    throw new UnsupportedOperationException();
//    }
//
///**
// * does nothing
// *
// * @throws UnsupportedOperationException always
// */

//
//  @Override
//  public  final void clear()
//    {
//    throw new UnsupportedOperationException();
//    }


/**
 * Returns the element at the specified position in this list.
 *
 * @param p_index index of element to return.
 * @return the element at the specified position in this list.
 * 
 * @throws IndexOutOfBoundsException if the index is out of range (index
 *      &lt; 0 || index &gt;= size()).
 */

  @Override
  public  final Type get(final  int p_index)
    {
    return this.m_array[p_index];
    }

///**
// * does nothing
// * @param p_index index of element to replace.
// * @param p_element element to be stored at the specified position.
// * @return never
// * 
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final  Type set(final int   p_index,
//                          final Type  p_element)
//    {
//    throw new UnsupportedOperationException();
//    }
//
///**
// * does nothing
// * @param p_index index at which the specified element is to be inserted.
// * @param p_element element to be inserted.
// * 
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final void add(final  int   p_index,
//                         final  Type  p_element)
//    {
//    throw new UnsupportedOperationException();
//    }
//
///**
// * does nothing
// * @param p_index the index of the element to removed.
// * @return never
// * 
// * @throws UnsupportedOperationException always
// */

//  @Override
//  public  final Type remove(final int p_index)
//    {
//    throw new UnsupportedOperationException();
//    }


/**
 * Returns the index in this list of the first occurrence of the specified
 * element, or -1 if this list does not contain this element.
 * More formally, returns the lowest index <tt>i</tt> such that
 * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
 * or -1 if there is no such index.
 *
 * @param p_o element to search for.
 * @return the index in this list of the first occurrence of the specified
 *         element, or -1 if this list does not contain this element.
 * @throws ClassCastException if the type of the specified element
 *         is incompatible with this list (optional).
 * @throws NullPointerException if the specified element is null and this
 *         list does not support null elements (optional).
 */


  @Override
  public  final int indexOf(final Object p_o)
    {    
    int     l_i, l_j;
    Type[]  l_a;
    Type    l_t;
    
    l_i = this.m_count;
    l_a = this.m_array;
    
    if(p_o == null)
      {
      for(l_j = 0; l_j < l_i; l_j++)
        {
        if(l_a[l_j] == null) return l_j;
        }
      return -1;
      }
    
    for(l_j = 0; l_j < l_i; l_j++)
      {
      l_t = l_a[l_j];
      if((l_t != null) && (l_t.equals(p_o)))
        {
        return l_j;
        }
      }
    
    return -1;
    }

/**
 * Returns the index in this list of the last occurrence of the specified
 * element, or -1 if this list does not contain this element.
 * More formally, returns the highest index <tt>i</tt> such that
 * <tt>(p_o==null ? get(i)==null : o.equals(get(i)))</tt>,
 * or -1 if there is no such index.
 *
 * @param p_o element to search for.
 * @return the index in this list of the last occurrence of the specified
 *         element, or -1 if this list does not contain this element.
 * @throws ClassCastException if the type of the specified element
 *         is incompatible with this list (optional).
 * @throws NullPointerException if the specified element is null and this
 *         list does not support null elements (optional).
 */

  @Override
  public  final int lastIndexOf(final Object p_o)
    {
    
    int     l_i;
    Type[]  l_a;
    Type    l_t;
    
    l_i = (this.m_count-1);
    l_a = this.m_array;
    
    if(p_o == null)
      {
      for(; l_i >= 0; l_i--)
        {
        if(l_a[l_i] == null) return l_i;
        }
      return -1;
      }
    
    for(; l_i >= 0; l_i--)
      {
      l_t = l_a[l_i];
      if((l_t != null) && (l_t.equals(p_o)))
        {
        return l_i;
        }
      }
    
    return -1;
    }


/**
 * Creates and returns a copy of this object.  The precise meaning
 * of "copy" may depend on the class of the object.
 *
 * @return     A clone of this instance.
 *
 * @see java.lang.Cloneable
 */

  @Override
  public  Object  clone ()
    {
    return this;
    }
  
/**
 * Internally copies the array collection.
 * @return The internal copy.
 */

  final Object internal_clone ()
    {
    ArrayCollection<Type> l_o;
    
    
    l_o = Typesafe.cast(super.clone());    
    l_o.m_array = l_o.m_array.clone();
    
    return l_o;
    }
  
  
///**
// * Visit all elements in the collection.
// * @param p_visitor The visitor to be carried around.
// * @return  <code>true</code> if the visitor successfully visited all
// *          elements, <code>false</code> if it aborted its visit.
// */

//  public  boolean  visit (final IVisitor<Type> p_visitor)
//    {
//    int     l_i;
//    Type[]  l_a;
//    
//    l_a = this.m_array;
//    for(l_i = (this.m_count-1); l_i >= 0; l_i--)
//      {
//      if(!(p_visitor.visit(l_a[l_i]))) return false;
//      }
//    return true;
//    }
  
  

/**
 * Stores the <code>SfcEvent</code> into the stream.
 * @param p_s The output stream.
 * @throws  IOException If something io-like went wrong.
 */

  private final void writeObject(final ObjectOutputStream p_s)
        throws IOException
    {    
    Type[]  l_c;
    int     l_i;
    
    p_s.defaultWriteObject();
    
    l_i = this.m_count;
    l_c = this.m_array;
    p_s.writeObject(l_c.getClass().getComponentType());
    
    for(--l_i; l_i >= 0; l_i--)
      {
      p_s.writeObject(l_c[l_i]);
      }
    }
  


/**
 * Reconstitute the <code>SfcEvent</code> instance from a stream (that is,
 * deserialize it).
 * @param p_s The input stream.
 * @throws  IOException If something io-like went wrong.
 * @throws  ClassNotFoundException  If a needed class could not be found.
 */

  private final void readObject(final ObjectInputStream p_s)
        throws IOException, ClassNotFoundException
    {   
    Class<Type> l_t;
    Type[]      l_c;
    int         l_i;
    
    p_s.defaultReadObject();
    
    l_i = this.m_count;
    l_c = this.m_array;
    
    l_i = this.m_count;
    l_t = Typesafe.cast(p_s.readObject());
    l_c = Arrays.create(l_t, l_i);
    
    for(--l_i; l_i >= 0; l_i--)
      {
      l_c[l_i] = Typesafe.cast(p_s.readObject());
      }
    }
  }

File Information:

file name:ArrayCollection.java
package:org.sfc.collections
qualified name:org.sfc.collections.ArrayCollection.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/collections/ArrayCollection.java
size:14.244 KB (14586 B)
uploaded: 2015-07-22 04:11:11 GMT+0000
last update: 2006-06-09 06:44:39 GMT+0000
last access: 2018-01-20 18:34:30 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2018-01-20 18:34:30 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo