/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    * 
    * This library is distributed in the hope that it will be useful,
    * but 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.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.toolkit.util;
  
  import java.util.*;
  
  /*** Static help class that provides a number of tools for working with 
   * iterators such as making the unmodifiable or wraping arrays.
   *
   * @author  Dennis Zikovic
   * @version 1.00
   *
   *//*
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2002-08-23  Dennis Zikovic    Creation
   */
  public final class Iterators
  {
      // Constants ---------------------------------------------------------------
      public static ListIterator EMPTY_ITERATOR = new ArrayIterator(null);
      
      // Static help methods -----------------------------------------------------
      public static ListIterator unmodifiableIterator(ListIterator it)
      {
          return new UnmodifiableListIterator(it);
      }
      
      public static Iterator unmodifiableIterator(Iterator it)
      {
          return new UnmodifiableIterator(it);
      }
      
      public static Iterator iterate(Enumeration enum)
      {
          if(enum==null)
              return EMPTY_ITERATOR;
          else
              return new EnumerationIterator(enum);
      }
      
      public static ListIterator iterate(Object[] array)
      {
          return new ArrayIterator(array);
      }
      
      public static ListIterator iterate(Object obj)
      {
          return new ArrayIterator(new Object[] {obj});
      }
      
      public static ListIterator iterate(Object obj1, Object obj2)
      {
          return new ArrayIterator(new Object[] {obj1, obj2});
      }
      
      // Internal classes --------------------------------------------------------
      
      public static class EnumerationIterator implements Iterator, Enumeration
      {
          // Data members --------------------------------------------------------
          protected Enumeration mEnumeration;
  
          // Constructors --------------------------------------------------------
          public EnumerationIterator(Enumeration enum)
          {
              mEnumeration = enum;
          }
          
          // Iterator implementation ---------------------------------------------
          public boolean hasNext() 
          {
              return mEnumeration.hasMoreElements();
          }
  
          public Object next() 
          {
              return mEnumeration.nextElement();
          }
          
          public void remove()  
          {
             throw new java.lang.UnsupportedOperationException();
         }
 
         // Enumeration implementation ------------------------------------------
         public boolean hasMoreElements() 
         {
             return mEnumeration.hasMoreElements();
         }
 
         public Object nextElement() 
         {
             return mEnumeration.nextElement();
         }
     }
     
     public static class ArrayIterator implements ListIterator, Enumeration
     {
         // Data members --------------------------------------------------------
         protected Object[] mObjectArray;
         protected int mArrayIndex;
 
         // Constructors --------------------------------------------------------
         public ArrayIterator(Object[] objectArray) 
         {
             mObjectArray = objectArray;
             mArrayIndex = -1;
         }
 
         // ListIterator implementation -----------------------------------------
         public void add(Object o) 
         {
             throw new java.lang.UnsupportedOperationException();
         }
 
         public boolean hasNext() 
         {
             return mObjectArray!=null && mArrayIndex<mObjectArray.length-1;
         }
         
         public boolean hasPrevious() 
         {
             return mArrayIndex>0;
         }
 
         public Object next() 
         {
             return mObjectArray[++mArrayIndex];
         }
 
         public int nextIndex() 
         {
             return mArrayIndex+1;
         }
         
         public Object previous() 
         {
             return mObjectArray[--mArrayIndex];
         }
         
         public int previousIndex() 
         {
             return mArrayIndex-1;
         }
         
         public void remove() 
         {
             throw new java.lang.UnsupportedOperationException();
         }
 
         public void set(Object o)  
         {
             mObjectArray[mArrayIndex] = o;
         }
 
         // Enumeration implementation ------------------------------------------
         public boolean hasMoreElements() 
         {
             return this.hasNext();
         }
 
         public Object nextElement() 
         {
             return this.next();
         }
     }
     
     public static class UnmodifiableIterator implements Iterator, Enumeration
     {
         // Data members --------------------------------------------------------
         protected Iterator mIterator;
 
         // Constructors --------------------------------------------------------
         public UnmodifiableIterator(Iterator iterator) 
         {
             mIterator = iterator;
         }
 
         // Iterator implementation ---------------------------------------------
         public boolean hasNext() 
         {
             return mIterator.hasNext();
         }
         
         public Object next() 
         {
             return mIterator.next();
         }
 
         public void remove() 
         {
             throw new java.lang.UnsupportedOperationException();
         }
 
         // Enumeration implementation ------------------------------------------
         public boolean hasMoreElements() 
         {
             return this.hasNext();
         }
 
         public Object nextElement() 
         {
             return this.next();
         }
     }
     
     public static class UnmodifiableListIterator implements ListIterator, Enumeration
     {
         // Data members --------------------------------------------------------
         protected ListIterator mIterator;
 
         // Constructors --------------------------------------------------------
         public UnmodifiableListIterator(ListIterator iterator) 
         {
             mIterator = iterator;
         }
 
         // ListIterator implementation -----------------------------------------
         public void add(Object o) 
         {
             throw new java.lang.UnsupportedOperationException();
         }
 
         public boolean hasNext() 
         {
             return mIterator.hasNext();
         }
         
         public boolean hasPrevious() 
         {
             return mIterator.hasPrevious();
         }
 
         public Object next() 
         {
             return mIterator.next();
         }
 
         public int nextIndex() 
         {
             return mIterator.nextIndex();
         }
         
         public Object previous() 
         {
             return mIterator.previous();
         }
         
         public int previousIndex() 
         {
             return mIterator.previousIndex();
         }
         
         public void remove() 
         {
             throw new java.lang.UnsupportedOperationException();
         }
 
         public void set(Object o)  
         {
             throw new java.lang.UnsupportedOperationException();
         }
 
         // Enumeration implementation ------------------------------------------
         public boolean hasMoreElements() 
         {
             return this.hasNext();
         }
 
         public Object nextElement() 
         {
             return this.next();
         }
     }
     
     public abstract static class WrapIterator implements Iterator, Enumeration
     {
         // Data members --------------------------------------------------------
         protected Iterator mIterator;
 
         // Constructors --------------------------------------------------------
         public WrapIterator(Iterator iterator) 
         {
             mIterator = iterator;
         }
         
         // Iterator implementation ---------------------------------------------
         public boolean hasNext() 
         {
             return mIterator.hasNext();
         }
         
         public Object next() 
         {
             return mIterator.next();
         }
 
         public void remove() 
         {
             mIterator.remove();
         }
 
         // Enumeration implementation ------------------------------------------
         public boolean hasMoreElements() 
         {
             return this.hasNext();
         }
 
         public Object nextElement() 
         {
             return this.next();
         }
     }
     
     public abstract static class FilterIterator implements Iterator, Enumeration
     {
         // Data members --------------------------------------------------------
         protected Iterator mIterator;
         protected Object mNextObject;
 
         // Constructors --------------------------------------------------------
         public FilterIterator(Iterator iterator) 
         {
             mIterator = iterator;
             mNextObject = nextAccepted();
         }
 
         public FilterIterator(Collection collection) 
         {
             this(collection.iterator());
         }
         
         protected FilterIterator()
         {
         }
 
         // Iterator implementation ---------------------------------------------
         public boolean hasNext() 
         {
             return mNextObject!=null;
         }
         
         public Object next() 
         {
             Object currentObject = mNextObject;
             mNextObject = nextAccepted();
             return currentObject;
         }
 
         public void remove() 
         {
             throw new java.lang.UnsupportedOperationException();
         }
 
         // Enumeration implementation ------------------------------------------
         public boolean hasMoreElements() 
         {
             return this.hasNext();
         }
 
         public Object nextElement() 
         {
             return this.next();
         }
         
         // Abstract methods ----------------------------------------------------
         
         /*** Abstract method that should return true if the provided object 
          * should be included in the itteration.
          */
         protected abstract boolean accept(Object object);
         
         // Help methods --------------------------------------------------------
         protected Object nextAccepted()
         {
             if(!mIterator.hasNext())
                 return null;
             
             Object nextObject = mIterator.next();
             while(!this.accept(nextObject) && mIterator.hasNext())
                 nextObject = mIterator.next();
             return nextObject;
         }
     }
 }