[Boost-commit] svn:boost r57095 - sandbox/stm/branches/vbe/boost/stm/tx

Subject: [Boost-commit] svn:boost r57095 - sandbox/stm/branches/vbe/boost/stm/tx
From: vicente.botet_at_[hidden]
Date: 2009-10-23 10:56:22

Author: viboes
Date: 2009-10-23 10:56:20 EDT (Fri, 23 Oct 2009)
New Revision: 57095
URL: http://svn.boost.org/trac/boost/changeset/57095

Log:
TBoost.STM vbe: Factoring common behavior between tx::numeric.hpp and tx/pointer.hpp on a new file tx::object.hpp

Added:
   sandbox/stm/branches/vbe/boost/stm/tx/object.hpp   (contents, props changed)
Text files modified: 
   sandbox/stm/branches/vbe/boost/stm/tx/numeric.hpp |    58 ++-------------------                   
   sandbox/stm/branches/vbe/boost/stm/tx/pointer.hpp |   106 +++++++-------------------------------- 
   2 files changed, 28 insertions(+), 136 deletions(-)

Modified: sandbox/stm/branches/vbe/boost/stm/tx/numeric.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/tx/numeric.hpp	(original)
+++ sandbox/stm/branches/vbe/boost/stm/tx/numeric.hpp	2009-10-23 10:56:20 EDT (Fri, 23 Oct 2009)
@@ -16,72 +16,28 @@
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
-#include <boost/stm/transaction.hpp>
-//#include <boost/stm/non_tx/detail/cache_map.hpp>
+#include <boost/stm/tx/object.hpp>
 
 //-----------------------------------------------------------------------------
 namespace boost { namespace stm { namespace tx {
 
 //-----------------------------------------------------------------------------
-// mixing transactional object numeric class that wraps a numeric builtin type providing
+// transactional object numeric class that wraps a numeric builtin type providing
 // a transparent transactional view on a transactional context
 // a non-transactional view on a non-transactional context
 // Note: the sizeof(numeric<T>)>>>>=sizeof(T)
 //-----------------------------------------------------------------------------
 template <typename T>
-class numeric : public transaction_object< numeric<T> >
+class numeric : public object< numeric<T>, T >
 {
-protected:
-    T val_;
+    typedef object< numeric<T> ,T > base_type;
 public:
     //-----------------------------------------------------------------------------
-    numeric() : val_(0) {}
-
-    //
+    numeric() : base_type(0) {}
     template<class U>
-    numeric(numeric<U> const& r) : val_(r.value()) {}
-
-    // contructor from a implicitly convertible to T
+    numeric(numeric<U> const& r) : base_type(r) {}
     template <typename U>
-    numeric(U v) : val_(v) {}
-    //numeric(T v) : val_(v) {}
-    ~numeric() {}
-
-    #if 0
-    template<class U>
-    numeric& operator=(numeric<U> const& r) {
-        val_=r.value();
-    }
-    #endif
-
-    operator T() const { return value(); }
-    operator T&() { return ref(); }
-
-    T& ref() {
-        transaction* tx=current_transaction();
-        if (tx!=0) {
-            if (tx->forced_to_abort()) {
-                tx->lock_and_abort();
-                throw aborted_transaction_exception("aborting transaction");
-            }
-
-            return tx->write(*this).val_;
-        }
-        return val_;
-    }
-
-    T value() const {
-        transaction* tx=current_transaction();
-        if (tx!=0) {
-            if (tx->forced_to_abort()) {
-                tx->lock_and_abort();
-                throw aborted_transaction_exception("aborting transaction");
-            }
-            return tx->read(*this).val_;
-        }
-        return val_;
-    }
-
+    numeric(U v) : base_type(v) {}
 };
 
 

Added: sandbox/stm/branches/vbe/boost/stm/tx/object.hpp
==============================================================================
--- (empty file)
+++ sandbox/stm/branches/vbe/boost/stm/tx/object.hpp	2009-10-23 10:56:20 EDT (Fri, 23 Oct 2009)
@@ -0,0 +1,91 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Justin E. Gottchlich 2009.
+// (C) Copyright Vicente J. Botet Escriba 2009.
+// Distributed under the Boost
+// Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/stm for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_STM_TX_OBJECT__HPP
+#define BOOST_STM_TX_OBJECT__HPP
+
+//-----------------------------------------------------------------------------
+#include <boost/stm/transaction.hpp>
+#include <boost/stm/transaction_object.hpp>
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+namespace boost { namespace stm { namespace tx {
+
+//-----------------------------------------------------------------------------
+// mixing transactional object class that wraps a object type providing
+// a transparent transactional view on a transactional context
+// a non-transactional view on a non-transactional context
+// Note: the sizeof(object<T>)>>>>=sizeof(T)
+//-----------------------------------------------------------------------------
+template <typename Final, typename T>
+class object : public transaction_object< Final >
+{
+protected:
+    T val_;
+public:
+    typedef Final final_type;
+    typedef T value_type;
+    //-----------------------------------------------------------------------------
+    object() : val_() {}
+
+    //
+    template<typename F, typename U>
+    object(object<F,U> const& r) : val_(r.value()) {}
+
+    // contructor from a convertible to T
+    template <typename U>
+    object(U v) : val_(v) {}
+    //object(T v) : val_(v) {}
+
+    #if 0
+    template<typename F, typename U>
+    object& operator=(object<F, U> const& r) {
+        val_=r.value();
+    }
+    #endif
+
+    operator T() const { return value(); }
+    operator T&() { return ref(); }
+
+    T& ref() {
+        transaction* tx=current_transaction();
+        if (tx!=0) {
+            if (tx->forced_to_abort()) {
+                tx->lock_and_abort();
+                throw aborted_transaction_exception("aborting transaction");
+            }
+
+            return tx->write(*this).val_;
+        }
+        return val_;
+    }
+
+    T value() const {
+        transaction* tx=current_transaction();
+        if (tx!=0) {
+            if (tx->forced_to_abort()) {
+                tx->lock_and_abort();
+                throw aborted_transaction_exception("aborting transaction");
+            }
+            return tx->read(*this).val_;
+        }
+        return val_;
+    }
+
+};
+
+}}}
+#endif
+
+

Modified: sandbox/stm/branches/vbe/boost/stm/tx/pointer.hpp
==============================================================================
--- sandbox/stm/branches/vbe/boost/stm/tx/pointer.hpp	(original)
+++ sandbox/stm/branches/vbe/boost/stm/tx/pointer.hpp	2009-10-23 10:56:20 EDT (Fri, 23 Oct 2009)
@@ -16,7 +16,7 @@
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
-#include <boost/stm/transaction.hpp>
+#include <boost/stm/tx/object.hpp>
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
@@ -30,64 +30,31 @@
 // Note: the sizeof(pointer<T>)>>>>=sizeof(T*)
 //-----------------------------------------------------------------------------
 template <typename T>
-class pointer : public transaction_object< pointer<T> >
+class pointer : public object< pointer<T> ,T* >
 {
-protected:
-    T* val_;
+    typedef object< pointer<T> , T* > base_type;
+    
 public:
     //-----------------------------------------------------------------------------
-    pointer() : val_(0) {}
-
-    //
+    pointer() : base_type(static_cast<T*>(0)) {}
     template<class U>
-    pointer(pointer<U> const& r) : val_(r.value()) {}
-
-    // contructor from a implicitly convertible to T
+    pointer(pointer<U> const& r) : base_type(r) {}
     template <typename U>
-    pointer(U* v) : val_(v) {}
-    pointer(T* v) : val_(v) {}
-    //
-    ~pointer() {}
-
-    operator T*() const { return get(); }
-    operator T*&() { return get(); }
-
-    T*& get() {
-        transaction* tx=current_transaction();
-        if (tx!=0) {
-            if (tx->forced_to_abort()) {
-                tx->lock_and_abort();
-                throw aborted_transaction_exception("aborting transaction");
-            }
-            return tx->write(*this).val_;
-        }
-        return val_;
-    }
-
-    T* get() const {
-        transaction* tx=current_transaction();
-        if (tx!=0) {
-            if (tx->forced_to_abort()) {
-                tx->lock_and_abort();
-                throw aborted_transaction_exception("aborting transaction");
-            }
-            return tx->read(*this).val_;
-        }
-        return val_;
-    }
+    pointer(U* v) : base_type(v) {}
+    //pointer(T* v) : base_type(v) {}
 
     T* operator->() const {
-        return this->get();
+        return this->value();
     }
     T& operator*() const {
-        return *this->get();
+        return *this->value();
     }
 
-    T * operator->() {
-        return this->get();
+    T* operator->() {
+        return this->ref();
     }
-    T & operator*() {
-        return *this->get();
+    T& operator*() {
+        return *this->ref();
     }
 
 };
@@ -95,47 +62,16 @@
 template <typename C, typename R>
 class pointer_to_member : public transaction_object< pointer_to_member<C,R> >
 {
-protected:
-    R C::* val_;
+    typedef object< pointer_to_member<C,R> ,R C::*> base_type;
 public:
     //-----------------------------------------------------------------------------
-    pointer_to_member() : val_(0) {}
-
-    //
-    pointer_to_member(pointer_to_member const& r) : val_(r.value()) {}
-
-    // contructor from a implicitly convertible to T
-    pointer_to_member(R C::* v) : val_(v) {}
-    //
-
-    operator R C::*() const { return get(); }
-    operator R C::*&() { return get(); }
-
-    R C::*& get() {
-        transaction* tx=current_transaction();
-        if (tx!=0) {
-            if (tx->forced_to_abort()) {
-                tx->lock_and_abort();
-                throw aborted_transaction_exception("aborting transaction");
-            }
-
-            return tx->write(*this).val_;
-        }
-        return val_;
-    }
-
-    R C::* const * get() const {
-        transaction* tx=current_transaction();
-        if (tx!=0) {
-            if (tx->forced_to_abort()) {
-                tx->lock_and_abort();
-                throw aborted_transaction_exception("aborting transaction");
-            }
-            return tx->read(*this).val_;
-        }
-        return val_;
-    }
+    pointer_to_member() : base_type(static_cast<R C::*>(0)) {}
 
+    template <typename D, typename S>
+    pointer_to_member(pointer_to_member<D,S> const& r) : base_type(r) {}
+    template <typename D, typename S>
+    pointer_to_member(S D::* v) : base_type(v) {}
+    //pointer_to_member(R C::* v) : base_type(v) {}
 };
 
 #if 0