[Boost-commit] svn:boost r51276 - in sandbox/synchro/boost/synchro: . detail poly process queues thread

Subject: [Boost-commit] svn:boost r51276 - in sandbox/synchro/boost/synchro: . detail poly process queues thread
From: vicente.botet_at_[hidden]
Date: 2009-02-16 16:18:40

Author: viboes
Date: 2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
New Revision: 51276
URL: http://svn.boost.org/trac/boost/changeset/51276

Log:
Boost.Synchro V0.0.0
Replacing noncopyable by DELETE macros

Text files modified: 
   sandbox/synchro/boost/synchro/condition_safe.hpp                 |     8 ++++++                                  
   sandbox/synchro/boost/synchro/detail/defaulted_functions.hpp     |     7 +++--                                   
   sandbox/synchro/boost/synchro/detail/deleted_functions.hpp       |    20 +++++++++++++++-                        
   sandbox/synchro/boost/synchro/lockable_adapter.hpp               |     5 +--                                     
   sandbox/synchro/boost/synchro/null_condition.hpp                 |    11 ++++-----                               
   sandbox/synchro/boost/synchro/null_mutex.hpp                     |     8 +++---                                  
   sandbox/synchro/boost/synchro/poly/lock_adapter.hpp              |     4 +++                                     
   sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp  |    16 -------------                           
   sandbox/synchro/boost/synchro/process/locks.hpp                  |    18 ++++++++++-----                         
   sandbox/synchro/boost/synchro/process/mutex.hpp                  |    11 ++++-----                               
   sandbox/synchro/boost/synchro/process/named_mutex.hpp            |    13 +++++------                             
   sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp  |    13 +++++------                             
   sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp |    10 +++++---                                
   sandbox/synchro/boost/synchro/process/recursive_mutex.hpp        |    10 +++-----                                
   sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp       |    11 ++++-----                               
   sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp   |     6 ++--                                    
   sandbox/synchro/boost/synchro/queues/synchro_buffer_monitor.hpp  |     3 ++                                      
   sandbox/synchro/boost/synchro/semaphore.hpp                      |     8 ++----                                  
   sandbox/synchro/boost/synchro/thread/lockable_scope_traits.hpp   |    16 -------------                           
   sandbox/synchro/boost/synchro/thread/locks.hpp                   |    14 +++++++----                             
   sandbox/synchro/boost/synchro/thread/mutex.hpp                   |    46 ++++++++++++++++++++--------------------
   sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp         |    22 ++++++++----------                      
   sandbox/synchro/boost/synchro/thread/shared_mutex.hpp            |     9 +++----                                 
   23 files changed, 144 insertions(+), 145 deletions(-)

Modified: sandbox/synchro/boost/synchro/condition_safe.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/condition_safe.hpp	(original)
+++ sandbox/synchro/boost/synchro/condition_safe.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -14,6 +14,8 @@
 #include <boost/synchro/lockable_concepts.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/synchro/thread/mutex.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
+#include <boost/synchro/detail/defaulted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -29,10 +31,16 @@
 public:
     typedef Condition condition;
     typedef condition_backdoor<Condition> backdoor;
+
+    BOOST_DEFAULT_CONSTRUCTOR_DEFAULT(condition_safe) /*< reestablish default construction >*/
+    BOOST_COPY_CONSTRUCTOR_DELETE(condition_safe) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(condition_safe) /*< disable copy asignement >*/
+
     void notify_one() { cond_.notify_one(); }
     void notify_all() { cond_.notify_all(); }
 private:
     friend class condition_backdoor<Condition>;
+    
     template <typename Locker, typename Predicate>
     void wait_when(Locker& lock, Predicate pred) {
         cond_.wait(lock, pred);

Modified: sandbox/synchro/boost/synchro/detail/defaulted_functions.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/detail/defaulted_functions.hpp	(original)
+++ sandbox/synchro/boost/synchro/detail/defaulted_functions.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -20,7 +20,7 @@
     #define BOOST_DEFAULT_CONSTRUCTOR_DEFAULT(T)        \
       T()=default;                                      \
 
-    #define BOOST_COPY_ASSIGNEMENT_DELETE(T)            \
+    #define BOOST_COPY_ASSIGNEMENT_DEFAULT(T)            \
       T& operator=(const T& rhs)=default;               \
 
 #else // !defined(BOOST_HAS_DEFAULTED_FUNCTIONS)
@@ -28,11 +28,12 @@
     #define BOOST_DEFAULT_CONSTRUCTOR_DEFAULT(T)        \
       inline T(){};                                     \
 
-    #define BOOST_COPY_ASSIGNEMENT_DELETE(T)            \
+    #define BOOST_COPY_ASSIGNEMENT_DEFAULT(T)            \
       inline T& operator=(const T& rhs) {               \
         T tmp(rhs);                                     \
         swap(tmp);\
         return this;\
       }
 
-#endif // !defined(BOOST_HAS_DEFAULTED_FUNCTIONS)
\ No newline at end of file
+#endif // !defined(BOOST_HAS_DEFAULTED_FUNCTIONS)
+#endif 

Modified: sandbox/synchro/boost/synchro/detail/deleted_functions.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/detail/deleted_functions.hpp	(original)
+++ sandbox/synchro/boost/synchro/detail/deleted_functions.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -26,8 +26,14 @@
 #define BOOST_COPY_CONSTRUCTOR_DELETE(T)            \
   T(const T&)=delete;
 
+#define BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(T)            \
+  T(T&)=delete;
+
 #define BOOST_COPY_ASSIGNEMENT_DELETE(T)            \
-  const T& operator=(const T&)=delete;
+  T& operator=(const T&)=delete;
+
+#define BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(T)            \
+  const T& operator=(T&)=delete;
 
 #define BOOST_SEQUENCE_DELETE(T)                    \
   T operator,(T)=delete;
@@ -79,9 +85,19 @@
   T(const T&);                                      \
 public:
 
+#define BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(T)            \
+private:                                            \
+  T(T&);                                            \
+public:
+
 #define BOOST_COPY_ASSIGNEMENT_DELETE(T)            \
 private:                                            \
-  const T& operator=(const T&);                     \
+  T& operator=(const T&);                     \
+public:
+
+#define BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(T)            \
+private:                                            \
+  T& operator=(T&);                           \
 public:
 
 #define BOOST_SEQUENCE_DELETE(T)                    \

Modified: sandbox/synchro/boost/synchro/lockable_adapter.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockable_adapter.hpp	(original)
+++ sandbox/synchro/boost/synchro/lockable_adapter.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -31,14 +31,13 @@
     typedef typename lifetime_tag<Lockable>::type lifetime;
     typedef typename naming_tag<Lockable>::type naming;
 
+    BOOST_COPY_CONSTRUCTOR_DELETE(exclusive_lockable_adapter) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(exclusive_lockable_adapter) /*< disable copy asignement >*/   
     exclusive_lockable_adapter() {}
     void lock() {lock_.lock();}
     void unlock() {lock_.unlock();}
     bool try_lock() { return lock_.try_lock();}
 
-    BOOST_COPY_CONSTRUCTOR_DELETE(exclusive_lockable_adapter) /*< disable copy construction >*/
-    BOOST_COPY_ASSIGNEMENT_DELETE(exclusive_lockable_adapter) /*< disable copy asignement >*/
-    
 protected:
     lockable_type* mutex() const { return &lock_; }
     mutable Lockable lock_;

Modified: sandbox/synchro/boost/synchro/null_condition.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/null_condition.hpp	(original)
+++ sandbox/synchro/boost/synchro/null_condition.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 //!Describes null_mutex class
 #include <boost/synchro/null_mutex.hpp>
 #include <boost/thread/thread_time.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost {
 
@@ -23,13 +24,11 @@
 
 class null_condition
 {
-private:
-   /// @cond
+public:
    //Non-copyable
-   null_condition(const null_condition &);
-   null_condition &operator=(const null_condition &);
-   /// @endcond
-   public:
+    BOOST_COPY_CONSTRUCTOR_DELETE(null_condition) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(null_condition) /*< disable copy asignement >*/
+
    //!Constructs a null_condition. On error throws interprocess_exception.
    null_condition(){}
 

Modified: sandbox/synchro/boost/synchro/null_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/null_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/null_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -14,6 +14,7 @@
 
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/thread/thread_time.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 //!\file
 //!Describes null_mutex classes
@@ -35,14 +36,13 @@
     has_timed_interface_tag, void
 >
 {
-   /// @cond
-   null_mutex(const null_mutex&);
-   null_mutex &operator= (const null_mutex&);
-   /// @endcond
 public:
     typedef null_condition best_condition_type;
     typedef null_condition best_condition_any_type;
 
+    BOOST_COPY_CONSTRUCTOR_DELETE(null_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(null_mutex) /*< disable copy asignement >*/
+
    //!Constructor.
    //!Empty.
    null_mutex(){}

Modified: sandbox/synchro/boost/synchro/poly/lock_adapter.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/poly/lock_adapter.hpp	(original)
+++ sandbox/synchro/boost/synchro/poly/lock_adapter.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -12,6 +12,8 @@
 #define BOOST_SYNCHRO_POLY_LOCK_ADAPTER__HPP
 
 #include <boost/synchro/poly/lock.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
+
 namespace boost { namespace synchro { namespace poly {
 
 //////////////////////////////////////////////////////////////////////////////
@@ -28,6 +30,8 @@
     typedef typename lifetime_tag<Lockable>::type lifetime;
     typedef typename naming_tag<Lockable>::type naming;
 
+    BOOST_COPY_CONSTRUCTOR_DELETE(exclusive_lock_adapter) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(exclusive_lock_adapter) /*< disable copy asignement >*/
     exclusive_lock_adapter(): lock_() {}
     ~exclusive_lock_adapter() {}
 

Modified: sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -51,22 +51,6 @@
     typedef boost::interprocess::upgradable_lock<lockable_type> upgrade_lock;
 
 };
-//template<typename Lockable>
-//lockable_scope_traits<multi_process_tag, Lockable>::defer_lock_t
-////boost::interprocess::detail::defer_lock_type
-//lockable_scope_traits<multi_process_tag, Lockable>::defer_lock ={};
-////(lockable_scope_traits<multi_process_tag, Lockable>::defer_lock_type());
-//
-//template<typename Lockable>
-//const lockable_scope_traits<multi_process_tag, Lockable>::adopt_lock_t
-//lockable_scope_traits<multi_process_tag, Lockable>::adopt_lock
-//={};
-//
-//template<typename Lockable>
-//const lockable_scope_traits<multi_process_tag, Lockable>::try_to_lock_t
-//lockable_scope_traits<multi_process_tag, Lockable>::try_to_lock
-//={};
-
 
 }
 }

Modified: sandbox/synchro/boost/synchro/process/locks.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/locks.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/locks.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/interprocess/sync/sharable_lock.hpp>
 #include <boost/interprocess/sync/upgradable_lock.hpp>
 #include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -40,10 +41,15 @@
         typedef multi_process_tag scope_tag_type;
         typedef typename unique_lock_type<Mutex>::type base_type;
         unique_locker(unique_locker&);
-        explicit unique_locker(unique_locker<Mutex, scope_tag_type>&);
-        unique_locker& operator=(unique_locker&);
-        unique_locker& operator=(unique_locker<Mutex, scope_tag_type>& other);
+    
+        //explicit unique_locker(unique_locker<Mutex, scope_tag_type>&);
+        //unique_locker& operator=(unique_locker&);
+        //unique_locker& operator=(unique_locker<Mutex, scope_tag_type>&);
     public:
+        //Non-copyable
+        BOOST_COPY_CONSTRUCTOR_DELETE(unique_locker) /*< disable copy construction >*/
+        BOOST_COPY_ASSIGNEMENT_DELETE(unique_locker) /*< disable copy asignement >*/
+        
         unique_locker(): base_type()
         {}
 
@@ -101,7 +107,7 @@
             return *this;
         }
 
-        unique_locker& operator=(upgrade_locker<Mutex>&& other)
+        unique_locker& operator=(upgrade_locker<Mutex, multi_process_tag>&& other)
         {
             unique_locker temp(other);
             swap(temp);
@@ -280,7 +286,7 @@
             return *this;
         }
 
-        try_unique_locker& operator=(upgrade_locker<Mutex>&& other)
+        try_unique_locker& operator=(upgrade_locker<Mutex, multi_process_tag>&& other)
         {
             try_unique_locker temp(other);
             swap(temp);
@@ -635,7 +641,7 @@
         explicit upgrade_to_unique_locker(upgrade_to_unique_locker&);
         upgrade_to_unique_locker& operator=(upgrade_to_unique_locker&);
     public:
-        explicit upgrade_to_unique_locker(upgrade_locker<Mutex>& m_): base_type(m_)
+        explicit upgrade_to_unique_locker(upgrade_locker<Mutex, multi_process_tag>& m_): base_type(m_)
         {}
         ~upgrade_to_unique_locker()
         {}

Modified: sandbox/synchro/boost/synchro/process/mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -16,6 +16,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -30,16 +31,14 @@
     boost::interprocess::interprocess_mutex
 >
 {
-
-    //Non-copyable
-    interprocess_mutex(const interprocess_mutex &);
-    interprocess_mutex &operator=(const interprocess_mutex &);
-
 public:
-
     typedef boost::interprocess::interprocess_condition  best_condition_type;
     typedef boost::interprocess::interprocess_condition  best_condition_any_type;
 
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(interprocess_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(interprocess_mutex) /*< disable copy asignement >*/
+
     bool try_lock_until(system_time const & abs_time)
     {return timed_lock(abs_time);}
     template<typename TimeDuration>

Modified: sandbox/synchro/boost/synchro/process/named_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/named_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/named_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 class named_mutex
@@ -28,17 +29,15 @@
     named_tag
 >
 {
-
-    //Non-copyable
-    named_mutex(const named_mutex &);
-    named_mutex &operator=(const named_mutex &);
-    named_mutex();
-
 public:
-
     typedef boost::interprocess::interprocess_condition  best_condition_type;
     typedef boost::interprocess::interprocess_condition  best_condition_any_type;
 
+    BOOST_DEFAULT_CONSTRUCTOR_DELETE(named_mutex) /*< disable default construction >*/
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(named_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(named_mutex) /*< disable copy asignement >*/
+
     named_mutex(interprocess::create_only_t create_only, const char *name)
        : interprocess::named_mutex(create_only, name) {};
        named_mutex(interprocess::open_or_create_t open_or_create, const char *name)

Modified: sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 class named_recursive_mutex
@@ -28,17 +29,15 @@
     named_tag
 >
 {
-
-    //Non-copyable
-    named_recursive_mutex(const named_recursive_mutex &);
-    named_recursive_mutex &operator=(const named_recursive_mutex &);
-    named_recursive_mutex();
-
 public:
-
     typedef boost::interprocess::interprocess_condition  best_condition_type;
     typedef boost::interprocess::interprocess_condition  best_condition_any_type;
 
+    BOOST_DEFAULT_CONSTRUCTOR_DELETE(named_recursive_mutex) /*< disable default construction >*/
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(named_recursive_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(named_recursive_mutex) /*< disable copy asignement >*/
+
     named_recursive_mutex(interprocess::create_only_t create_only, const char *name)
            : interprocess::named_recursive_mutex(create_only, name) {};
        named_recursive_mutex(interprocess::open_or_create_t open_or_create, const char *name)

Modified: sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -29,14 +30,15 @@
         named_tag
     >     
 {
-   //Non-copyable
-    interprocess_named_upgradable_mutex(const interprocess_upgradable_mutex &);
-    interprocess_named_upgradable_mutex &operator=(const interprocess_named_upgradable_mutex &);
-    interprocess_named_upgradable_mutex();
 public:
     typedef boost::interprocess::interprocess_condition  condition_type;
     typedef boost::interprocess::interprocess_condition  condition_any_type;
 
+    BOOST_DEFAULT_CONSTRUCTOR_DELETE(interprocess_named_upgradable_mutex) /*< disable default construction >*/
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(interprocess_named_upgradable_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(interprocess_named_upgradable_mutex) /*< disable copy asignement >*/
+
     interprocess_named_upgradable_mutex(interprocess::create_only_t create_only, const char *name)
            : interprocess::named_upgradable_mutex(create_only, name) {};
        interprocess_named_upgradable_mutex(interprocess::open_or_create_t open_or_create, const char *name)

Modified: sandbox/synchro/boost/synchro/process/recursive_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/recursive_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/recursive_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -29,16 +30,13 @@
     boost::interprocess::interprocess_recursive_mutex
 >
 {
-
-    //Non-copyable
-    interprocess_recursive_mutex(const interprocess_recursive_mutex &);
-    interprocess_recursive_mutex &operator=(const interprocess_recursive_mutex &);
-
 public:
-
     typedef boost::interprocess::interprocess_condition  best_condition_type;
     typedef boost::interprocess::interprocess_condition  best_condition_any_type;
 
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(interprocess_recursive_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(interprocess_recursive_mutex) /*< disable copy asignement >*/
     interprocess_recursive_mutex(){}
         
     bool try_lock_until(system_time const & abs_time)

Modified: sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -29,16 +30,14 @@
     interprocess::interprocess_upgradable_mutex
 >
 {
-
-    //Non-copyable
-    interprocess_upgradable_mutex(const interprocess_upgradable_mutex &);
-    interprocess_upgradable_mutex &operator=(const interprocess_upgradable_mutex &);
-
 public:
-
     typedef boost::interprocess::interprocess_condition  condition_type;
     typedef boost::interprocess::interprocess_condition  condition_any_type;
 
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(interprocess_upgradable_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(interprocess_upgradable_mutex) /*< disable copy asignement >*/
+
     bool try_lock_until(system_time const & abs_time)
     {return timed_lock(abs_time);}
     template<typename TimeDuration>

Modified: sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp	(original)
+++ sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -11,11 +11,9 @@
 #ifndef BOOST_SYNCHRO_QUEUES_SYNCHRO_BUFFER__HPP
 #define BOOST_SYNCHRO_QUEUES_SYNCHRO_BUFFER__HPP
 
-//#include <boost/thread/locks.hpp>
-//#include <boost/thread/mutex.hpp>
-//#include <boost/thread/condition_variable.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/lockers.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 #if 0
@@ -81,6 +79,8 @@
     unsigned in_, out_;
 
 public:
+    BOOST_COPY_CONSTRUCTOR_DELETE(sync_buffer) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(sync_buffer) /*< disable copy asignement >*/
     sync_buffer():in_(0), out_(0) {}
 
     bool full() { return out_==(in_+1)%(size+1); }

Modified: sandbox/synchro/boost/synchro/queues/synchro_buffer_monitor.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/queues/synchro_buffer_monitor.hpp	(original)
+++ sandbox/synchro/boost/synchro/queues/synchro_buffer_monitor.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -12,6 +12,7 @@
 #define BOOST_SYNCHRO_CONC_BUFFER__HPP
 
 #include <boost/synchro/monitor.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -58,6 +59,8 @@
         sync_buffer &that_;
     };
 public:
+    BOOST_COPY_CONSTRUCTOR_DELETE(sync_buffer) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(sync_buffer) /*< disable copy asignement >*/
     sync_buffer():in_(0), out_(0) {}
 
     bool full() { return out_==(in_+1)%(size+1); }

Modified: sandbox/synchro/boost/synchro/semaphore.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/semaphore.hpp	(original)
+++ sandbox/synchro/boost/synchro/semaphore.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 
 #include <boost/synchro/thread_synchronization_family.hpp>
 #include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 //!\file
 //!Describes a semaphore class for inter-process synchronization
@@ -33,12 +34,9 @@
     typedef typename unique_lock_type<lockable_type>::type scoped_lock;
     typedef basic_semaphore this_type;
 
-    /// @cond
-    //Non-copyable
-    basic_semaphore(const this_type &);
-    this_type& operator=(const this_type &);
-    /// @endcond
 public:
+    BOOST_COPY_CONSTRUCTOR_DELETE(basic_semaphore) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(basic_semaphore) /*< disable copy asignement >*/
 
     //!Creates a semaphore with the given initial count.
     //!exception if there is an error.*/

Modified: sandbox/synchro/boost/synchro/thread/lockable_scope_traits.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/lockable_scope_traits.hpp	(original)
+++ sandbox/synchro/boost/synchro/thread/lockable_scope_traits.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -33,24 +33,8 @@
     static const defer_lock_t& defer_lock() {return boost::defer_lock;}
     static const adopt_lock_t& adopt_lock() {return boost::adopt_lock;}
     static const try_to_lock_t& try_to_lock() {return boost::try_to_lock;}
-
-#if 0
-    static const defer_lock_t defer_lock;
-    static const adopt_lock_t adopt_lock;
-    static const try_to_lock_t try_to_lock;
-#endif
-
 };
 
-#if 0
-template<>
-const boost::defer_lock_t lockable_scope_traits<multi_threaded_tag>::defer_lock={};
-template<typename Lockable>
-const boost::adopt_lock_t lockable_scope_traits<multi_threaded_tag>::adopt_lock={};
-template<typename Lockable>
-const boost::try_to_lock_t lockable_scope_traits<multi_threaded_tag>::try_to_lock={};
-#endif
-
 template<typename Lockable>
 struct lockable_scope_traits<multi_threaded_tag, Lockable> : scope_traits<multi_threaded_tag>
 {

Modified: sandbox/synchro/boost/synchro/thread/locks.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/locks.hpp	(original)
+++ sandbox/synchro/boost/synchro/thread/locks.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/thread/locks.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/lockers.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 
 namespace boost { namespace synchro {
@@ -46,10 +47,13 @@
         typedef multi_threaded_tag scope_tag_type;
         typedef typename unique_lock_type<Mutex>::type base_type;
         //unique_locker(unique_locker&);
-        explicit unique_locker(unique_locker<Mutex, scope_tag_type>&);
+        //explicit unique_locker(unique_locker<Mutex, scope_tag_type>&);
         //unique_locker& operator=(unique_locker&);
-        unique_locker& operator=(unique_locker<Mutex, scope_tag_type>& other);
+        //unique_locker& operator=(unique_locker<Mutex, scope_tag_type>& other);
+    
     public:
+        BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(unique_locker) /*< disable copy construction >*/
+        BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(unique_locker) /*< disable copy asignement >*/
         unique_locker(): base_type()
         {}
 
@@ -107,7 +111,7 @@
             return *this;
         }
 
-        unique_locker& operator=(upgrade_locker<Mutex>&& other)
+        unique_locker& operator=(upgrade_locker<Mutex, multi_threaded_tag>&& other)
         {
             unique_locker temp(other);
             swap(temp);
@@ -265,7 +269,7 @@
             return *this;
         }
 
-        try_unique_locker& operator=(upgrade_locker<Mutex>&& other)
+        try_unique_locker& operator=(upgrade_locker<Mutex, multi_threaded_tag>&& other)
         {
             try_unique_locker temp(other);
             swap(temp);
@@ -573,7 +577,7 @@
         explicit upgrade_to_unique_locker(upgrade_to_unique_locker&);
         upgrade_to_unique_locker& operator=(upgrade_to_unique_locker&);
     public:
-        explicit upgrade_to_unique_locker(upgrade_locker<Mutex>& m_): base_type(m_)
+        explicit upgrade_to_unique_locker(upgrade_locker<Mutex, multi_threaded_tag>& m_): base_type(m_)
         {}
         ~upgrade_to_unique_locker()
         {}

Modified: sandbox/synchro/boost/synchro/thread/mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/thread/mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -18,6 +18,7 @@
 #include <boost/thread/thread_time.hpp>
 #include <boost/synchro/thread/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 
 namespace boost { namespace synchro {
@@ -33,15 +34,15 @@
     mutex
 >
 {
-
-    //Non-copyable
-    thread_mutex(const thread_mutex &);
-    thread_mutex &operator=(const thread_mutex &);
-
 public:
+    // public types
     typedef boost::condition_variable  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
 
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(thread_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(thread_mutex) /*< disable copy asignement >*/
+
     thread_mutex() {}
 };
 
@@ -123,32 +124,31 @@
     process_lifetime_tag,
     anonymous_tag,
     timed_mutex
->
-{
-
-    //Non-copyable
-    thread_timed_mutex(const thread_mutex &);
-    thread_timed_mutex &operator=(const thread_mutex &);
-
+> {
 public:
-    
     typedef boost::condition_variable_any  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
 
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(thread_timed_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(thread_timed_mutex) /*< disable copy asignement >*/
     thread_timed_mutex () {}
         
-    bool try_lock_until(system_time const & abs_time)
-    {return timed_lock(abs_time);}
+    bool try_lock_until(system_time const & abs_time) {
+        return timed_lock(abs_time);
+    }
     template<typename TimeDuration>
-    bool try_lock_for(TimeDuration const & relative_time)
-    {return timed_lock(relative_time);}
-
-    void lock_until(system_time const & abs_time)
-    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    bool try_lock_for(TimeDuration const & relative_time) {
+        return timed_lock(relative_time);
+    }
+
+    void lock_until(system_time const & abs_time) {
+        if(!timed_lock(abs_time)) throw timeout_exception();
+    }
     template<typename TimeDuration>
-    void lock_for(TimeDuration const & relative_time)
-    {if(!timed_lock(relative_time)) throw timeout_exception();}
-    
+    void lock_for(TimeDuration const & relative_time) {
+        if(!timed_lock(relative_time)) throw timeout_exception();
+    }
 };    
 
 #if 0

Modified: sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -16,6 +16,7 @@
 #include <boost/synchro/thread/lockable_scope_traits.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
 
@@ -31,15 +32,13 @@
     recursive_mutex
 >
 {
-
-    //Non-copyable
-    thread_recursive_mutex(const thread_recursive_mutex &);
-    thread_recursive_mutex &operator=(const thread_recursive_mutex &);
-
 public:
-
     typedef boost::condition_variable_any  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
+
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(thread_recursive_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(thread_recursive_mutex) /*< disable copy asignement >*/
     thread_recursive_mutex() {}
 };    
 #if 0    
@@ -98,16 +97,15 @@
 >
 {
 
-    //Non-copyable
-    thread_recursive_timed_mutex(const thread_recursive_timed_mutex &);
-    thread_recursive_timed_mutex &operator=(const thread_recursive_timed_mutex &);
-
 public:
-    thread_recursive_timed_mutex() {}
-        
     typedef boost::condition_variable_any  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
 
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(thread_recursive_timed_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(thread_recursive_timed_mutex) /*< disable copy asignement >*/
+    thread_recursive_timed_mutex() {}
+
     bool try_lock_until(system_time const & abs_time)
     {return this->timed_lock(abs_time);}
     template<typename TimeDuration>

Modified: sandbox/synchro/boost/synchro/thread/shared_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/shared_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/thread/shared_mutex.hpp	2009-02-16 16:18:38 EST (Mon, 16 Feb 2009)
@@ -16,6 +16,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/thread/lockable_scope_traits.hpp>
 #include <boost/synchro/timeout_exception.hpp>
+#include <boost/synchro/detail/deleted_functions.hpp>
 
 namespace boost { namespace synchro {
     
@@ -30,15 +31,13 @@
     shared_mutex
 >
 {
-
-    //Non-copyable
-    thread_shared_mutex(const thread_shared_mutex &);
-    thread_shared_mutex &operator=(const thread_shared_mutex &);
-
 public:
     typedef boost::condition_variable_any  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
 
+    //Non-copyable
+    BOOST_COPY_CONSTRUCTOR_DELETE(thread_shared_mutex) /*< disable copy construction >*/
+    BOOST_COPY_ASSIGNEMENT_DELETE(thread_shared_mutex) /*< disable copy asignement >*/
     thread_shared_mutex() {}
 
     bool try_lock_until(system_time const & abs_time)