#ifndef SKELETON_H
#define SKELETON_H
/////////////////////////////////////////////////////////////////////////////
// skeleton.h  -  demonstrate Memento pattern
//
// Jim Fawcett, CSE791 - Design Patterns, Summer 2000
//

#include <string>
#include <vector>
#include <iostream>

/////////////////////////////////////////////////////////////////////////////
// forward declarations

template<class state> class Originator;

/////////////////////////////////////////////////////////////////////////////
// Memento class

template<class state> class Memento {

  public:
    Memento(Originator<state> *pOrig);
    void GetState();
    void SetState();

  private:
    Originator<state>* _pOrig;
    state _state;
};

template<class state> inline
Memento<state>::Memento(Originator<state> *pOrig) : _pOrig(pOrig) { }

template<class state> inline
void Memento<state>::GetState() { 
  
  _state = _pOrig->_state; 
}

template<class state> inline
void Memento<state>::SetState() { 
  
  _pOrig->_state = _state; 
}

//

/////////////////////////////////////////////////////////////////////////////
// Originator class

template<class state> class Originator {

  friend class Memento<state>;

  public:
    Originator(const state &s);
    void Operation(std::string s);
    void SetMemento(Memento<state> *m);
    Memento<state>* CreateMemento();

  private:
    state _state;
};

template<class state> inline
Originator<state>::Originator(const state &s) : _state(s) { }

template<class state> inline
void Originator<state>::SetMemento(Memento<state> *m) { 
  
  m->SetState();
  cout << "\n\n  Originator retrieving state \"" << _state << "\"";
}

template<class state> inline
Memento<state>* Originator<state>::CreateMemento() { 

  cout << "\n  Originator creating memento with state \"" 
       << _state << "\"";
  Memento<state> *pMem = new Memento<state>(this);
  pMem->GetState();
  return pMem;
}

template<class state> inline
void Originator<state>::Operation(std::string s) { 
  
  cout << "\n\n  Originator changing state to \"" << s << "\"";
  _state = s; 
}

//

/////////////////////////////////////////////////////////////////////////////
// Caretaker class

template<class state> class Caretaker {

  public:
    Caretaker(Originator<state> *orig);
    void acceptMemento();
    void returnMemento();

  private:
    Originator<state>* _pOrig;
    std::vector< Memento<state>* > _mementos;
};

template<class state> inline
Caretaker<state>::Caretaker(Originator<state> *pOrig) : _pOrig(pOrig) { }

template<class state>
void Caretaker<state>::acceptMemento() {

  Memento<state> *pMem = _pOrig->CreateMemento();
  _mementos.push_back(pMem);
}

template<class state> inline
void Caretaker<state>::returnMemento() {

  if(_mementos.size() > 0) {
    Memento<state> *pMem = _mementos.back();
    _mementos.pop_back();
    _pOrig->SetMemento(pMem);
    delete pMem;
  }
}

#endif