// Purpose. Memento design pattern

// 1. Assign the roles of "caretaker" and "originator"
// 2. Create a "memento" class and declare the originator a friend
// 3. Caretaker knows when to "check point" the originator
// 4. Originator creates a memento and copies its state to the memento
// 5. Caretaker holds on to (but cannot peek in to) the memento
// 6. Caretaker knows when to "roll back" the originator
// 7. Originator reinstates itself using the saved state in the memento

#include <iostream> #include <string> using namespace std;

class Memento { // 2. Create a "memento" class and
friend class Stack; // declare the originator a friend
int *items, num;
Memento( int* arr, int n ) {
items = new int[num = n];
for (int i=0; i < num; i++) items[i] = arr[i]; }
public:
~Memento() { delete items; }
};

class Stack { // 1. Stack is the "originator"
int items[10], sp;
public:
Stack() { sp = -1; }
void push( int in ) { items[++sp] = in; }
int pop() { return items[sp--]; }
bool isEmpty() { return sp == -1; }
// 4. Originator creates a memento and copies its state to the memento
Memento* checkPoint() {
return new Memento( items, sp+1 );
}
// 7. Originator reinstates itself using the saved state in the memento
void rollBack( Memento* m ) {
sp = m->num-1;
for (int i=0; i < m->num; i++) items[i] = m->items[i];
}
friend ostream& operator<< ( ostream& os, const Stack& s ) {
string buf( "[ " );
for (int i=0; i < s.sp+1; i++) { buf += s.items[i]+48; buf += ' '; }
buf += ']';
return os << buf; // stack is [ 0 1 2 3 4 ]
} }; // stack is [ 0 1 2 3 4 5 6 7 8 9 ]
// popping stack: 9 8 7 6 5 4 3 2 1 0
// 1. main() is the "caretaker" // stack is [ ]
void main( void ) { // second is [ 0 1 2 3 4 5 6 7 8 9 ]
Stack s; // first is [ 0 1 2 3 4 ]
for (int i=0; i < 5; i++) s.push( i ); // popping stack: 4 3 2 1 0
cout << "stack is " << s << endl;
Memento* first = s.checkPoint(); // 3. Caretaker knows when to save
for (i=5; i < 10; i++) s.push( i ); // 5. Caretaker holds on to memento
cout << "stack is " << s << endl;
Memento* second = s.checkPoint(); // 3. Caretaker knows when to save
cout << "popping stack: "; // 5. Caretaker holds on to memento
while ( ! s.isEmpty()) cout << s.pop() << ' '; cout << endl;
cout << "stack is " << s << endl;
s.rollBack( second ); // 6. Caretaker knows when to undo
cout << "second is " << s << endl;
s.rollBack( first ); // 6. Caretaker knows when to undo
cout << "first is " << s << endl;
cout << "popping stack: ";
while ( ! s.isEmpty()) cout << s.pop() << ' '; cout << endl;
delete first; delete second;
}



// Purpose. Memento design pattern
//
// Discussion. A memento is an object that stores a snapshot of the
// internal state of another object. It can be leveraged to support
// multi-level undo of the Command pattern. In this example, before a
// command is run against the Number object, Number's current state is
// saved in Command's static memento history list, and the command itself
// is saved in the static command history list. Undo() simply "pops" the
// memento history list and reinstates Number's state from the memento.
// Redo() "pops" the command history list. Note that Number's encapsula-
// tion is preserved, and Memento is wide open to Number.

#include <iostream.h>
class Number;

class Memento {
public:
Memento( int val ) { _state = val; }
private:
friend class Number; // not essential, but p287 suggests this
int _state;
};

class Number {
public:
Number( int value ) { _value = value; }
void dubble() { _value = 2 * _value; }
void half() { _value = _value / 2; }
int getValue() { return _value; }
Memento* createMemento() { return new Memento( _value ); }
void reinstateMemento( Memento* mem ) { _value = mem->_state ; }
private:
int _value;
};

class Command {
public:
typedef void (Number::* Action)();
Command( Number* receiver, Action action ) {
_receiver = receiver;
_action = action; }
virtual void execute() {
_mementoList[_numCommands] = _receiver->createMemento();
_commandList[_numCommands] = this;
if (_numCommands > _highWater) _highWater = _numCommands;
_numCommands++;
(_receiver->*_action)(); }
static void undo() {
if (_numCommands == 0) {
cout << "*** Attempt to run off the end!! ***" << endl;
return; }
_commandList[_numCommands-1]->_receiver->
reinstateMemento( _mementoList[_numCommands-1] );
_numCommands--; }
void static redo() {
if (_numCommands > _highWater) {
cout << "*** Attempt to run off the end!! ***" << endl;
return; }
(_commandList[_numCommands]->_receiver->
*(_commandList[_numCommands]->_action))();
_numCommands++; }
protected:
Number* _receiver;
Action _action;
static Command* _commandList[20];
static Memento* _mementoList[20];
static int _numCommands;
static int _highWater;
};

Command* Command::_commandList[];
Memento* Command::_mementoList[];
int Command::_numCommands = 0;
int Command::_highWater = 0;

void main() {
int i;
cout << "Integer: ";
cin >> i;
Number* object = new Number(i);

Command* commands[3];
commands[1] = new Command( object, &Number::dubble );
commands[2] = new Command( object, &Number::half );

cout << "Exit[0], Double[1], Half[2], Undo[3], Redo[4]: ";
cin >> i;

while (i)
{
if (i == 3)
Command::undo();
else if (i == 4)
Command::redo();
else
commands[i]->execute();
cout << " " << object->getValue() << endl;
cout << "Exit[0], Double[1], Half[2], Undo[3], Redo[4]: ";
cin >> i;
}
}

// Integer: 11
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 2
// 5
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 1
// 10
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 2
// 5
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 3
// 10
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 3
// 5
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 3
// 11
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 3
// *** Attempt to run off the end!! ***
// 11
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 4
// 5
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 4
// 10
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 4
// 5
// Exit[0], Double[1], Half[2], Undo[3], Redo[4]: 4
// *** Attempt to run off the end!! ***
// 5