Re: [boost] undo library

From: Steven Kirk (steven.kirk_at_[hidden])
Date: 2003-01-23 08:16:01

Just one thought : couldn't much of this be achieved without having to
create your own undo classes by boost::functions and the boost::bind
library?

for example, to implement just the undo (untested code, just to give an
idea, I'm not suggesting that this wouldn't be better wrapped in an
undo_list class):

-
void string_erase_undo(std::string& dest, int pos, std::string to_insert)
{
    dest.insert(pos, to_insert);
}

std::vector< boost::function<void()> > undolist;
std::string teststring = "This is a simple test of the boost undo library";

undolist.push_back(boost::bind(string_erase_undo, teststring, 10,
                               std::string(teststring, 10, 7));
teststring.erase(10, 7);

// to undo:
undolist.back()()
-

> Hello there!
>
> I just wanted to ask if there would be someone interested in a framework
> library for undo/redo-functionality. In other C++ groups sometimes the
> question pops up, how to implement undo-functionality. Since I've written
> such thing as part of a programm of mine and since I have it "boostenised"
> already, I would like to introduce it briefly. Please feel free to give me
> any comments about it...
>
> Basicly there are two classes: boost::undo_list and boost::undo_action,
the
> latter is an abstract base class for any undo-function you want to
> provide...
> Instead of describing all the details I'll just give a short example of
how
> one could use the library...
> // ----------------------------------------------------
> #include <string>
> #include <iostream>
> using namespace std;
>
> #include "undo_action.hpp"  // class boost::undo_action
> #include "undo_list.hpp"    // class boost::undo_list
>
> #include "myown_undoactions.hpp"  // contains undo-action classes
>
> int main() {
>     // 1. create the undo list somewhere
>     boost::undo_list undolist;
>     // 2. maybe you want to change the number of maximum undo steps
>     undolist.set_maxundo(100);
>
>     string teststring;
>     teststring = "This is a simple test of the boost undo library";
>
>     cout << "Original string: " << teststring << endl;
>
>     // Ok, someone want's to remove a part of that string.
>     // let's start with constructing the undo-action and adding that to
>     // the undo list. The class StringEraseUndo is a user defined
>     // undo class derived from undo_action
>
>     // 3. create and add an undo action
>
>     // NOTE: the constructor can look whatever the user wants it
>     // to look like (see example at end of posting)
>     undolist.add( new StringEraseUndo(10, 7,
>         teststring.substr(10, 7), teststring) );
>
>     // NOTE: All pointers added to the list make the objects
>     // be OWNED by the list, thus the list is responsable
>     // for cleaning up the memory
>
>     // 4. perform the will-be-made-undone action
>     // That means, let's finally delete that substring
>     teststring.erase(10, 7);
>     cout << "After erase: " << teststring << endl;
>
>     // 5. and now let's make this undone...
>     undolist.undo_last();
>     cout << "After UNDO: " << teststring << endl;
>
>     // 6. or re-done, if you like
>     undolist.redo_last();
>     cout << "After REDO: " << teststring << endl;
> };
> // ----------------------------------------------------
>
> Well, it is obvious that the biggest problem in using the undo-library
will
> be the implementation of the user defined undo/redo-classes.
> For the example above the class StringEraseUndo could look like this:
>
> class StringEraseUndo : public undo_action {
>   public:
>     // Ctor
>     StringEraseUndo(std::size_t start, std::size_t size,
>         const std::string& snipped, std::string& str)
>         : start_(start), size_(size), snipped_(snipped), str_(str) {};
>
>     virtual bool undo();
>     virtual void redo();
>
>   private:
>     std::size_t start_;
>     std::size_t size_;
>     std::string snipped_;
>     std::string& str_;
> };
>
> bool StringEraseUndo::undo() {
>     str_.insert(start_, snipped_);
>     return true;
> };
>
> void StringEraseUndo::redo() {
>     str_.erase(start_, size_);
> };
>
>
> However, since the undo-classes can be whatever they want to be, including
> non-C++-standard stuff like GUI things, this library can be used in almost
> any circumstances. The Framework, that is the undo_list and the
undo_action
> classes can still be written in plain C++ without having to know anything
> about the users environment. This clearly qualifies these classes as a
> library.
>
> Sorry for the long text, but with just describing the system shortly it
> would have caused too much confusion :-)
>
> The library itself (that is the undo_action.hpp, undo_list.hpp and
> undo_list.cpp) are ready so far. Do you think this could be a useful
> addition to the boost library?
>
> Thanks for any comments!
> Bye - Andreas
>
>
> _______________________________________________
> Unsubscribe & other changes:
http://lists.boost.org/mailman/listinfo.cgi/boost
>
>