/*
    *  Copyright 1999-2004 The Apache Software Foundation
    *
    *  Licensed under the Apache License, Version 2.0 (the "License");
    *  you may not use this file except in compliance with the License.
    *  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   */
  package net.sf.collections15.iterators;
  
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  
  import net.sf.collections15.Predicate;
  
  /*** 
   * Decorates an <code>Iterator</code> such that only elements matching a
   * predicate filter are returned.
   *
   * @since Commons Collections 1.0
   * @version $Revision: 1.1 $ $Date: 2005/02/27 19:33:42 $
   * 
   * @author James Strachan
   * @author Jan Sorensen
   * @author Ralph Wagner
   * @author Stephen Colebourne
   * @author Mauro Franceschini (port to 5.0)
   */
  public class FilterIterator<E> implements Iterator<E> {
  
      // Instance fields
      // -------------------------------------------------------------------------
      
      /*** The iterator being used */
      private Iterator<E> iterator;
      
      /*** The predicate being used */
      private Predicate<E> predicate;
      
      /*** The next object in the iteration */
      private E nextObject;
      
      /*** Whether the next object has been calculated yet */
      private boolean nextObjectSet = false;
  
      // Constructors
      // -------------------------------------------------------------------------
      
      /***
       * Constructs a new <code>FilterIterator</code> that will not function
       * until {@link #setIterator(Iterator) setIterator} and
       * {@link #setPredicate(Predicate) setPredicate} are invoked.
       */
      public FilterIterator() {
          super();
      }
  
      /***
       * Constructs a new <code>FilterIterator</code> that will not function
       * until {@link #setPredicate(Predicate) setPredicate} is invoked.
       *
       * @param iterator the iterator to use
       */
      public FilterIterator(Iterator<E> iterator) {
          super();
          this.iterator = iterator;
      }
  
      /***
       * Constructs a new <code>FilterIterator</code> that will use the
       * given iterator and predicate.
       *
       * @param iterator the iterator to use
       * @param predicate the predicate to use
       */
      public FilterIterator(Iterator<E> iterator, Predicate<E> predicate) {
          super();
          this.iterator = iterator;
          this.predicate = predicate;
      }
  
      // Iterator interface methods
      // -------------------------------------------------------------------------
      
      /*** 
       * Returns <code>true</code> if the underlying iterator contains an object
       * that matches the predicate.
       *
       * @return <code>true</code> if there is another object that matches the
       *  predicate 
       */
      public boolean hasNext() {
         if (nextObjectSet) {
             return true;
         } else {
             return setNextObject();
         }
     }
 
     /*** 
      * Returns the next object that matches the predicate.
      * 
      * @return the next object which matches the given predicate
      * 
      * @throws NoSuchElementException if there are no more elements that match
      *  the predicate 
      */
     public E next() {
         if (!nextObjectSet) {
             if (!setNextObject()) {
                 throw new NoSuchElementException();
             }
         }
         nextObjectSet = false;
         return nextObject;
     }
 
     /***
      * Removes from the underlying collection of the base iterator the last
      * element returned by this iterator.
      * <p>
      * This method can only be called if <code>next()</code> was called, but not
      * after <code>hasNext()</code>, because the <code>hasNext()</code> call
      * changes the base iterator.
      * 
      * @throws IllegalStateException if <code>hasNext()</code> has already
      *  been called.
      */
     public void remove() {
         if (nextObjectSet) {
             throw new IllegalStateException("remove() cannot be called");
         }
         iterator.remove();
     }
 
     // Properties
     // -------------------------------------------------------------------------
     
     /*** 
      * Gets the iterator this iterator is using.
      * 
      * @return the iterator.
      */
     public Iterator<E> getIterator() {
         return iterator;
     }
 
     /*** 
      * Sets the iterator for this iterator to use.
      * <p>
      * If iteration has started, this effectively resets the iterator.
      * 
      * @param iterator the iterator to use
      */
     public void setIterator(Iterator<E> iterator) {
         this.iterator = iterator;
     }
 
     /*** 
      * Gets the predicate this iterator is using.
      * 
      * @return the predicate.
      */
     public Predicate<E> getPredicate() {
         return predicate;
     }
 
     /*** 
      * Sets the predicate this the iterator to use.
      * 
      * @param predicate the predicate to use
      */
     public void setPredicate(Predicate<E> predicate) {
         this.predicate = predicate;
     }
 
     // Private methods
     // -------------------------------------------------------------------------
     
     /***
      * Set nextObject to the next object.
      * 
      * @return <code>false</code> if there are no more objects and
      *  <code>true</code> otherwise
      */
     private boolean setNextObject() {
         while (iterator.hasNext()) {
             E object = iterator.next();
             if (predicate.evaluate(object)) {
                 nextObject = object;
                 nextObjectSet = true;
                 return true;
             }
         }
         return false;
     }
 }