Memento pattern

package 
{
	import flash.display.Sprite;
 
	/**
	* Memento
	*/
	public class As3Memento extends Sprite
	{
		function As3Memento()
		{
			var ct:CareTaker = new CareTaker();
			var originator:Originator = new Originator();
 
				originator.A = 'letter A';
				originator.B = 'letter B';
				originator.C = 'letter C';
 
				ct.addMementoFrom(originator);
 
				originator.A = 'anything...';
				originator.B = 'blah blah...';
				originator.C = 'etc...';
				ct.addMementoFrom(originator);
 
				originator.restoreFromMemento(ct.getMemento(0));
 
				trace(originator.A, originator.B, originator.C);
 
				originator.restoreFromMemento(ct.getMemento(1));
 
				trace(originator.A, originator.B, originator.C);
 
		}
	}
 
}
 
interface IMemento
{
	function getMemento():Object;
	function restoreFromMemento(obj:Object):void;
}
 
class Originator implements IMemento
{
	public var A:String;
	public var B:String;
	public var C:String;
 
	function Originator()
	{ }
 
	/* INTERFACE IMemento */
 
	public function getMemento():Object
	{
		return { _A:A, _B:B, _C:C };
	}
 
	public function restoreFromMemento(obj:Object):void
	{
		A = obj._A;
		B = obj._B;
		C = obj._C;
	}
 
}
 
class CareTaker 
{
	private var mementos:Array;
	function CareTaker()
	{
		mementos = new Array();
	}
 
	public function addMementoFrom( object:IMemento ):void
	{
		mementos.push( object.getMemento() );
	}
 
	public function getMemento(index:uint):Object
	{
		return mementos[index];
	}
}

class Originator {
 
    private String state;
    /* lots of memory consumptive private data that is not necessary to define the
     * state and should thus not be saved. Hence the small memento object. */
 
    public void set(String state) {
        System.out.println("Originator: Setting state to " + state);
        this.state = state;
    }
 
    public Object saveToMemento() {
        System.out.println("Originator: Saving to Memento.");
        return new Memento(state);
    }
 
    public void restoreFromMemento(Object m) {
        if (m instanceof Memento) {
            Memento memento = (Memento) m;
            state = memento.getSavedState();
            System.out.println("Originator: State after restoring from Memento: " + state);
        }
    }
 
    private static class Memento {
 
        private String state;
 
        public Memento(String stateToSave) {
            state = stateToSave;
        }
 
        public String getSavedState() {
            return state;
        }
 
    }
 
}
 
import java.util.*;
 
class Caretaker {
 
    private List<Object> savedStates = new ArrayList<Object>();
 
    public void addMemento(Object m) {
        savedStates.add(m);
    }
 
    public Object getMemento(int index) {
        return savedStates.get(index);
    }
 
}
 
class MementoExample {
 
    public static void main(String[] args) {
 
        Caretaker caretaker = new Caretaker();
 
        Originator originator = new Originator();
        originator.set("State1");
        originator.set("State2");
        caretaker.addMemento(originator.saveToMemento());
        originator.set("State3");
        caretaker.addMemento(originator.saveToMemento());
        originator.set("State4");
 
        originator.restoreFromMemento(caretaker.getMemento(1));
 
    }
 
}

#!/usr/bin/env ruby -KU
 
require 'rubygems'
require 'spec'
 
class Originator
  class Memento
    def initialize(state)
      # dup required so that munging of the Originator's original state doesn't mess up
      # this Memento for first or subsequent restore
      @state = state.dup
    end
 
    def state
      # dup required so that munging of the Originator's restored state doesn't mess up
      # this Memento for a second restore
      @state.dup
    end
  end
 
  attr_accessor :state
 
  # pretend there's lots of additional memory-heavy data, which can be reconstructed
  # from state
  def save_to_memento
    Memento.new(@state)
  end
 
  def restore_from_memento(m)
    @state = m.state
  end
 
end
 
class Caretaker < Array; end
 
describe Originator do
  before(:all) do
    @caretaker = Caretaker.new
    @originator = Originator.new
 
    @originator.state = "State1"
  end
 
  it "should have original state" do 
    @originator.state.should == 'State1'
  end
 
  it "should update state" do
    @originator.state = "State2"
    @originator.state.should == 'State2'
  end
 
  it "should save memento" do
    @caretaker << @originator.save_to_memento
    @caretaker.size.should == 1
  end
 
  it "should update state after save to memento" do
    @originator.state = "State3"
    @originator.state.should == 'State3'
  end
 
  it "should save to memento again" do
    @caretaker << @originator.save_to_memento
    @caretaker.size.should == 2
  end
 
  it "should update state after save to memento again" do
    @originator.state = "State4";
    @originator.state.should == 'State4'
  end
 
  it "should restore to original save point" do
    @originator.restore_from_memento @caretaker[0]
    @originator.state.should == 'State2'
  end
 
  it "should restore to second save point" do
    @originator.restore_from_memento @caretaker[1]
    @originator.state.should == 'State3'
  end
 
  it "should restore after pathological munging of restored state" do
    @originator.state[-1] = '5'
    @originator.state.should == 'State5'
    @originator.restore_from_memento @caretaker[1]
    @originator.state.should == 'State3'
  end
 
  it "should restore after pathological munging of original state" do
    @originator.state = "State6"
    @originator.state.should == 'State6'
    @caretaker << @originator.save_to_memento
    @originator.state[-1] = '7'
    @originator.state.should == 'State7'
    @originator.restore_from_memento @caretaker[2]
    @originator.state.should == 'State6'
  end
end