CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2002 Command & Memento
	Previous    Lecture Notes Index    Next     © 2002, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 08-Apr-02

Doc 12, Command & Memento Slide # 2

Command

Structure

Invoker be a menu

Client be a word processing program

Receiver a document

Action be save

Doc 12, Command & Memento Slide # 3

When to Use the Command Pattern

• When you need an action as a parameter

Commands replace callback functions

• When you need to specify, queue, and execute requests at different times

• When you need to support undo

• When you need to support logging changes

• When you structure a system around high-level operations built on primitive operations

A Transactions encapsulates a set of changes to data

Systems that use transaction often can use the command pattern

• When you need to support a macro language

Doc 12, Command & Memento Slide # 4

Consequences

Doc 12, Command & Memento Slide # 5

abstract class Command
   {
   abstract public void execute();
   }
   
class OpenCommand extends Command
   {
   private Application opener;
   
   public OpenCommand( Application theOpener )
      {
      opener = theOpener;
      }
   
   public void execute()
      {
      String documentName = AskUserSomeHow();
      
      if ( name != null )
         {
         Document toOpen = 
               new Document( documentName );
         opener.add( toOpen );
         opener.open();
         }
      }
   }

Doc 12, Command & Memento Slide # 6

class Menu
   {
   private Hashtable menuActions = new Hashtable();
   
   public void addMenuItem( String displayString, 
                  Command itemAction )
      {
      menuActions.put( displayString, itemAction );
      }
   public void handleEvent( String itemSelected )
      {
      Command runMe;
      runMe = (Command) menuActions.get( itemSelected );
      runMe.execute();
      }
   // lots of stuff missing
   }

Doc 12, Command & Memento Slide # 7

class MacroCommand extends Command
   {
   private Vector commands = new Vector();
   
   public void add( Command toAdd )
      {
      commands.addElement( toAdd );
      }
   
   public void remove( Command toRemove )
      {
      commands.removeElement( toAdd );
      }
   
   public void execute()
      {
      Enumeration commandList = commands.elements();
      
      while ( commandList.hasMoreElements() )
         {
         Command nextCommand;
         nextCommand = (Command)
                      commandList.nextElement();
         nextCommand.execute();
         }
      }
   }

Doc 12, Command & Memento Slide # 8

Doc 12, Command & Memento Slide # 9

import java.util.*;
import java.lang.reflect.*;

public class Command
   {
   private Object receiver;
   private Method command;
   private Object[] arguments;
   
   public Command(Object receiver, Method command, 
                           Object[] arguments )
      {
      this.receiver = receiver;
      this.command = command;
      this.arguments = arguments;
      }
   public void execute() throws InvocationTargetException, 
                                 IllegalAccessException
      {
      command.invoke( receiver, arguments );
      }
   }
Doc 12, Command & Memento Slide # 10

public class Test {
   public static void main(String[] args) throws Exception 
      {
      Vector sample = new Vector();
      Class[] argumentTypes = { Object.class };
      Method add = 
         Vector.class.getMethod( "addElement", argumentTypes);
      Object[] arguments = { "cat" };
      
      Command test = new Command(sample, add, arguments );
      test.execute();
      System.out.println( sample.elementAt( 0));
      }
   }

Doc 12, Command & Memento Slide # 11

Object subclass: #PluggableCommand
   instanceVariableNames: 'receiver selector arguments '
   classVariableNames: ''
   poolDictionaries: ''
   category: 'Whitney-Examples'

receiver: anObject selector: aSymbol arguments: anArrayOrNil
   ^super new
      setReceiver: anObject 
      selector: aSymbol 
      arguments: anArrayOrNil

setReceiver: anObject selector: aSymbol arguments: anArrayOrNil
   receiver := anObject.
   selector := aSymbol.
   arguments := anArrayOrNil isNil
               ifTrue:[#( )]
               ifFalse: [anArrayOrNil]

execute
   ^receiver 
      perform: selector 
      withArguments: arguments

Doc 12, Command & Memento Slide # 12

| sample command |
sample := OrderedCollection new.
command := PluggableCommand
      receiver: sample
      selector: #add:
      arguments: #( 5 ).
command execute.
^sample at: 1

Doc 12, Command & Memento Slide # 13

Command Processor

• Contains all command objects

• Schedules the execution of commands

• May store the commands for later unto

• May log the sequence of commands for testing purposes

• Uses singleton to insure only one instance

Doc 12, Command & Memento Slide # 14

Structure

Doc 12, Command & Memento Slide # 15

Consequences

• Flexibility in the way requests are activated

Different user interface elements can generate the same kind of command object

Allows the user to configure commands performed by a user interface element

• Flexibility in the number and functionality of requests

Adding new commands and providing for a macro language comes easy

• Programming execution-related services

Commands can be stored for later replay

Commands can be logged

Commands can be rolled back

• Testability at application level

• Concurrency

Allows for the execution of commands in separate threads

Doc 12, Command & Memento Slide # 16

• Efficiency loss

• Potential for an excessive number of command classes

Try reducing the number of command classes by:

Grouping commands around abstractions

Unifying simple commands classes by passing the receiver object as a parameter

• Complexity

How do commands get additional parameters they need?

Doc 12, Command & Memento Slide # 17

Functor

• A single member function (method)

final class StudentNameComparator implements Comparator {
   
   public int compare( Object leftOp, Object rightOp ) {
      String leftName = ((Student) leftOp).name;
      String rightName = ((Student) rightOp).name;
      return leftName.compareTo( rightName );
   }
}

Doc 12, Command & Memento Slide # 18

• Using inheritance we can factor common code to a base class
• Same run-time flexibility as function pointer
• Lends it self to poor abstractions

Use functors when you would be tempted to use function pointers

Doc 12, Command & Memento Slide # 19

Memento

Structure

• Can access Memento’s get/set state methods

• Create Memento

Doc 12, Command & Memento Slide # 20

Applicability

• Need to save all or part of the state of an object and

• Do not wish to expose the saved state to the outside world

Doc 12, Command & Memento Slide # 21

package Examples;
class Memento
   {
   private Hashtable savedState = new Hashtable();
   
   protected Memento() {}; //Give some protection
   
   protected void setState( String stateName, Object stateValue )
      { 
      savedState.put( stateName, stateValue );
      } 
   protected Object getState( String stateName)
      {
      return savedState.get( stateName);
      } 
      
   protected Object getState(String stateName, Object defaultValue )
      {
      if ( savedState.containsKey( stateName ) )
         return savedState.get( stateName);
      else
         return defaultValue;
      } 
   }

Doc 12, Command & Memento Slide # 22

package Examples;
class ComplexObject
   {
   private String name;
   private int someData;
   private Vector objectAsState = new Vector();
   
   public Memento createMemento()
      {
      Memento currentState = new Memento();
      currentState.setState( "name", name );
      currentState.setState( "someData", new Integer(someData) );
      currentState.setState( "objectAsState", objectAsState.clone() );
      return currentState;
      }
   
   public void restoreState( Memento oldState)
      {
      name = (String) oldState.getState( "name", name );
      objectAsState = (Vector) oldState.getState( "objectAsState" );
      Integer data = (Integer) oldState.getState( "someData");
      someData = data.intValue();
      }

Doc 12, Command & Memento Slide # 23

   // Show a way to do incremental saves
   public Memento setName( String aName )
      {
      Memento deltaState = saveAState( "name", name);
      name = aName;
      return deltaState;
      }

   public void setSomeData( int value )
      {
      someData = value;
      }
   private Memento saveAState(String stateName, Object stateValue)
      {
      Memento currentState = new Memento();
      currentState.setState( stateName, stateValue );
      return currentState;
      }   
   }

Doc 12, Command & Memento Slide # 24

Consequences/ Implementation

How to store state history and for how long?

Doc 12, Command & Memento Slide # 25

Make Memento's interface private

Make Originator a friend of the Memento

   Class Memento {
   public:
      virtual ~Memento();
   private:
      friend class Originator;
      Memento();
      void setState(State*);
      State* GetState();
      ...

Doc 12, Command & Memento Slide # 26

Use private nested/inner class to hide memento's interface

class ComplexObject {
   private String name;
   private int someData;
   
   public Memento createMemento() {
      return new Memento();
   }
      
   public void  restoreState( Memento oldState) {
      oldState.restoreStateTo( this );
   }
   
   public class Memento {
      private String savedName;
      private int savedSomeData;
      
      private Memento() {
         savedName = name;
         savedSomeData = someData;
      }
      
      private void restoreStateTo(ComplexObject target) {
         target.name = savedName;
         target.someData = savedSomeData;
      }
   }
}

Doc 12, Command & Memento Slide # 27

interface Memento extends Cloneable { }

class ComplexObject implements Memento {
   private String name;
   private int someData;
   
   public Memento createMemento() {
      Memento myState = null;
      try {
         myState =  (Memento) this.clone();
      }
      catch (CloneNotSupportedException notReachable) {
      }
      return myState;
   }
      
   public void  restoreState( Memento savedState) {
      ComplexObject myNewState = (ComplexObject)savedState;
      name = myNewState.name;
      someData = myNewState.someData;
   }
}

Doc 12, Command & Memento Slide # 28

Iterators & Mementos

class IteratorState {
   int currentPosition = 0;
   
   protected IteratorState() {}
   
   protected int getPosition() {   return currentPosition;   }
   
   protected void advancePosition() { currentPosition++; }
   }
   
class Vector {
   protected Object elementData[];
   protected int elementCount;
   
   public IteratorState newIteration() { return new IteratorState(); }
   
   public boolean hasMoreElements(IteratorState aState) {
      return aState.getPosition() < elementCount;
   }
   
   public Object nextElement( IteratorState aState ) {
      if (hasMoreElements( aState ) ) {
         int currentPosition = aState.getPosition();
         aState.advancePosition();
         return elementData[currentPosition];
         }
   throw new NoSuchElementException("VectorIterator");
   }
   ...

Doc 12, Command & Memento Slide # 29

Previous    visitors since 08-Apr-02    Next