commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From germu...@apache.org
Subject cvs commit: jakarta-commons/chain/src/java/org/apache/commons/chain/generic DispatchCommand.java
Date Fri, 07 Jan 2005 21:10:30 GMT
germuska    2005/01/07 13:10:30

  Added:       chain/src/test/org/apache/commons/chain/generic
                        DispatchCommandTestCase.java
               chain/src/java/org/apache/commons/chain/generic
                        DispatchCommand.java
  Log:
  add DispatchCommand and test case
  
  Revision  Changes    Path
  1.1                  jakarta-commons/chain/src/test/org/apache/commons/chain/generic/DispatchCommandTestCase.java
  
  Index: DispatchCommandTestCase.java
  ===================================================================
  package org.apache.commons.chain.generic;
  
  import junit.framework.TestCase;
  import org.apache.commons.chain.Context;
  import org.apache.commons.chain.impl.ContextBase;
  
  /* JUnitTest case for class: org.apache.commons.chain.generic.DispatchCommand */
  public class DispatchCommandTestCase extends TestCase {
  
      public DispatchCommandTestCase(String _name) {
          super(_name);
      }
  
      /* setUp method for test case */
      protected void setUp() {
      }
  
      /* tearDown method for test case */
      protected void tearDown() {
      }
  
      /* Executes the test case */
      public static void main(String[] argv) {
          String[] testCaseList = {DispatchCommandTestCase.class.getName()};
          junit.textui.TestRunner.main(testCaseList);
      }
  
      public void testMethodDispatch() throws Exception {
          TestCommand test = new TestCommand();
  
          test.setMethod("testMethod");
          Context context = new ContextBase();
          assertNull(context.get("foo"));
          boolean result = test.execute(context);
          assertTrue(result);
          assertNotNull(context.get("foo"));
          assertEquals("foo", context.get("foo"));
  
  
      }
  
  
      public void testMethodKeyDispatch() throws Exception {
          TestCommand test = new TestCommand();
  
          test.setMethodKey("foo");
          Context context = new ContextBase();
          context.put("foo", "testMethodKey");
          assertNull(context.get("bar"));
          boolean result = test.execute(context);
          assertFalse(result);
          assertNotNull(context.get("bar"));
          assertEquals("bar", context.get("bar"));
  
  
      }
  
      public void testAlternateContext() throws Exception {
          TestAlternateContextCommand test = new TestAlternateContextCommand();
  
          test.setMethod("foo");
          Context context = new ContextBase();
          assertNull(context.get("elephant"));
          boolean result = test.execute(context);
          assertTrue(result);
          assertNotNull(context.get("elephant"));
          assertEquals("elephant", context.get("elephant"));
  
  
      }
  
      
      class TestCommand extends DispatchCommand {
          
  
          public boolean testMethod(Context context) {
              context.put("foo", "foo");
              return true;
          }
  
          public boolean testMethodKey(Context context) {
              
              context.put("bar", "bar");
              return false;
          }
  
      }
  
      /**
       * Command which uses alternate method signature.
       * <p>Title: Commons Chain</p>
       * <p>Description: An implmentation of the GoF Chain of Responsibility pattern</p>
       * <p>Copyright: Copyright (c) 2003-2004 The Apache Software Foundation - All
Rights Reserved.</p>
       * <p>Company: The Apache Software Foundation</p>
       * @author germuska
       * @version 0.2-dev
       */
      class TestAlternateContextCommand extends DispatchCommand {
  
  
          protected Class[] getSignature() {
              return new Class[] { TestAlternateContext.class };
          }
  
          protected Object[] getArguments(Context context) {
              return new Object[] { new TestAlternateContext(context) };
          }
  
          public boolean foo(TestAlternateContext context) {
              context.put("elephant", "elephant");
              return true;
          }
          
      }
  
  
      class TestAlternateContext extends java.util.HashMap implements Context {
          Context wrappedContext = null;
           TestAlternateContext(Context context) {
              this.wrappedContext = context;
          }
  
          public Object get(Object o) {
              return this.wrappedContext.get(o);
          }
  
          public Object put(Object key, Object value) {
              return this.wrappedContext.put(key, value);
          }
  
      }
  }
  
  
  1.1                  jakarta-commons/chain/src/java/org/apache/commons/chain/generic/DispatchCommand.java
  
  Index: DispatchCommand.java
  ===================================================================
  package org.apache.commons.chain.generic;
  
  import org.apache.commons.chain.Command;
  import org.apache.commons.chain.Context;
  import java.lang.reflect.Method;
  import java.util.WeakHashMap;
  import java.lang.reflect.InvocationTargetException;
  
  /**
   * An abstract base command which uses introspection to look up a method to execute.  
   * For use by developers who prefer to group related functionality into a single class
   * rather than an inheritance family.
   */
  public abstract class DispatchCommand implements Command {
  
      protected WeakHashMap methods = new WeakHashMap();
  
      protected String method = null;
  
      protected String methodKey = null;
  
      /**
       * The base implementation expects dispatch methods to take a <code>Context</code>
       * as their only argument.
       */
      protected static final Class[] DEFAULT_SIGNATURE = new Class[] { Context.class };
  
  
      /**
       * Look up the method specified by either "method" or "methodKey" and invoke it,
       * returning a boolean value as interpreted by <code>evaluateResult</code>.
       * @param context
       * @return
       * @throws Exception
       */
      public boolean execute(Context context) throws Exception {
  
          if (this.getMethod() == null && this.getMethodKey() == null) {
              throw new IllegalStateException("Neither 'method' nor 'methodKey' properties
are defined ");
          }
  
          Method methodObject = extractMethod(context);
  
          return evaluateResult(methodObject.invoke(this, getArguments(context)));
      }
  
      /**
       * Extract the dispatch method.  The base implementation uses the command's 
       * <code>method</code> property at the name of a method to look up, or,
if that is not defined,
       * 
       * and <code>methodKey</code>
       * @param context
       * @return
       * @throws NoSuchMethodException if no method can be found under the specified name.
       * @throws NullPointerException if no methodName can be determined
       */
      protected Method extractMethod(Context context) throws NoSuchMethodException {
  
          String methodName = this.getMethod();
  
          if (methodName == null) {
              Object methodContextObj = context.get(this.getMethodKey());
              if (methodContextObj == null) {
                  throw new NullPointerException("No value found in context under " + this.getMethodKey());
              }
              methodName = methodContextObj.toString();
          }
  
  
          Method theMethod = null;
  
          synchronized (methods) {
              theMethod = (Method) methods.get(methodName);
  
              if (theMethod == null) {
                  theMethod = getClass().getMethod(methodName, getSignature());
                  methods.put(methodName, theMethod);
              }
          }
  
          return theMethod;
      }
  
      /**
       * Evaluate the result of the method invocation as a boolean value.  Base implementation
       * expects that the invoked method returns boolean true/false, but subclasses might
       * implement other interpretations.
       * @param o
       * @return
       */
      protected boolean evaluateResult(Object o) {
          
          Boolean result = (Boolean) o;
          return (result != null && result.booleanValue());
          
      }
  
      /**
       * Return a <code>Class[]</code> describing the expected signature of the
method 
       * @return
       */
      protected Class[] getSignature() {
          return DEFAULT_SIGNATURE;
      }
      
      /**
       * Get the arguments to be passed into the dispatch method.  
       * Default implementation simply returns the context which was passed in, but subclasses
       * could use this to wrap the context in some other type, or extract key values from
the 
       * context to pass in.  The length and types of values returned by this must coordinate
       * with the return value of <code>getSignature()</code>
       * @param context
       * @return
       */
      protected Object[] getArguments(Context context) {
          return new Object[] { context };
      }
  
      public String getMethod() {
          return method;
      }
      public String getMethodKey() {
          return methodKey;
      }
      public void setMethod(String method) {
          this.method = method;
      }
      public void setMethodKey(String methodKey) {
          this.methodKey = methodKey;
      }
  
      
  
  }
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message