// Copyright (c) 2003, Chad Woolley, All rights reserved.
   
   package org.virtualmock.aspect;
   
   import java.util.Hashtable;
   import org.codehaus.aspectwerkz.regexp.ClassPattern;
   import org.codehaus.aspectwerkz.regexp.Pattern;
   import org.virtualmock.call.InvokedCall;
   import org.virtualmock.call.RecordedCall;
  import org.virtualmock.util.Toolbox;
  
  
  /***
   * This class consists of utility methods which have been abstracted out of the
   * Advice class.  This makes them easier to debug and unit test.  It also acts
   * as  an encapsulation layer between the advices and the rest of the class.
   * This is the only class which deals with  aspect-specific classes, such as
   * JoinPoints.
   *
   * @author Chad Woolley
   * @version $Revision: 1.15 $
   */
  public class AspectUtils {
      /***
       * Returns true if the specified class should be excluded from VirtualMock
       * processing.
       *
       * @param targetClass the class which will be checked to see if it should
       *        be excluded
       *
       * @return true if the specified class should be excluded
       *
       * @todo hardcoded to exclude VMTest class as an example
       */
      public boolean isClassExcluded(Class targetClass) {
          String targetClassName = targetClass.getName();
  
          String classExclusionPattern = "org.virtualmock.VMTest";
          ClassPattern classPattern =
              Pattern.compileClassPattern(classExclusionPattern);
          boolean isExcluded = classPattern.matches(targetClassName);
  
          return isExcluded;
      }
  
      /***
       * Log4j logger
       *
       * @param argumentValues DOCUMENT ME! (Constructor Parameter)
       *
       * @return DOCUMENT ME! (Method Return)
       */
  
      // Commented for Hansel
      // private static Logger logger =
      //    Logger.getLogger(AspectUtils.class.getName());
  
      /***
       * Create dummy argument names.
       *
       * @param argumentValues the argument values for which the dummy argument
       *        names will be created.
       *
       * @return an array of dummy argument names.
       */
      public String[] createArgumentNames(Object[] argumentValues) {
          // can't do the following line in aspectwerkz like you can in AspectJ,
          // because java throws away param names when compiling bytecode:
          //   String[] argumentNames = 
          //      methodJoinPoint.getMethod().getParameterNames();
          // instead, we just create names as arg0, arg1, etc.
          String[] argumentNames = new String[argumentValues.length];
  
          for (int j = 0; j < argumentValues.length; j++) {
              StringBuffer parameterName = new StringBuffer();
              parameterName.append("arg");
              parameterName.append(j);
              argumentNames[j] = parameterName.toString();
          }
  
          return argumentNames;
      }
  
      /***
       * Transform two arrays of matching argument types and argument values into
       * a hashtable of corresponding key/value pairs, with the argumentType as
       * the key.
       *
       * @param argumentTypes an array of argument types
       * @param argumentValues an array of argument values
       *
       * @return the argument types and values represented as a hashtable
       */
      public Hashtable hashArguments(Class[] argumentTypes,
          Object[] argumentValues) {
          Hashtable arguments = null;
  
          for (int i = 0; i < argumentValues.length; i++) {
              if (argumentValues[i] != null) {
                 if (arguments == null) {
                     arguments = new Hashtable();
                 }
 
                 arguments.put(argumentTypes[i], argumentValues[i]);
             }
         }
 
         return arguments;
     }
 
     /***
      * Performs the logic of playing back a recorded mock call.
      *
      * @param invokedCall the call that was invoked
      * @param recordedCall the recorded call that matches this invoked call
      *
      * @return the recorded mock return type (which may be null if one was not
      *         recorded)
      *
      * @throws Throwable the recorded mock exception (if one was recorded)
      */
     public Object playbackMockCall(InvokedCall invokedCall,
         RecordedCall recordedCall) throws Throwable {
         // indicate that this expected call was actually invoked by the
         // class under test.
         Toolbox.getCallManager().indicateCalled(invokedCall);
 
         // get the recorded mock exception (if specified)
         Throwable throwable = recordedCall.getThrowable();
 
         // throw the exception, if one was recorded
         if (throwable != null) {
             // DEBUG: disabled for Hansel
             // if (logger.isDebugEnabled()) {
             //     logger.debug("THROWING MOCK EXCEPTION: " + throwable);
             // }
             throw throwable;
         }
 
         // get the recorded mock return value (if specified)
         Object returnValue = recordedCall.getReturnValue();
 
         // return the value, if one was recorded
         if (returnValue != null) {
             // DEBUG: disabled for Hansel
             // if (logger.isDebugEnabled()) {
             //    logger.debug("RETURNING MOCK VALUE: " + returnValue);
             // }
             return returnValue;
         }
 
         // DEBUG: disabled for Hansel
         //        if (logger.isDebugEnabled()) {
         //            logger.debug("RETURNING MOCK NULL VALUE");
         //            logger.debug("exiting playbackMockCall method");
         //        }
         // return null if there is no exception to throw or value to return
         return null;
     }
 }