Logo
Distributed Genetic Programming Framework
print print

File org.sfc.collections.ListIterator.java

Here you can find all the information about the file org.sfc.collections.ListIterator.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 09:17:46
 * Original Filename: org.sfc.collections.ListIterator.java
 * Version          : 1.0.1
 * Last modification: 2006-06-12
 *                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.util.List;
import java.util.NoSuchElementException;


/**
 * A list iterator prototype.
 * 
 * @param <ItemType>  The element type.
 *
 * @author Thomas Weise
 */

public final  class ListIterator<ItemType>
       extends    IteratorBase<ItemType>
       implements java.util.ListIterator<ItemType>
  {
/**
 * The list backing this iterator.
 */

  private final List<ItemType>  m_list  ;
/**
 * The current iteration index.
 */

  private       int         m_index ;
  
/**
 * Create a new list iterator.
 * @param p_list  The list to work on.
 * @param p_index The index to start at.
 */

  public  ListIterator(final List<ItemType> p_list,
                       final int        p_index)
    {
    super();
    this.m_list  = p_list;
    this.m_index = p_index;
    }
  
/**
 * Returns <tt>true</tt> if this list iterator has more elements when
 * traversing the list in the forward direction. (In other words, returns
 * <tt>true</tt> if <tt>next</tt> would return an element rather than
 * throwing an exception.)
 *
 * @return <tt>true</tt> if the list iterator has more elements when
 *    traversing the list in the forward direction.
 */

  public  final boolean hasNext()
    {
    return (this.m_list.size() > this.m_index);
    }

/**
 * Returns the next element in the list.  This method may be called
 * repeatedly to iterate through the list, or intermixed with calls to
 * <tt>previous</tt> to go back and forth.  (Note that alternating calls
 * to <tt>next</tt> and <tt>previous</tt> will return the same element
 * repeatedly.)
 *
 * @return the next element in the list.
 * @exception NoSuchElementException if the iteration has no next element.
 */

  public  final ItemType next()
    {
    int            l_c;
    List<ItemType> l_l;
    
    l_c = this.m_index;
    l_l = this.m_list;
    if(l_c >= l_l.size()) throw new NoSuchElementException();
    this.m_index = (l_c+1);
    return l_l.get(l_c);
    }

/**
 * Returns <tt>true</tt> if this list iterator has more elements when
 * traversing the list in the reverse direction.  (In other words, returns
 * <tt>true</tt> if <tt>previous</tt> would return an element rather than
 * throwing an exception.)
 *
 * @return <tt>true</tt> if the list iterator has more elements when
 *         traversing the list in the reverse direction.
 */

  public  final boolean hasPrevious()
    {
    return (this.m_index > 0);
    }

/**
 * Returns the previous element in the list.  This method may be called
 * repeatedly to iterate through the list backwards, or intermixed with
 * calls to <tt>next</tt> to go back and forth.  (Note that alternating
 * calls to <tt>next</tt> and <tt>previous</tt> will return the same
 * element repeatedly.)
 *
 * @return the previous element in the list.
 * 
 * @exception NoSuchElementException if the iteration has no previous
 *            element.
 */

  public  final ItemType previous()
    {    
    int        l_c;
    List<ItemType> l_l;
    
    l_c = (this.m_index-1);
    if(l_c < 0) throw new NoSuchElementException();
    l_l = this.m_list;    
    this.m_index = l_c;
    return l_l.get(l_c);
    }

/**
 * Returns the index of the element that would be returned by a subsequent
 * call to <tt>next</tt>. (Returns list size if the list iterator is at the
 * end of the list.)
 *
 * @return the index of the element that would be returned by a subsequent
 *         call to <tt>next</tt>, or list size if list iterator is at end
 *         of list. 
 */

  public  final int nextIndex()
    {
    return this.m_index;
    }

/**
 * Returns the index of the element that would be returned by a subsequent
 * call to <tt>previous</tt>. (Returns -1 if the list iterator is at the
 * beginning of the list.)
 *
 * @return the index of the element that would be returned by a subsequent
 *         call to <tt>previous</tt>, or -1 if list iterator is at
 *         beginning of list.
 */
 
  public  final int previousIndex()
    {
    return (this.m_index-1);
    }


    // Modification Operations
    
/**
 * Removes from the list the last element that was returned by
 * <tt>next</tt> or <tt>previous</tt> (optional operation).  This call can
 * only be made once per call to <tt>next</tt> or <tt>previous</tt>.  It
 * can be made only if <tt>ListIterator.add</tt> has not been called after
 * the last call to <tt>next</tt> or <tt>previous</tt>.
 *
 * @exception UnsupportedOperationException if the <tt>remove</tt>
 *      operation is not supported by this list iterator.
 * @exception IllegalStateException neither <tt>next</tt> nor
 *      <tt>previous</tt> have been called, or <tt>remove</tt> or
 *      <tt>add</tt> have been called after the last call to *
 *      <tt>next</tt> or <tt>previous</tt>.
 */

  @Override
  public  final void remove()
    {
    this.m_list.remove(this.m_index--);
    }

/**
 * Replaces the last element returned by <tt>next</tt> or
 * <tt>previous</tt> with the specified element (optional operation).
 * This call can be made only if neither <tt>ListIterator.remove</tt> nor
 * <tt>ListIterator.add</tt> have been called after the last call to
 * <tt>next</tt> or <tt>previous</tt>.
 *
 * @param p_o the element with which to replace the last element returned by
 *          <tt>next</tt> or <tt>previous</tt>.
 * @exception UnsupportedOperationException if the <tt>set</tt> operation
 *      is not supported by this list iterator.
 * @exception ClassCastException if the class of the specified element
 *      prevents it from being added to this list.
 * @exception IllegalArgumentException if some aspect of the specified
 *      element prevents it from being added to this list.
 * @exception IllegalStateException if neither <tt>next</tt> nor
 *            <tt>previous</tt> have been called, or <tt>remove</tt> or
 *      <tt>add</tt> have been called after the last call to
 *      <tt>next</tt> or <tt>previous</tt>.
 */

  public  final void set(final ItemType p_o)
    {
    this.m_list.set(this.m_index, p_o);
    }

/**
 * Inserts the specified element into the list (optional operation).  The
 * element is inserted immediately before the next element that would be
 * returned by <tt>next</tt>, if any, and after the next element that
 * would be returned by <tt>previous</tt>, if any.  (If the list contains
 * no elements, the new element becomes the sole element on the list.)
 * The new element is inserted before the implicit cursor: a subsequent
 * call to <tt>next</tt> would be unaffected, and a subsequent call to
 * <tt>previous</tt> would return the new element.  (This call increases
 * by one the value that would be returned by a call to <tt>nextIndex</tt>
 * or <tt>previousIndex</tt>.)
 *
 * @param p_o the element to insert.
 * @exception UnsupportedOperationException if the <tt>add</tt> method is
 *      not supported by this list iterator.
 * 
 * @exception ClassCastException if the class of the specified element
 *      prevents it from being added to this list.
 * 
 * @exception IllegalArgumentException if some aspect of this element
 *            prevents it from being added to this list.
 */

  public  final void add(final ItemType p_o)
    {
    this.m_list.add(this.m_index++, p_o);
    }
  }

File Information:

file name:ListIterator.java
package:org.sfc.collections
qualified name:org.sfc.collections.ListIterator.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/collections/ListIterator.java
size:8.362 KB (8563 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-06-14 08:42:46 GMT+0000
last access: 2018-04-26 04:09:24 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-26 04:09:24 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo