//
// TrOp class contains an operation that may be
// undone during a rollback. It's an ABC from
// which all undoable operations derive.
//
class TrOp
{
  public:
    virtual void Undo() = 0;
    virtual ~TrOp() {}
};

//
// The Change template generates depending on
// the data type all possible operations (derived
// from TrOp) that may be undone. For example
// the instruction:
//
//           new Change<int>(a);
//
// generates a new "change of an integer" object
// and saves the old value to be able to restore
// it if an undo is requested.
//
template<class T> class Change : public TrOp
{
  public:
    T& who;
    T old_value;
    
    Change(T& s) : who(s), old_value(s) { }
    void Undo() { who=old_value; }
};

//
// The Transaction vector contains all the
// operations that must be undone to get
// back to the last good state of the
// database. It's a vector of pointers as
// TrOps are used polymorphically.
//
std::vector<TrOp *> Transaction;

//
// The Field template generates all possible
// fields in an database object. The Field<T>
// class is responsible for generating an
// appropriate Change<T> object before any
// modification.
//
template<class T> class Field : public T
{
  private:
    void Save()
    {
      Transaction.push_back(
        new Change<T>(*static_cast<T*>(this))
      );
    }
    Field& operator&();
  
  public:
    // Costructor from a T object
    Field(const T& s) : T(s) { }
    
    // Conversion to a T value (const!!!)
    operator const T() const { return *this; }
    
    // Assigning
    Field& operator=(const T& v)
    { Save(); T::operator=(v); return *this; }
    
    Field& operator=(const Field<T>& v)
    { Save(); T::operator=(v); return *this; }
    
    // Remapping of ++/--
    const T operator++(int)
    { Save(); return T::operator++(0); }
    
    const T operator--(int)
    { Save(); return T::operator--(0); }
    
    Field& operator++()
    { Save(); T::operator++(); return *this; }
    
    Field& operator--()
    { Save(); T::operator--(); return *this; }
    
    // Remapping of modifiers
    Field& operator+=(const T& v)
    { Save(); T::operator+=(v); return *this; }
    
    Field& operator-=(const T& v)
    { Save(); T::operator-=(v); return *this; }
    
    Field& operator*=(const T& v)
    { Save(); T::operator*=(v); return *this; }
    
    Field& operator/=(const T& v)
    { Save(); T::operator/=(v); return *this; }
    
    Field& operator%=(const T& v)
    { Save(); T::operator%=(v); return *this; }

    //
    // Note: if there are methods that change
    // the object they should be overridden to
    // be able to call Save() before invoking
    // the original method of T.
    //
};