CSC/ECE 517 Fall 2007/wiki1b 7 as

From Expertiza_Wiki
Jump to navigation Jump to search

Command Patterns

Definition : Command Pattern is a Design Pattern that encapsulates invocation and allows code that causes actions to be initiated to be separated from code that performs those actions.

Why use Command Patterns?

A Command pattern is an object behavioral pattern that allows us to achieve complete decoupling between the sender and the receiver. (A sender is an object that invokes an operation, and a receiver is an object that receives the request to execute a certain operation. With decoupling, the sender has no knowledge of the Receiver's request.) The term request here refers to the command that is to be executed. The Command pattern also allows us to vary when and how a request is fulfilled. Therefore, a Command pattern provides us flexibility as well as extensibility.


Use of Command Patterns

  • Decouple the object that invokes the operation from the one that performs the action described earlier.
  • Assemble commands into a composite command.
  • Add new Commands, without having to change existing classes.


Implementation of Command Patterns in Java Vs Ruby

Both Java and Ruby are object oriented programming languages in which command pattern can be implemented by turning the request itself into an object. This object can be stored and passed around like other objects. The Receiver has the knowledge required to carry out the request. In Java the implementation is through interfaces and in Ruby the implementation is through mixins. The difference in implementation of command patterns in Java and Ruby are brought out using a simple example that undos the concatenation operation on strings. Because of concepts such as meta-programming, modules, mixins many of the design patterns have much simpler, cleaner implementations in Ruby.

To illustrate the concept of command pattern we have attempted to implement do-undo concept in both Java and Ruby as follows. This concept is very useful in real life, not just in text editing but also for very complicated classes in which the implementation needs to be decoupled from the invocation. We have have brought out the concept of command patterns using string concatenation. Every time the object calls the concatenation function, we push the current operation on the object into a stack and then allow it to be modified. On the invocation of undo method, the stack is popped and operation is done in a reverse manner thus accomplishing the undo action.

Implementation in Java

The key to implementing command patterns in Java are interfaces, which declare the executing operations. In its simplest form, this interface includes an abstract execute operation. Each concrete Command class specifies a receiver-action pair by storing the Receiver as an instance variable. It provides different implementations of the execute() method to invoke the request.

Example Code 

import java.util.ArrayList;

/*
 * Basic interface for do-undo command pattern. 
 */
interface CommandPattern {
	void doCommand();
	void undoCommand();
}

/*
 * this NewString implements CommandPattern
 */
class NewString implements CommandPattern {
	// Stores the result of the last operation.
	private ArrayList<String> lastRes = new ArrayList();
	// The string on which the concatenation operation is done
        private String s;
	
	public NewString (String args) {
		s = args;
	}
	// returns the last operation result of the object
	public ArrayList<String> getResult() {
		return lastRes;
	}
        // current operation stored on to the ArrayList
	public void setResult(ArrayList<String> opers) {
		this.lastRes = opers;
	}
	
	public void concat(String args) {
		doCommand();
		s = s.concat(args);
	}
	
        //this function is called when concat method is called. (the previous function)
        //we append current operation to an ArrayList
	public void doCommand() {
		lastRes.add(this.s);
	}
	
        // this method does the undo operation.
        // in this method redo the last operation in an ad-hoc fashion, to undo
        // last operation
	public void undoCommand() {
		if(lastRes.size() > 0) {
			s = lastRes.get(lastRes.size()-1);
			lastRes.remove(lastRes.size()-1);
		}
		else
			System.out.println("no command done to undo");
	}
        // the getter and setter methods for the string
	public String getS() {
		return s;
	}
	public void setS(String s) {
		this.s = s;
	}
	
	public static void main(String[] args) {
	
		NewString s = new NewString("sample ");
		System.out.println(s.getS());
		s.concat("123");//concatenating the string
		System.out.println(s.getS());
		s.undoCommand();//removes the last modification of the NewString object
		System.out.println(s.getS());
		s.undoCommand();
		System.out.println(s.getS());
	}
}

Sample Output: 

$ sample
$ sample123
$ sample
$ no command done to undo

Implementation in Ruby

The key to implementing command patterns in Java are mixins, which define the executing operations. In its simplest form, this mixin include the implementation of the execute operation. Each Command class that specifies a receiver-action pair by storing the Receiver as an instance includes the mixin and calls the execute operation of the mixin.

Example Code 

$ irb
# this is command pattern module which implements do undo operation 
# for any class/object.  We store the last operation in a stack.
module CommandPattern
  //pops the previous operation from the stack
  def undoCommand()    
    if(@lastRes.length > 0)
        initialize(@lastRes.pop())
    else
        puts "no command done to undo"
    end
  end
  //pushes the current operation of the stack
  def doCommand(object)
  
    if(@lastRes == nil)
      @lastRes = []
    end
    
    @lastRes.push(object)
    puts "docommand #{object}" 
  end
end

# here we can extend any class to whatever functionality we want,
#by just including the module previously defined.
class NewString < String 
  include CommandPattern
  attr_accessor :lastRes
  def initialize(arg)
    super(arg)
  end
  def concat(arg)
    doCommand(to_s())
    super(arg)
    
  end
end

Sample Output: 

>a = NewString.new("sample")
>puts a
>>sample
>a.concat("123")
>puts a
>>sample123
>a.undoCommand()
>puts a
>>sample
>a.undoCommand()
>>no command done to undo

Advantages of Ruby over Java

The following explanation from the webpage [1] captures the advantages of Ruby implementation of command patterns over Java in a succinct and clear manner.

"Execute() methods in the Command design pattern must return Object rather than a specific type in pre-Java 5 code, resulting in ClassCastExceptions. Likewise, when signatures change between compile-time and runtime, runtime Errors ensue. In practice, whether in Java or Ruby, such errors rarely cause severe field bugs. A strong unit test suite—which you need anyway!—generally catches them in time.

Ruby's dynamic typing does not mean weak typing—Ruby always requires you to pass objects of the correct type. Java, in fact, enforces types more weakly than Ruby. For example, Java evaluates "4" + 2 as "42", coercing the integer to a string, while Ruby throws a TypeError, telling you it "can't convert Fixnum into String." Likewise, Java, sacrificing correctness for speed, can silently overflow an integer operation, producing weirdness such as Integer.MAX_VALUE + 1, which equals Integer.MIN_VALUE, while Ruby simply expands integers as needed."

Conclusion

In our Ruby implementation, the command pattern for undo is coded as a module, which can be included for any class or an object. While in Java, its been implemented as an interface forcing it be implemented by every class that needs this functionality. Also, implementing it as a separate module makes 'do' and 'undo' code to be written only once and any object/class can be extended easily. While in Java, each class that implements this interface must have a separate definition for the code. This has several disadvantages like increases code complexity, size and is generally confusing and tedious to trace or understand the code.

References

  • Wikipedia page, [2]
  • Javaworld, a pretty detailed discussion on pros and cons of using java and ruby for various purposes. [3]
  • Example of Undo Implementation [4]

Further Reading

  • Design Patterns: A good starting point [5]
  • How to implement Command Pattern in java [6]
  • Advanced topics on Ruby[7]
  • An elementary tutorial on Design Pattern [8]

External Links

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2007/wiki1b_7_as&oldid=5489"