A while back I implemented a scope guard to make it easier to follow Abrahams strong guarantee. And I have used it in various projects and found it very useful.

But there is one thing that the scope guard does not handle very well lets look at a short example.

int a = 1;
float b = 2.12f;
std::string c = "hello";

try
{
    a = fetch_a();
    b = fetch_b();
    c = fetch_c();
}
catch(..)
{
    ...
}

In the example above you could get partial value transaction, e.g. if fetch_b throws an exception fetch_a will have made it’s transaction to a.
Resulting in that the integer variable a is not in face with b and c. The behavior of the program is undetermined from this point forward.

This type of rollback is not handle very well by the scope guards, it is not impossible but not the trivial task you want it to be.

To solve this problem I introduced a small class named transaction that has the functionality to rollback all variables it holds reference to. The variable is rolled back to the state it was when the variable was added to the transaction class.

The rollback would only be done if the commit method on the transaction class is not executed witch would happen if e.g. an exception would be thrown. If we would used the transaction class in the example above the code would look like this:

int a = 1;
float b = 2.12f;
std::string c = "hello";

try
{
    thebc::transaction t();
    t.add( a );
    t.add( b );
    t.add( c );

    a = fetch_a();
    b = fetch_b();
    c = fetch_c();

    t.commit();
}
catch(..)
{
    ...
}

Now if fetch_b or c would throw an exception all the variables would rollback to there previous values and the application would go on as if the failed method never was executed.

I have hacked on a journaled fstream for a other project will post more info on this later.