Email	Print Reprint
	add to:
	Del.icio.us Digg Google Furl	Slashdot Y! MyWeb Blink
	TABLE OF CONTENTS Transactional Programming Transactions Nesting Transactions Transactional Values Implementation Lists and Trees Cleanup, Concurrent Access, Performance

Transactional Values

Any C++ class can be made transactional. The atomic::value class template holds a single value that can be rolled back to any previous value.

atomic::value<std::string> name =
     "bill";
{
  atomic::transaction t1;
 name = "tom";
  assert(*name == "tom");
 {
  atomic::transaction t2;
    name = "fred";
  assert(*name == "fred");
  t2.commit();
 }
  assert(*name == "fred"); 
    // Committed by t2
}
assert(*name == "bill");
    // Rolled back by t1

The stored object is const, so that it cannot be accidentally modified in a way that cannot be rolled back by a transaction. Previous values are not destroyed until the end of the transaction, in case they need to be reincarnated.

Transactional Pointers

The Atomic Library provides shared pointers and weak pointers that are similar to the TR1 smart pointers (www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf). These pointers keep a counter of the number of pointers to the object. When the count reaches zero, the object can be deleted.

These pointers do not destroy the pointee object until the end of the transaction in case the pointer needs to be rolled back, but the reference count (q.expired(), for example) behaves as if the object is destroyed. For instance:

atomic::shared_ptr<int> 
    p(new int(1));
atomic::weak_ptr<int> q(p);
{
 atomic::transaction tr;
 p.reset(new int(2));
 assert(q.expired());
 assert(*p == 2);
}
assert(*p == 1);  
    // Rolled back by tr
assert(!q.expired()); 
    // Rolled back by tr

If compatibility with std::tr1::shared_ptr is required, then a suitable approach would be atomic::value<std::tr1::shared_ptr<> >.

Previous Page | 1 Transactional Programming | 2 Transactions | 3 Nesting Transactions | 4 Transactional Values | 5 Implementation | 6 Lists and Trees | 7 Cleanup, Concurrent Access, Performance Next Page

RELATED ARTICLES Cloud Computing: Detecting Scalability Problems Logging In C++ : Part 2 recls 100% .NET QuickThread: A New C++ Multicore Library C Snippet #8		TOP 5 ARTICLES No Top Articles.