Logo
Distributed Genetic Programming Framework
print print

File org.sfc.collections.BasicList.java

Here you can find all the information about the file org.sfc.collections.BasicList.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-22 10:26:01
 * Original Filename: org.sfc.collections.BasicList.java
 * Version          : 1.0.0
 * Last modification: 2006-05-22
 *                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.Serializable;
import java.util.AbstractList;
import java.util.Iterator;
import java.util.List;
import java.util.RandomAccess;
import java.util.Set;

import org.sfc.utils.ICloneable;


/**
 * The abstract base class for sfc lists.
 * 
 * @param <Type>  The item type.
 * 
 * @author Thomas Weise
 */

public  abstract  class BasicList<Type> extends     AbstractList<Type>
                                        implements  Set<Type>,
                                                    ICloneable,
                                                    Serializable,
                                                    RandomAccess,
                                                    IVisitable<Type>
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;

  
/**
 * Returns a view of the portion of this list between the specified
 * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive.  (If
 * <tt>fromIndex</tt> and <tt>toIndex</tt> are equal, the returned list is
 * empty.)  The returned list is backed by this list, so non-structural
 * changes in the returned list are reflected in this list, and vice-versa.
 * The returned list supports all of the optional list operations supported
 * by this list.<p>
 *
 * This method eliminates the need for explicit range operations (of
 * the sort that commonly exist for arrays).   Any operation that expects
 * a list can be used as a range operation by passing a subList view
 * instead of a whole list.  For example, the following idiom
 * removes a range of elements from a list:
 * <pre>
 *      list.subList(from, to).clear();
 * </pre>
 * Similar idioms may be constructed for <tt>indexOf</tt> and
 * <tt>lastIndexOf</tt>, and all of the algorithms in the
 * <tt>Collections</tt> class can be applied to a subList.<p>
 *
 * The semantics of the list returned by this method become undefined if
 * the backing list (i.e., this list) is <i>structurally modified</i> in
 * any way other than via the returned list.  (Structural modifications are
 * those that change the size of this list, or otherwise perturb it in such
 * a fashion that iterations in progress may yield incorrect results.)
 *
 * @param p_from_index low endpoint (inclusive) of the subList.
 * @param p_to_index high endpoint (exclusive) of the subList.
 * @return a view of the specified range within this list.
 * 
 * @throws IndexOutOfBoundsException for an illegal endpoint index value
 *     (fromIndex &lt; 0 || toIndex &gt; size || fromIndex &gt; toIndex).
 */

  @Override
  public  final List<Type> subList(final int p_from_index,
                                         int p_to_index)
    {    
    if((p_from_index < 0) || (p_to_index > this.size()) )
      {
      throw new IndexOutOfBoundsException();
      }
    
    return new SubList<Type>(this, p_from_index, p_to_index - p_from_index);
    }
  
  /**
 * Returns a list iterator of the elements in this list (in proper
 * sequence).
 *
 * @return a list iterator of the elements in this list (in proper
 *         sequence).
 */

  @Override
  public  final java.util.ListIterator<Type> listIterator()
    {
    return new org.sfc.collections.ListIterator<Type>(this, 0);
    }

/**
 * Returns a list iterator of the elements in this list (in proper
 * sequence), starting at the specified position in this list.  The
 * specified index indicates the first element that would be returned by
 * an initial call to the <tt>next</tt> method.  An initial call to
 * the <tt>previous</tt> method would return the element with the
 * specified index minus one.
 *
 * @param p_index index of first element to be returned from the
 *        list iterator (by a call to the <tt>next</tt> method).
 * @return a list iterator of the elements in this list (in proper
 *         sequence), starting 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 java.util.ListIterator<Type> listIterator(final int p_index)
    {
    if((p_index < 0) || (p_index >= this.size()))
      {
      throw new IndexOutOfBoundsException();
      }
    return new org.sfc.collections.ListIterator<Type>(this, p_index);
    }
  

/**
 * 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 ()
    {
    try
      {
      return super.clone();
      }
    catch(Throwable l_t)
      {
      return this;
      }
    }
  

  
/**
 * Returns an iterator over the elements in this list in proper
 * sequence. <p>
 *
 * This implementation returns a straightforward implementation of the
 * iterator interface, relying on the backing list's <tt>size()</tt>,
 * <tt>get(int)</tt>, and <tt>remove(int)</tt> methods.<p>
 *
 * Note that the iterator returned by this method will throw an
 * <tt>UnsupportedOperationException</tt> in response to its
 * <tt>remove</tt> method unless the list's <tt>remove(int)</tt> method is
 * overridden.<p>
 *
 * This implementation can be made to throw runtime exceptions in the face
 * of concurrent modification, as described in the specification for the
 * (protected) <tt>modCount</tt> field.
 *
 * @return an iterator over the elements in this list in proper sequence.
 * 
 * @see #modCount
 */

  @Override 
  public final  Iterator<Type> iterator()
    {
    return this.listIterator();
    }
  

/**
 * 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 ( IVisitor<Type> p_visitor)
    {
    int     l_i;
    
    for(l_i = (this.size()-1); l_i >= 0; l_i--)
      {
      if(!(p_visitor.visit(this.get(l_i)))) return false;
      }
    return true;
    }

  }

File Information:

file name:BasicList.java
package:org.sfc.collections
qualified name:org.sfc.collections.BasicList.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/collections/BasicList.java
size:7.183 KB (7356 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-06-09 06:18:57 GMT+0000
last access: 2018-04-23 23:13:49 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 2018-01-07 12:03:34 GMT+0000 served at 2018-04-23 23:13:49 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo