CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2004 Memento, Prototype & Abstract Factory
	Previous    Lecture Notes Index    Next     © 2004, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 08-Mar-04

Doc 12, Memento, Prototype & Abstract Factory Slide # 2

Memento

Structure

• Can access Memento’s get/set state methods

• Create Memento

Doc 12, Memento, Prototype & Abstract Factory Slide # 3

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, Memento, Prototype & Abstract Factory Slide # 4

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, Memento, Prototype & Abstract Factory Slide # 5

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, Memento, Prototype & Abstract Factory Slide # 6

   // 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, Memento, Prototype & Abstract Factory Slide # 7

Consequences/ Implementation

• How to store state history and for how long?

Doc 12, Memento, Prototype & Abstract Factory Slide # 8

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, Memento, Prototype & Abstract Factory Slide # 9

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, Memento, Prototype & Abstract Factory Slide # 10

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, Memento, Prototype & Abstract Factory Slide # 11

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, Memento, Prototype & Abstract Factory Slide # 12

Prototype

Intent

Applicability

• A system should be independent of how its products are created, composed, and represented; and

• when the classes to instantiate are specified at run-time; or

• to avoid building a class hierarchy of factories that parallels the class hierarchy of products; or

• when instances of a class can have one of only a few different combinations of state.

It may be easier to have the proper number of prototypes and clone them rather than instantiating the class manually each time

Doc 12, Memento, Prototype & Abstract Factory Slide # 13

• Copy the original and edit the copy

• Store only the differences between original and the customize version in a decorator

Doc 12, Memento, Prototype & Abstract Factory Slide # 14

Copying Issues

Shallow Copy Verse Deep Copy

Doc 12, Memento, Prototype & Abstract Factory Slide # 15

Doc 12, Memento, Prototype & Abstract Factory Slide # 16

Doc 12, Memento, Prototype & Abstract Factory Slide # 17

Cloning Issues

class Door 
   {
   public:
      Door();
      Door( const Door&);
   
      virtual Door* clone() const;
   
      virtual void Initialize( Room*, Room* );
      // stuff not shown
   private:
      Room* room1;
      Room* room2;
   }
   
Door::Door ( const Door& other ) //Copy constructor
   {
   room1 = other.room1;
   room2 = other.room2;
   }
   
Door* Door::clone()  const 
   {
   return new Door( *this );
   }

Doc 12, Memento, Prototype & Abstract Factory Slide # 18

Default is shallow copy

class Door implements Cloneable {
   public void Initialize( Room a, Room b) 
      { room1 = a; room2 = b; }
   public Object clone() throws
                CloneNotSupportedException {
      // modify this method for deep copy
      // no need to implement this method for shallow copy
      return super.clone();
   }
   Room room1;
   Room room2;
}

Doc 12, Memento, Prototype & Abstract Factory Slide # 19

Object>>shallowCopy
   Does a shallowCopy of the receiver

Object>>copy
   ^self shallowCopy postCopy
   
   “Template method for copy”

Smalltalk.CS635 defineClass: #Door
   superclass: #{Core.Object}
   indexedType: #none
   private: false
   instanceVariableNames: 'room1 room2 '

postCopy
   room1 := room1 copy.
   room2 := room2 copy. 

Doc 12, Memento, Prototype & Abstract Factory Slide # 20

Consequences

• Adding and removing products at run-time

• Specifying new objects by varying values

• Specifying new objects by varying structure

• Reducing subclassing (from factory method)

• Configuring an application with classes dynamically

Implementation Issues

• Using a prototype manager

• Implementing the Clone operation

• Initializing clones

Doc 12, Memento, Prototype & Abstract Factory Slide # 21

Abstract Factory

• Mac, PC & Unix
• Use the look and feel of each platform

Doc 12, Memento, Prototype & Abstract Factory Slide # 22

• An interface (or abstract class) for each widget
• A concrete class for each platform:

Doc 12, Memento, Prototype & Abstract Factory Slide # 23

public void installDisneyMenu()
   {
   Menu disney = create a menu somehow
   disney.addItem( "Disney World" );
   disney.addItem( "Donald Duck" );
   disney.addItem( "Mickey Mouse" );
   disney.addGrayBar( );
   disney.addItem( "Minnie Mouse" );
   disney.addItem( "Pluto" );
   etc.
   }

• We get the correct interface widgets

• Minimize places in code that know the platform

Doc 12, Memento, Prototype & Abstract Factory Slide # 24

abstract class WidgetFactory
   {
   public Window createWindow();
   public Menu createMenu();
   public Button createButton();
   }
   
class MacWidgetFactory extends WidgetFactory
   {
   public Window createWindow() 
      { code to create a mac window }
      
   public Menu createMenu() 
      { code to create a mac Menu }
      
   public Button createButton() 
      { code to create a mac button }
   }   
   
class Win95WidgetFactory extends WidgetFactory
   {
   public Window createWindow() 
      { code to create a Win95 window }
      
   public Menu createMenu() 
      { code to create a Win95 Menu }
      
   public Button createButton() 
      { code to create a Win95 button }
   }

Doc 12, Memento, Prototype & Abstract Factory Slide # 25

public void installDisneyMenu(WidgetFactory myFactory)
   {
   Menu disney = myFactory.createMenu();
   disney.addItem( "Disney World" );
   disney.addItem( "Donald Duck" );
   disney.addItem( "Mickey Mouse" );
   disney.addGrayBar( );
   disney.addItem( "Minnie Mouse" );
   disney.addItem( "Pluto" );
   etc.
   }

Doc 12, Memento, Prototype & Abstract Factory Slide # 26

How Do Factories create Widgets?

Method 1) My Factory Method

abstract class WidgetFactory
   {
   public Window createWindow();
   public Menu createMenu();
   public Button createButton();
   }
   
class MacWidgetFactory extends WidgetFactory
   {
   public Window createWindow() 
      { return new MacWidow() }
      
   public Menu createMenu() 
      { return new MacMenu() }
      
   public Button createButton() 
      { return new MacButton()  }
   }   

Doc 12, Memento, Prototype & Abstract Factory Slide # 27

Method 2) Their Factory Method

abstract class WidgetFactory {
   private Window windowFactory;
   private Menu menuFactory;
   private Button buttonFactory;
   
   public Window createWindow()
      { return windowFactory.createWindow() }
   
   public Menu createMenu();
      { return menuFactory.createMenu() }
   
   public Button createButton()
      { return buttonFactory.createMenu() }
}
   
class MacWidgetFactory extends WidgetFactory {
   public MacWidgetFactory() {
      windowFactory = new MacWindow();
      menuFactory = new MacMenu();
      buttonFactory = new MacButton();
   }
}   
   
class MacWindow extends Window {
   public Window createWindow() { blah }
   etc.

Doc 12, Memento, Prototype & Abstract Factory Slide # 28

abstract class WidgetFactory {
   private Window windowFactory;
   private Menu menuFactory;
   private Button buttonFactory;
   
   public Window createWindow()
      { return windowFactory.createWindow() }
   
   public Window createWindow( Rectangle size)
      { return windowFactory.createWindow( size ) }
   
   public Window createWindow( Rectangle size, String title)
      { return windowFactory.createWindow( size, title) }
   
   public Window createFancyWindow()
      { return windowFactory.createFancyWindow() }
   
   public Window createPlainWindow()
      { return windowFactory.createPlainWindow() }

Doc 12, Memento, Prototype & Abstract Factory Slide # 29

Method 2.5) Subclass returns Class

abstract class WidgetFactory {
   
   public Window createWindow()
      { return windowClass().newInstance() }
   
   public Menu createMenu();
      { return menuClass().newInstance()  }
   
   public Button createButton()
      {  return buttoneClass().newInstance() }
   
   public Class windowClass();
   public Class menuClass();
   public Class buttonClass();
}
   
class MacWidgetFactory extends WidgetFactory {
   public Class windowClass() 
      { return MacWindow.class; }
   
   public Class menuClass() 
      { return MacMenu.class; }
   
   public Class buttonClass() 
      { return MacButton.class; }
}   

Doc 12, Memento, Prototype & Abstract Factory Slide # 30

Method 3) Prototype

class WidgetFactory
   {
   private Window windowPrototype;
   private Menu menuPrototype;
   private Button buttonPrototype;
   
   public WidgetFactory( Window windowPrototype,
                  Menu menuPrototype,
                  Button buttonPrototype)
      {
      this.windowPrototype = windowPrototype;
      this.menuPrototype = menuPrototype;
      this.buttonPrototype = buttonPrototype;
      }
   
   public Window createWindow()
      { return windowFactory.createWindow() }
   
   public Window createWindow( Rectangle size)
      { return windowFactory.createWindow( size ) }
   
   public Window createWindow( Rectangle size, String title)
      { return windowFactory.createWindow( size, title) }
   
   public Window createFancyWindow()
      { return windowFactory.createFancyWindow() }
   
   etc.

Doc 12, Memento, Prototype & Abstract Factory Slide # 31

Applicability

• A system should be independent of how its products are created, composed and represented

• A system should be configured with one of multiple families of products

• A family of related product objects is designed to be used together, and you need to enforce this constraint

• You want to provide a class library of products, and you want to reveal just their interfaces, not their implementation

Doc 12, Memento, Prototype & Abstract Factory Slide # 32

• It isolates concrete classes

• It makes exchanging product families easy

• It promotes consistency among products

• Supporting new kinds of products is difficult

• Factories as singletons

• Defining extensible factories

Doc 12, Memento, Prototype & Abstract Factory Slide # 33

public void installDisneyMenu(WidgetFactory myFactory)
   {
   // We ship next week, I can't get the stupid generic Menu 
   // to do the fancy Mac menu stuff
   // Windows version won't ship for 6 months
   // Will fix this later
   
   MacMenu disney = (MacMenu) myFactory.createMenu();
   disney.addItem( "Disney World" );
   disney.addItem( "Donald Duck" );
   disney.addItem( "Mickey Mouse" );
   disney.addMacGrayBar( );
   disney.addItem( "Minnie Mouse" );
   disney.addItem( "Pluto" );
   etc.
   }

Doc 12, Memento, Prototype & Abstract Factory Slide # 34

Previous    visitors since 08-Mar-04    Next