//
// La classe TrOp contiene una operazione che puo'
// essere annullata durante un rollback.
// Si tratta di una classe base astratta da cui
// derivano tutti i tipi di operazione annullabile.
//
class TrOp
{
  public:
    virtual void Undo() = 0;
    virtual ~TrOp() {}
};

//
// Il template Change genera al variare del tipo
// dati usato le possibili operazioni (derivate
// da TrOp) che e' possibile annullare in un
// rollback. In pratica l'istruzione
//
//           new Change<int>(a);
//
// crea un oggetto "cambio di intero" e salva
// il vecchio valore in modo da rendere
// annullabile l'operazione eseguita.
//
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; }
};

//
// Il vettore Transaction contiene tutte le
// operazioni da annullare in caso di una
// richiesta di rollback.
//
std::vector<TrOp *> Transaction;

//
// Il template field genera al variare del
// tipo dati i possibili campi di un oggetto.
// Il campo provvede a generare un opportuno
// oggetto Change<tipo> ad ogni modifica.
//
template<class T> class Field : public T
{
  private:
    void Save()
    {
      Transaction.push_back(
        new Change<T>(*static_cast<T*>(this))
      );
    }
    Field& operator&();
  
  public:
    // Costruttore da oggetto T
    Field(const T& s) : T(s) { }
    
    // Conversione a valore (const!!!)
    operator const T() const { return *this; }
    
    // Assegnazione
    Field& operator=(const T& v)
    { Save(); T::operator=(v); return *this; }

    Field& operator=(const Field<T>& v)
    { Save(); T::operator=(v); return *this; }
    
    // Rimappatura ++/--
    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; }
    
    // Rimappatura incrementi/decrementi
    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; }

    //
    // Nota: se sono presenti metodi che
    // modificano una classe e' necessario
    // inserire un opportuno override in modo
    // da effettuare una Save() completa o
    // Save() specifiche delle parti modificate
    // prima di invocare il metodo in questione.
    //
};