Source code: com/aendvari/griffin/validation/ValidationHandler.java

   /*
    * ValidationHandler.java
    *
    * Copyright (c) 2001, 2002 Aendvari, Ltd. All Rights Reserved.
    *
    * See the file LICENSE for terms of use.
    *
    */
   
  package com.aendvari.griffin.validation;
  
  import java.util.*;
  import java.beans.*;
  
  import java.lang.reflect.*;
  import java.lang.NoSuchMethodException;
  import java.lang.IllegalAccessException;
  
  import com.aendvari.common.util.*;
  
  import com.aendvari.common.model.*;
  
  import com.aendvari.griffin.validation.*;
  import com.aendvari.griffin.validation.dataset.*;
  import com.aendvari.griffin.validation.validator.*;
  
  
  /**
   * <p>Defines a {@link ValidationHandler}.</p>
   *
   * <p>This class is used to examine a handler class for its methods.</p>
   *
   * <p>This class is used by the {@link Validation} class to execute validate/error methods.</p>
   *
   * @author  Scott Milne
   *
   */
  
  public class ValidationHandler
  {
    /* Variables */
  
    /** The name of the validation handler class. */
    private String name;
  
    /** The class of the validation handler class */
    private Object handlerObject;
  
    /** A {@link MultiHashMap} of the Method objects available in this handler. */
    private MultiHashMap methods;
  
  
    /* Constructors. */
  
  
    /**
     * Constructs an empty <code>ValidationHandler</code> instance.
     *
     * <p>This <b>does not</b> initialize the handler by default. All other constructors do.</p>
     *
     */
  
    public ValidationHandler()
    {
      name = "";
      handlerObject = null;
      methods = new MultiHashMap();
    }
  
    /**
     * Constructs a <code>ValidationHandler</code> instance.
     *
     * @param    setName            The name of the validation handler class.
     * @param    setHandler          The path to a class to be used for the handler.
     *
     */
  
    public ValidationHandler( String setName, String setHandler )
      throws Exception
    {
      name = setName;
      methods = new MultiHashMap();
  
      // lookup the class object by name
      Class handlerClass = null;
  
      try
      {
        handlerClass = Class.forName(setHandler);
      }
      catch(ClassNotFoundException exception)
      {
        throw new Exception("[ValidationHandler] ClassNotFound: " + setName + " class: " + setHandler + " : " + exception.getMessage());
      }
  
      // now create an instance of the class
      try
      {
        // create an instance of the given class
       handlerObject = handlerClass.newInstance();
     }
     /*
      * ClassNotFoundException
      * NoSuchMethodException
      * IllegalAccessException
      *
      */
     catch (Exception exception)
     {
       throw new Exception("[ValidationHandler] ClassNotInstantiated: " + setName + " class: " + setHandler + " : " + exception.getMessage());
     }
 
     // initialize this handler
     initializeHandler();
   }
 
   /**
    * Constructs a <code>ValidationHandler</code> instance.
    *
    * @param    setName            The name of the validation handler class.
    * @param    setHandlerClass        The {@link java.lang.Object java.lang.Object} to be used for the handler.
    *
    */
 
   public ValidationHandler( String setName, Object setHandlerObject )
     throws Exception
   {
     name = setName;
     handlerObject = setHandlerObject;
     methods = new MultiHashMap();
 
     // initialize this handler
     initializeHandler();
   }
 
   /**
    * Constructs a <code>ValidationHandler</code> instance.
    *
    * @param    setName            The name of the validation handler class.
    * @param    setHandlerClass        The {@link java.lang.Class java.lang.Class} to be used for the handler.
    *
    */
 
   public ValidationHandler( String setName, Class setHandlerClass )
     throws Exception
   {
     name = setName;
     methods = new MultiHashMap();
 
     // now create an instance of the class
     try
     {
       // create an instance of the given class
       handlerObject = setHandlerClass.newInstance();
     }
     /*
      * ClassNotFoundException
      * NoSuchMethodException
      * IllegalAccessException
      *
      */
     catch (Exception exception)
     {
       throw new Exception("[ValidationHandler] ClassNotInstantiated: " + setName + " class: " + setHandlerClass + " : " + exception.getMessage());
     }
 
     // initialize this handler
     initializeHandler();
   }
 
   /* Initialization */
 
   /**
    * Examines the handler class, extracting the methods from it and storing them for later access.
    *
    */
 
   public void initializeHandler()
     throws Exception
   {
     try
     {
       // transverse the bean
       BeanInfo beanInfo = Introspector.getBeanInfo( handlerObject.getClass() );
 
       // get all the properties of the bean
       MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors();
 
       // for each property, get the set/get methods if available
       int index=0;
       for (index=0; index<methodDescriptors.length; index++)
       {
         MethodDescriptor methodDescriptor = methodDescriptors[index];
         Method method = methodDescriptor.getMethod();
 
         // make sure a valid method is available
         if( method != null )
         {
           String methodName = method.getName();
           methods.put( methodName, method );
         }
       }
 
     }
     catch (Exception exception)
     {
       throw new Exception("[initializeHandler]: " + " class: " + handlerObject.getClass() + " : " + exception.getMessage());
     }
   }
 
 
   /* Accessors. */
 
   /**
    * Get the value of the validation class.
    *
    * @return                  A string representing the name of the validation handler class.
    *
    */
 
   public String getName()
   {
     return name;
   }
 
   /**
    * Set the value of the validation class.
    *
    * @param    setName            A string representing the name of the validation handler class.
    *
    */
 
   public void setName( String setName )
   {
     name = setName;
   }
 
   /**
    * Get the class of the validation class.
    *
    * @return                  A string representing the class of the validation handler class.
    *
    */
 
   public Object getHandlerObject()
   {
     return handlerObject;
   }
 
   /**
    * Set the class path of the validation class.
    *
    * @param    setHandlerObject        A string representing the class of the validation handler class.
    *
    */
 
   public void setHandlerObject( String setHandlerObject )
   {
     handlerObject = setHandlerObject;
   }
 
   /**
    * Executes this classes' part of a {@link Dataset} validation.
    *
    * @param    methodName          The name of the method to execute.
    * @param    parameters          A <code>Collection</code> of {@link MethodParameter} instances.
    * @param    handler            The {@link Handler} instance.
    * @param    property          A {@link Property} instance for the value to test.
    *
    * @return                  true/false if the validation succeeded.
    *
    * @throws                  Throws <code>Exception</code> if no method is found.
    *
    */
 
   public boolean executeMethod(
     String methodName,
     Collection parameters,
     Handler handler,
     Property property )
       throws Exception
   {
     Method method = null;
     Collection methodList = methods.getCollisionList(methodName);
 
     boolean methodFound = false;
     Iterator methodListIterator = methodList.iterator();
 
     while ( methodListIterator.hasNext() )
     {
       boolean allMatched = true;
 
       Method tempMethod = (Method)methodListIterator.next();
 
       // get the list of parameters for this method
       Class[] params = tempMethod.getParameterTypes();
 
       //
       // test against type and number of params
       //
       // throw Exception if nothing matches
       //
 
       // test the number of params
       if (parameters.size() == params.length)
       {
         // they match, so now verify their types by order
 
         // for each parameter
         int paramIndex = 0;
         Iterator paramIterator = parameters.iterator();
 
         while ( paramIterator.hasNext() )
         {
           MethodParameter param = (MethodParameter)paramIterator.next();
 
           String paramType = params[paramIndex].getName();
 
           // if the two types do not match, then break out
           if ( !paramType.equals(param.getType()) )
           {
             allMatched = false;
             break;
           }
 
           paramIndex++;
         }
       }
       else
       {
         allMatched = false;
       }
 
       // if everything matched, break out now to save time
       if (allMatched)
       {
         method = tempMethod;
         break;
       }
     }
 
     // if the method is still null at this point, it cannot be found, give up
     if (method == null)
     {
       throw new Exception("Invalid parameters were provided for method "+methodName+"\"");
     }
 
 
     // get the list of parameters for this method
     Class[] params = method.getParameterTypes();
 
     // create an argument array for holding the Objects for the parameters
     Object[] paramValues = new Object[params.length];
 
     // for each parameter
     int paramIndex = 0;
     Iterator paramIterator = parameters.iterator();
 
     while ( paramIterator.hasNext() )
     {
       MethodParameter param = (MethodParameter)paramIterator.next();
 
       Object setValue = null;
       String paramName = param.getName();
 
       ParameterDefine define = handler.getParameterDefine(paramName);
 
       // if not null, the user defined this param, so use that value
       if (define != null)
       {
         setValue = define.getValue();
       }
       // if the define is null, it means the user did not provide this parameter
       // so we'll use the default one instead
       else
       {
         setValue = param.getValue();
       }
 
       Class paramType = params[paramIndex];
 
       //
       // convert primitives into their object form using setValue as their value
       //
 
       if( paramType == int.class )
       {
         paramValues[paramIndex] = Integer.valueOf((String)setValue);
       }
       else if( paramType == byte.class )
       {
         paramValues[paramIndex] = Byte.valueOf((String)setValue);
       }
       else if( paramType == char.class )
       {
         paramValues[paramIndex] = new Character( ((Character)setValue).charValue());
       }
       else if( paramType == double.class )
       {
         paramValues[paramIndex] = Double.valueOf((String)setValue);
       }
       else if( paramType == float.class )
       {
         paramValues[paramIndex] = Float.valueOf((String)setValue);
       }
       else if( paramType == long.class )
       {
         paramValues[paramIndex] = Long.valueOf((String)setValue);
       }
       else if( paramType == short.class )
       {
         paramValues[paramIndex] = Short.valueOf((String)setValue);
       }
       else if( paramType == boolean.class )
       {
         paramValues[paramIndex] = Boolean.valueOf((String)setValue);
       }
       //
       // java.lang Objects
       //
       else if( Boolean.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = Boolean.valueOf((String)setValue);
       }
       else if( Byte.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = Byte.valueOf((String)setValue);
       }
       else if( Character.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = new Character( ((Character)setValue).charValue());
       }
       else if( Double.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = Double.valueOf((String)setValue);
       }
       else if( Float.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = Float.valueOf((String)setValue);
       }
       else if( Integer.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = Integer.valueOf((String)setValue);
       }
       else if( Long.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = Long.valueOf((String)setValue);
       }
       else if( Short.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = Short.valueOf((String)setValue);
       }
       else if( String.class.isAssignableFrom(paramType) )
       {
         paramValues[paramIndex] = setValue;
       }
       // everything else
       else
       {
         paramValues[paramIndex] = setValue;
       }
 
       paramIndex++;
     }
 
     // execute the method and get the return value from it
     Object responseObj = method.invoke( handlerObject, paramValues );
 
     // not sure if this is ok, but if the return type if null, then return true
     // the is usually from "void" error methods
     if ( responseObj == null )
     {
       return true;
     }
 
     // if the type returned is a boolean, get the value
     if ( responseObj.getClass() == Boolean.class )
     {
       return ((Boolean)responseObj).booleanValue();
     }
 
     // for now, otherwise fail
     return false;
   }
 
   /**
    * Determines if the given method is available in this handler
    *
    */
 
   public boolean isMethodAvailable( String methodName )
   {
     return methods.containsKey(methodName);
   }
 
   /**
    * Convert this object into a String representation.
    *
    */
 
   public String toString()
   {
     String data = "ValidationHandler [";
 
     data += "name=" + name + ", ";
     data += "handlerObject=" + handlerObject;
     data += "]";
 
     return data;
   }
 }