// Purpose.  Command design pattern - decoupling producer from consumer

import java.util.*;
public class CommandQueue {

interface Command { void execute(); }

static class DomesticEngineer implements Command {
   public void execute() {
      System.out.println( "take out the trash" );
}  }

static class Politician implements Command {
   public void execute() {
      System.out.println( "take money from the rich, take votes from the poor" );
}  }

static class Programmer implements Command {
   public void execute() {
      System.out.println( "sell the bugs, charge extra for the fixes" );
}  }

public static List produceRequests() {
   List queue = new ArrayList();
   queue.add( new DomesticEngineer() );
   queue.add( new Politician() );
   queue.add( new Programmer() );
   return queue;
}

public static void workOffRequests( List queue ) {
   for (Iterator it = queue.iterator(); it.hasNext(); )
      ((Command)it.next()).execute();
}

public static void main( String[] args ) {
   List queue = produceRequests();
   workOffRequests( queue );
}}

// take out the trash
// take money from the rich, take votes from the poor
// sell the bugs, charge extra for the fixes



// Purpose.  Java reflection and the Command design pattern
//
// Motivation.  "Sometimes it is necessary to issue requests to objects without
// knowing anything about the operation being requested or the receiver of the
// request."  The Command design pattern suggests encapsulating ("wrapping") in
// an object all (or some) of the following: an object, a method name, and some
// arguments.  Java does not support "pointers to methods", but its reflection
// capability will do nicely.  The "command" is a black box to the "client".
// All the client does is call "execute()" on the opaque object.

import java.lang.reflect.*;

public class CommandReflect {
   private int state;
   public CommandReflect( int in ) {
      state = in;
   }
   public int addOne( Integer one ) {
      return state + one.intValue();
   }
   public int addTwo( Integer one, Integer two ) {
      return state + one.intValue() + two.intValue();
   }

   static public class Command {
      private Object   receiver;               // the "encapsulated" object
      private Method   action;                 // the "pre-registered" request
      private Object[] args;                   // the "pre-registered" arg list
      public Command( Object obj, String methodName, Object[] arguments ) {
         receiver = obj;
         args = arguments;
         Class cls = obj.getClass();           // get the object's "Class"
         Class[] argTypes = new Class[args.length];
         for (int i=0; i < args.length; i++)   // get the "Class" for each
            argTypes[i] = args[i].getClass();  //    supplied argument
         // get the "Method" data structure with the correct name and signature
         try {      action = cls.getMethod( methodName, argTypes );      }
         catch( NoSuchMethodException e ) { System.out.println( e ); }
      }
      public Object execute() {
         // in C++, you do something like --- return receiver->action( args ); 
         try {     return action.invoke( receiver, args );     }
         catch( IllegalAccessException e    ) { System.out.println( e ); }
         catch( InvocationTargetException e ) { System.out.println( e ); }
         return null;
   }  }

   public static void main( String[] args ) {
      CommandReflect[] objs = { new CommandReflect(1), new CommandReflect(2) };
      System.out.print( "Normal call results: " );
      System.out.print( objs[0].addOne( new Integer(3) ) + " " );
      System.out.print( objs[1].addTwo( new Integer(4),
                                        new Integer(5) ) + " " );
      Command[] cmds = {
         new Command( objs[0], "addOne", new Integer[] { new Integer(3) } ),
         new Command( objs[1], "addTwo", new Integer[] { new Integer(4),
                                                         new Integer(5) } ) };
      System.out.print( "\nReflection results:  " );
      for (int i=0; i < cmds.length; i++)
          System.out.print( cmds[i].execute() + " " );
      System.out.println();
}  }

// Normal call results: 4 11     // 1 + 3 = 4     // 2 + 4 + 5 = 11
// Reflection results:  4 11