package net.sf.sapjcosupport;

 import org.apache.commons.lang.NotImplementedException;

 import org.apache.oro.text.regex.MalformedPatternException;

 import org.apache.oro.text.regex.Pattern;

 import org.apache.oro.text.regex.Perl5Compiler;

 import org.apache.oro.text.regex.Perl5Matcher;

 import org.apache.log4j.Logger;

 import org.springframework.core.NestedRuntimeException;

 import java.lang.reflect.Field;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.NoSuchElementException;

 /**

  * Iterator implementation that iterates through the fields declared in a class,

  * and retrieves the values for an instance.

  * <p/>

  * This implementation does not support item removal, and will throw a

  * <code>NotImplementedException</code> when the {@link #remove()} method is called.

  *

  * @author Jo Vandermeeren

  * @since 4 Jun, 2006 - 10:12:07 PM

  */

 public class ReflectionFieldIterator implements Iterator {

     private Object instance;

     private int counter;

     private Field[] fields;

     private Logger logger;

     /**

      * Simple constructor.

      *

      * @param instance instance to operate on

      * @see #ReflectionFieldIterator(Object, String)

      */

     public ReflectionFieldIterator(Object instance) {

         this(instance, null);

     }

     /**

      * Advanced constructor.

      * <p/>

      * This constructor accepts a regular expression by which the field names are evaluated.<br/>

      * Only fields with matching names will be considered; if the <code>regularExpression</code>

      * parameter is null or does not compile to a pattern, all fields will be considered.

      * <p/>

      * If the instance passed to this constructor is null, no exception will be thrown, but the

      * {@link #hasNext()} method will return <code>false</code>.

      *

      * @param instance          instance to operate on

      * @param regularExpression regular expression pattern to match field names

      */

     public ReflectionFieldIterator(Object instance, String regularExpression) {

         logger = Logger.getLogger(getClass());

         this.instance = instance;

         if (instance != null) {

             fields = instance.getClass().getFields();

             if (regularExpression != null) {

                 filterFieldNames(regularExpression);

             }

         } else {

             if (logger.isDebugEnabled()) {

                 logger.debug("The instance that was passed to the iterator is null.");

             }

             fields = null;

         }

     }

     private void filterFieldNames(String regularExpression) {

         if (fields == null) {

             return;

         }

         Pattern pattern;

         try {

             pattern = new Perl5Compiler().compile(regularExpression);

         } catch (MalformedPatternException e) {

             if (logger.isInfoEnabled()) {

                 logger.info("Regular expression did not compile to a pattern; all fields will be considered.", e);

             }

             return;

         }

         Perl5Matcher matcher = new Perl5Matcher();

         ArrayList filteredFieldList = new ArrayList(fields.length);

         for (int i = 0; i < fields.length; i++) {

             if (matcher.matches(fields[i].getName(), pattern)) {

                 filteredFieldList.add(fields[i]);

             }

         }

         fields = (Field[]) filteredFieldList.toArray(new Field[filteredFieldList.size()]);

     }

     /**

      * Checks if more fields are available to iterate through.

      *

      * @return true if more fields are available

      */

     public boolean hasNext() {

         if (fields == null) {

             return false;

         }

         return counter < fields.length;

     }

     /**

      * Retrieves the next available field value.

      *

      * @return next object in sequence

      * @throws NoSuchElementException if no more objects are available

      */

     public Object next() {

         if (!hasNext()) {

             throw new NoSuchElementException("No more elements available in iterator");

         }

         try {

             fields[++counter].setAccessible(true);

             return fields[counter].get(instance);

         } catch (IllegalAccessException e) {

             throw new IllegalAccessRuntimeException(e);

         }

     }

     /**

      * @deprecated Do not use this method, it is not implemented and throws a runtime exception

      */

     public void remove() {

         throw new NotImplementedException("This iterator implementation does not support item removal");

     }

     /**

      * RuntimeException wrapper for IllegalAccessException.

      */

     public class IllegalAccessRuntimeException extends RuntimeWrapperException {

         /**

          * Constructor.

          * <p/>

          * This method simply calls its parent with an <code>IllegalAccessException</code>

          * instance and an appropriate message.

          *

          * @param exception IllegalAccessException to wrap

          */

         public IllegalAccessRuntimeException(final IllegalAccessException exception) {

             super("Could not access field through reflection", exception);

         }

     }

     /**

      * Wraps any Throwable instance in a RuntimeException.

      */

     public class RuntimeWrapperException extends NestedRuntimeException {

         /**

          * Uses the message provided by the original throwable.

          *

          * @param throwable instance to wrap

          */

         public RuntimeWrapperException(Throwable throwable) {

             super(throwable.getMessage(), throwable);

         }

         /**

          * Uses a specified messaged to pass to the parent constructor.

          *

          * @param message   message to associate

          * @param throwable instance to wrap

          */

         public RuntimeWrapperException(String message, Throwable throwable) {

             super(message, throwable);

         }

     }

 }