---

test-Undoable.cxx

Go to the documentation of this file.

#include "Undoable.h"
#include <sigc++/bind.h>
#include <sigc++/object_slot.h>

class UndoableInt : public Undoable 
{
public:
    UndoableInt(int i) : fVal(i) {}
    virtual ~UndoableInt() {}
    void Set(int i) { fVal = i; }
    int Get(void) { return fVal; }

    // Undoable:
    UndoMemento GetMemento(void) 
        { return SigC::bind(SigC::slot(this,&UndoableInt::Set),fVal); }
private:
    int fVal;
};

class BigUndoable : public Undoable
{

public:

    struct MyState {
        int fInt;
        float fFloat;
        MyState(int i, float f) : fInt(i), fFloat(f) {};
        MyState() : fInt(0), fFloat(0.0) {};
    };
    
    BigUndoable(int i, float f)  {fState.fInt = i; fState.fFloat = f;}
    ~BigUndoable() {}

    void SetState(MyState ms) { fState = ms; }
    int GetInt() { return fState.fInt; }
    float GetFloat() { return fState.fFloat; }
    void IncState() { ++fState.fInt; ++fState.fFloat; }

    UndoMemento GetMemento(void)
        { return SigC::bind(SigC::slot(this,&BigUndoable::SetState),fState); }

private:
    MyState fState;
};
int test1()
{
    UndoableInt i1(42);
    UndoHistory uh;
    UndoableInt i2(69), i3(1);
    BigUndoable bu(0,0.0);

    // Load up history
    for (int i=0; i<5; ++i) {
        UndoCommand uc;

        uc.push_back(UndoItem(i1));
        uc.push_back(UndoItem(i2));
        uh.Store(uc);
        assert(uc.size() == 0);

        uc.push_back(UndoItem(i3));
        uh.Store(uc);
        assert(uc.size() == 0);

        uc.push_back(UndoItem(bu));
        uh.Store(uc);
        assert(uc.size() == 0);

        cerr << "[" << i << "] "
             << "Stored as " 
             << "[i1=" << i1.Get() 
             << ", i2=" << i2.Get() 
             << "], [i3=" << i3.Get() << "], ("
             << bu.GetInt() << "," << bu.GetFloat() <<") ";
        i1.Set(i1.Get()+1);
        i2.Set(i2.Get()+1);
        i3.Set(i3.Get()+1);
        bu.IncState();
        cerr << "modify to "
             << "[i1=" << i1.Get()
             << ", i2=" << i2.Get() 
             << "], [i3=" << i3.Get() 
             << "], ("
             << bu.GetInt() << "," << bu.GetFloat() <<") " << endl;
    }
        
    cerr << endl;

    // Undo some
    for (int i=0; i<16; ++i) {
        cerr << "[undo #" << i << "] "
             << "i1=" << i1.Get() 
             << ", i2=" << i2.Get()
             << ", i3=" << i3.Get()
             << " (" << bu.GetInt() << "," << bu.GetFloat() <<") ";
        if (uh.Undo())
            cerr << " after: "
                 << "i1=" << i1.Get()
                 << ", i2=" << i2.Get() 
                 << ", i3=" << i3.Get() 
                 << " (" << bu.GetInt() << "," << bu.GetFloat() <<") "
                 << endl;
        else 
            cerr << " Nothing to undo\n";
    }

    cerr << endl;

    // Redo some
    for (int i=0; i<16; ++i) {
        cerr << "[redo #" << i << "] "
             << "i1=" << i1.Get() 
             << ", i2=" << i2.Get() 
             << ", i3=" << i3.Get() 
             << " (" << bu.GetInt() << "," << bu.GetFloat() <<") ";
        if (uh.Redo())
            cerr << " after: "
                 << "i1=" << i1.Get()
                 << ", i2=" << i2.Get() 
                 << ", i3=" << i3.Get() 
                 << " (" << bu.GetInt() << "," << bu.GetFloat() <<") "
                 << endl;
        else 
            cerr << " Nothing to redo\n";
    }

    return 0;
}

class Composite : public Undoable
{
public:
    Composite() : i1(1), i2(2), i3(3) {}
    virtual ~Composite() {}


    UndoMemento GetMemento(void) {
        vector<UndoMemento> umv;
        umv.push_back(i1.GetMemento());
        umv.push_back(i2.GetMemento());
        umv.push_back(i3.GetMemento());
        return SigC::bind(SigC::slot(this,&Composite::ProcVec),umv);
    }

    void ProcVec(vector<UndoMemento> umv) {
        vector<UndoMemento>::iterator vit;
        for (vit = umv.begin(); vit != umv.end(); ++vit) (*vit)();
    }
  
    void Increment() { 
        i1.Set(i1.Get()+1);
        i2.Set(i2.Get()+1);
        i3.Set(i3.Get()+1);
    }

    void Print() {
        cout << "i1="<< i1.Get()
             << " i2="<< i2.Get()
             << " i3="<< i3.Get()
             << endl;
    }

private:
    UndoableInt i1, i2, i3;

};

int test2()
{
    Composite c;
    UndoHistory uh;

    // Load up history
    for (int i=0; i<5; ++i) {
        UndoCommand uc;

        uc.push_back(UndoItem(c));
        uh.Store(uc);
        assert(uc.size() == 0);

        cout << "Before: "; c.Print();
        c.Increment();
        cout << "After:  "; c.Print();

    }

    cout << endl;
    
    // Undo some
    for (int i=0; i<6; ++i) {
        cout << "Before undo: "; c.Print();
        if (uh.Undo()) {
            cout << "After undo:  "; c.Print();
        }
        else
            cout << "Nothing to undo\n";
    }

    cerr << endl;

    // Redo some
    for (int i=0; i<6; ++i) {
        cout << "Before redo: "; c.Print();
        if (uh.Redo()) {
            cout << "After redo:  "; c.Print();
        }
        else
            cout << "Nothing to redo\n";
    }

    return 0;
}

int main (int argc, char *argv[]) 
{
    char c = '1';
    if (argc > 1) c = argv[1][0];
    switch (c) {
    case '1':
        return test1();
        break;
    case '2': 
    default:
        return test2();
        break;
    }
    return 0;
} // end of main()

---