Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r51325 - in sandbox/synchro/boost/synchro: . conc process thread
From: vicente.botet_at_[hidden]
Date: 2009-02-18 18:16:54


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

Log:
Replacing by DELETE macros
Text files modified:
   sandbox/synchro/boost/synchro/conc/concurrent_component.hpp | 22 +----
   sandbox/synchro/boost/synchro/lockers.hpp | 7 +
   sandbox/synchro/boost/synchro/null_synchronization_family.hpp | 7 +
   sandbox/synchro/boost/synchro/process/locks.hpp | 130 +++++++++++++++++-----------------
   sandbox/synchro/boost/synchro/process_synchronization_family.hpp | 10 +-
   sandbox/synchro/boost/synchro/semaphore.hpp | 70 ++++++++++++++----
   sandbox/synchro/boost/synchro/thread/locks.hpp | 152 ++++++++++++++++++++++-----------------
   sandbox/synchro/boost/synchro/thread_synchronization_family.hpp | 6 +
   sandbox/synchro/boost/synchro/timeout_exception.hpp | 2
   9 files changed, 233 insertions(+), 173 deletions(-)

Modified: sandbox/synchro/boost/synchro/conc/concurrent_component.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/conc/concurrent_component.hpp (original)
+++ sandbox/synchro/boost/synchro/conc/concurrent_component.hpp 2009-02-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -67,17 +67,7 @@
 };
 }
 
-//template <typename Lockable=boost::mutex>
 class concurrent_component : public concurrent_component_base {
-#if 0
- In file included from ..\example\Histogram.cpp:11:
- ../../../boost/synchro/conc/concurrent_component.hpp:32:
- error: '*' cannot appear in a constant-expression
-
- BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
-#endif
-public:
-
 protected:
 //[port
     struct port {
@@ -133,8 +123,8 @@
             p.accept(abs_time);
         }
 #endif
- semaphore accept_call_;
- semaphore until_end_;
+ binary_semaphore accept_call_;
+ binary_semaphore until_end_;
     };
     static void accept(port& p) {
 // accept_call_.common_.post(1);
@@ -179,8 +169,8 @@
             accept_call_.post();
             until_end_.wait();
         }
- semaphore accept_call_;
- semaphore until_end_;
+ binary_semaphore accept_call_;
+ binary_semaphore until_end_;
         const concurrent_component_base* sender_;
     };
     static void accept(object_port& that, const concurrent_component_base* snd) {
@@ -216,8 +206,8 @@
 // static void accept(object_port& that, const concurrent_component_base* snd) {
 // that.accept(snd);
 // }
- semaphore accept_call_;
- semaphore until_end_;
+ binary_semaphore accept_call_;
+ binary_semaphore until_end_;
 // const std::type_info* type_;
     };
     template <typename TYPE>

Modified: sandbox/synchro/boost/synchro/lockers.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers.hpp (original)
+++ sandbox/synchro/boost/synchro/lockers.hpp 2009-02-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -25,7 +25,9 @@
     {};
     struct adopt_lock_t
     {};
- struct throw_lock_t
+ struct throw_timeout_t
+ {};
+ struct nothrow_timeout_t
     {};
 
 
@@ -34,7 +36,8 @@
     const defer_lock_t defer_lock={};
     const try_to_lock_t try_to_lock={};
     const adopt_lock_t adopt_lock={};
- const throw_lock_t throw_lock={};
+ const throw_timeout_t throw_timeout={};
+ const nothrow_timeout_t nothrow_timeout={};
 
     template<typename Mutex, typename ScopeTag=typename scope_tag<Mutex>::type>
     class unique_locker;

Modified: sandbox/synchro/boost/synchro/null_synchronization_family.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/null_synchronization_family.hpp (original)
+++ sandbox/synchro/boost/synchro/null_synchronization_family.hpp 2009-02-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -13,14 +13,15 @@
 
 #include <boost/synchro/null_mutex.hpp>
 #include <boost/synchro/null_condition.hpp>
+#include <boost/synchro/synchronization_family.hpp>
 
 namespace boost {
 namespace synchro {
 
 //!Describes interprocess_mutex family to use with Sync frameworks
 //!based on null operation synchronization objects.
-struct null_synchronization_family
-{
+template <>
+struct synchronization_family<mono_threaded_tag> {
    typedef boost::synchro::null_mutex mutex_type;
    typedef boost::synchro::null_mutex recursive_mutex_type;
    typedef boost::synchro::null_mutex timed_mutex_type;
@@ -30,6 +31,8 @@
    typedef boost::synchro::null_condition condition_any_type;
 };
 
+typedef synchronization_family<mono_threaded_tag> null_synchronization_family;
+
 }
 }
 

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-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -40,18 +40,11 @@
         typedef Mutex lockable_type;
         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>&);
- public:
- //Non-copyable
- BOOST_COPY_CONSTRUCTOR_DELETE(unique_locker) /*< disable copy construction >*/
- BOOST_COPY_ASSIGNEMENT_DELETE(unique_locker) /*< disable copy asignement >*/
+
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(unique_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(unique_locker) /*< disable copy asignement >*/
         
- unique_locker(): base_type()
- {}
+ unique_locker(): base_type() {}
 
         explicit unique_locker(Mutex& m_): base_type(m_)
         {}
@@ -67,12 +60,12 @@
         unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
         {}
         template<typename TimeDuration>
- unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t)
+ unique_locker(Mutex& m_,TimeDuration const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
             lock_for(target_time);
         }
- unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t)
+ unique_locker(Mutex& m_,system_time const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
             lock_until(target_time);
@@ -216,17 +209,15 @@
     template<typename Mutex>
     class try_unique_locker<Mutex,multi_process_tag>: public unique_locker<Mutex,multi_process_tag> {
         //typename scope_tag<Mutex>::type == multi_process_tag
- private:
+ public:
         typedef Mutex lockable_type;
         typedef multi_process_tag scope_tag_type;
         typedef unique_locker<Mutex,multi_process_tag> base_type;
- try_unique_locker(try_unique_locker&);
- explicit try_unique_locker(try_unique_locker<Mutex, scope_tag_type>&);
- try_unique_locker& operator=(try_unique_locker&);
- try_unique_locker& operator=(try_unique_locker<Mutex, scope_tag_type>& other);
- public:
- try_unique_locker(): base_type()
- {}
+
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(try_unique_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(try_unique_locker) /*< disable copy asignement >*/
+
+ try_unique_locker(): base_type() {}
 
         explicit try_unique_locker(Mutex& m_): base_type(m_, boost::interprocess::defer_lock)
         {
@@ -240,33 +231,45 @@
         {}
         try_unique_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::interprocess::try_to_lock)
         {}
+
+ try_unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+ {}
         template<typename TimeDuration>
         try_unique_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, target_time)
         {}
- try_unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+
+ try_unique_locker(nothrow_timeout_t, system_time const& target_time, Mutex& m_)
+ : base_type(m_, defer_lock)
         {}
         template<typename TimeDuration>
- try_unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t)
+ try_unique_locker(nothrow_timeout_t, TimeDuration const& target_time, Mutex& m_)
             : base_type(m_, defer_lock)
- {
- this->lock_for(target_time);
- }
- try_unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t)
+ {}
+
+ try_unique_locker(Mutex& m_,system_time const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
             this->lock_until(target_time);
         }
         template<typename TimeDuration>
- try_unique_locker(TimeDuration const& target_time, Mutex& m_)
+ try_unique_locker(Mutex& m_,TimeDuration const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
             this->lock_for(target_time);
         }
+
         try_unique_locker(system_time const& target_time, Mutex& m_)
             : base_type(m_, defer_lock)
         {
             this->lock_until(target_time);
         }
+ template<typename TimeDuration>
+ try_unique_locker(TimeDuration const& target_time, Mutex& m_)
+ : base_type(m_, defer_lock)
+ {
+ this->lock_for(target_time);
+ }
+
 #ifdef BOOST_HAS_RVALUE_REFS
         try_unique_locker(try_unique_locker&& other): base_type(other)
         {}
@@ -399,12 +402,9 @@
         typedef multi_process_tag scope_tag_type;
         typedef typename shared_lock_type<Mutex>::type base_type;
 
- private:
- explicit shared_locker(shared_locker&);
- shared_locker& operator=(shared_locker&);
- public:
- shared_locker(): base_type()
- {}
+ shared_locker(): base_type() {}
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(shared_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(shared_locker) /*< disable copy asignement >*/
 
         explicit shared_locker(Mutex& m_): base_type(m_)
         {}
@@ -414,26 +414,44 @@
         {}
         shared_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::interprocess::try_to_lock)
         {}
- shared_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+
+ shared_locker(Mutex& m_,system_time const& target_time)
+ : base_type(m_, target_time)
+ {}
+ template<typename TimeDuration>
+ shared_locker(Mutex& m_,TimeDuration const& target_time)
+ : base_type(m_, boost::get_system_time()+target_time)
+ {}
+
+ shared_locker(nothrow_timeout_t, system_time const& target_time,Mutex& m_)
+ : base_type(m_, boost::interprocess::defer_lock)
         {}
         template<typename TimeDuration>
- shared_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, boost::get_system_time()+target_time)
+ shared_locker(nothrow_timeout_t, TimeDuration const& target_time,Mutex& m_)
         {}
- shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
+
+
+ shared_locker(Mutex& m_,system_time const& target_time,throw_timeout_t)
             : base_type(m_, boost::interprocess::defer_lock)
         {
             lock_until(target_time);
         }
         template<typename TimeDuration>
- shared_locker(Mutex& m_,TimeDuration const& target_time,throw_lock_t)
+ shared_locker(Mutex& m_,TimeDuration const& target_time,throw_timeout_t)
         {
             lock_for(target_time);
         }
- shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
+
+ shared_locker(system_time const& target_time,Mutex& m_)
             : base_type(m_, boost::interprocess::defer_lock)
         {
             lock_until(target_time);
         }
+ template<typename TimeDuration>
+ shared_locker(TimeDuration const& target_time,Mutex& m_)
+ {
+ lock_for(target_time);
+ }
 
 
         shared_locker(interprocess::detail::moved_object<shared_locker<Mutex, scope_tag_type> > other)
@@ -532,22 +550,6 @@
 
     };
 
-#if 0
-#ifdef BOOST_HAS_RVALUE_REFS
- template<typename Mutex, typename ScopeTag>
- void swap(shared_locker<Mutex, ScopeTag>&& lhs,shared_locker<Mutex, ScopeTag>&& rhs)
- {
- lhs.swap(rhs);
- }
-#else
- template<typename Mutex, typename ScopeTag>
- void swap(shared_locker<Mutex, ScopeTag>& lhs,shared_locker<Mutex, ScopeTag>& rhs)
- {
- lhs.swap(rhs);
- }
-#endif
-#endif
-
     template<typename Mutex>
     class upgrade_locker<Mutex,multi_process_tag>: public upgrade_lock_type<Mutex>::type {
         //typename scope_tag<Mutex>::type == multi_process_tag
@@ -555,12 +557,10 @@
         typedef Mutex lockable_type;
         typedef multi_process_tag scope_tag_type;
         typedef typename upgrade_lock_type<Mutex>::type base_type;
- private:
- explicit upgrade_locker(upgrade_locker&);
- upgrade_locker& operator=(upgrade_locker&);
- public:
- upgrade_locker(): base_type()
- {}
+
+ upgrade_locker(): base_type() {}
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(upgrade_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(upgrade_locker) /*< disable copy asignement >*/
 
         explicit upgrade_locker(Mutex& m_): base_type(m_)
         {
@@ -637,10 +637,10 @@
         typedef Mutex lockable_type;
         typedef multi_process_tag scope_tag_type;
         typedef typename upgrade_to_unique_locker_type<Mutex>::type base_type;
- private:
- explicit upgrade_to_unique_locker(upgrade_to_unique_locker&);
- upgrade_to_unique_locker& operator=(upgrade_to_unique_locker&);
- public:
+
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(upgrade_to_unique_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(upgrade_to_unique_locker) /*< disable copy asignement >*/
+
         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_synchronization_family.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process_synchronization_family.hpp (original)
+++ sandbox/synchro/boost/synchro/process_synchronization_family.hpp 2009-02-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -16,15 +16,16 @@
 #include <boost/synchro/process/upgradable_mutex.hpp>
 #include <boost/synchro/process/locks.hpp>
 #include <boost/interprocess/sync/interprocess_condition.hpp>
+#include <boost/synchro/synchronization_family.hpp>
 
 namespace boost {
 namespace synchro {
 
-
 //!Describes interprocess_mutex family to use with Sync framework
 //!based on boost::interprocess synchronization objects.
-struct process_synchronization_family
-{
+//[process_synchronization_family
+template <>
+struct synchronization_family<multi_process_tag> {
    typedef boost::synchro::interprocess_mutex mutex_type;
    typedef boost::synchro::interprocess_recursive_mutex recursive_mutex_type;
    typedef boost::synchro::interprocess_mutex timed_mutex_type;
@@ -34,7 +35,8 @@
    typedef boost::interprocess::interprocess_condition condition_any_type;
 };
 
+typedef synchronization_family<multi_process_tag> process_synchronization_family;
+//]
 }
 }
-
 #endif

Modified: sandbox/synchro/boost/synchro/semaphore.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/semaphore.hpp (original)
+++ sandbox/synchro/boost/synchro/semaphore.hpp 2009-02-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -26,9 +26,10 @@
 
 //!Wraps a semaphore that can be placed in shared memory and can be
 //!shared between processes. Allows timed lock tries
-template <typename Sync=thread_synchronization_family>
+template <typename ScopeTag=multi_threaded_tag>
 class basic_semaphore
 {
+ typedef synchronization_family<ScopeTag> Sync;
     typedef typename Sync::mutex_type lockable_type;
     typedef typename Sync::condition_type condition_variable;
     typedef typename unique_lock_type<lockable_type>::type scoped_lock;
@@ -66,29 +67,41 @@
     //!to the posted or the timeout expires. If the timeout expires, the
     //!function returns false. If the semaphore is posted the function
     //!returns true. If there is an error throws sem_exception
- inline bool wait_until(const system_time &abs_time);
+ inline bool try_wait_until(const system_time &abs_time);
+
     template<typename TimeDuration>
- inline bool wait_for(const TimeDuration &rel_time);
+ inline bool try_wait_for(const TimeDuration &rel_time) {
+ return try_wait_until(get_system_time()+rel_time);
+ }
+
+ inline void wait_until(const system_time &abs_time) {
+ if (!try_wait_until(abs_time)) throw timeout_exception();
+ }
+
+ template<typename TimeDuration>
+ inline void wait_for(const TimeDuration &rel_time) {
+ if (!try_wait_until(rel_time)) throw timeout_exception();
+ }
 
     /// @cond
-private:
+protected:
     lockable_type m_mut;
     condition_variable m_cond;
     int m_count;
     /// @endcond
 };
 
-template <typename Sync>
-inline basic_semaphore<Sync>::~basic_semaphore()
+template <typename ScopeTag>
+inline basic_semaphore<ScopeTag>::~basic_semaphore()
 {}
 
-template <typename Sync>
-inline basic_semaphore<Sync>::basic_semaphore(int initialCount)
+template <typename ScopeTag>
+inline basic_semaphore<ScopeTag>::basic_semaphore(int initialCount)
    : m_mut(), m_cond(), m_count(initialCount)
 {}
 
-template <typename Sync>
-inline void basic_semaphore<Sync>::post()
+template <typename ScopeTag>
+inline void basic_semaphore<ScopeTag>::post()
 {
    scoped_lock lock(m_mut);
    if(m_count == 0){
@@ -97,8 +110,8 @@
    ++m_count;
 }
 
-template <typename Sync>
-inline void basic_semaphore<Sync>::wait()
+template <typename ScopeTag>
+inline void basic_semaphore<ScopeTag>::wait()
 {
    scoped_lock lock(m_mut);
    while(m_count == 0){
@@ -107,8 +120,8 @@
    --m_count;
 }
 
-template <typename Sync>
-inline bool basic_semaphore<Sync>::try_wait()
+template <typename ScopeTag>
+inline bool basic_semaphore<ScopeTag>::try_wait()
 {
    scoped_lock lock(m_mut);
    if(m_count == 0){
@@ -118,8 +131,8 @@
    return true;
 }
 
-template <typename Sync>
-inline bool basic_semaphore<Sync>::wait_until(const system_time &abs_time)
+template <typename ScopeTag>
+inline bool basic_semaphore<ScopeTag>::try_wait_until(const system_time &abs_time)
 {
    scoped_lock lock(m_mut);
    while(m_count == 0){
@@ -132,6 +145,31 @@
 
 typedef basic_semaphore<> semaphore;
 
+template <typename ScopeTag=multi_threaded_tag>
+class basic_binary_semaphore: public basic_semaphore<ScopeTag>
+{
+ typedef synchronization_family<ScopeTag> Sync;
+ typedef typename Sync::mutex_type lockable_type;
+ typedef typename Sync::condition_type condition_variable;
+ typedef typename unique_lock_type<lockable_type>::type scoped_lock;
+public:
+ BOOST_COPY_CONSTRUCTOR_DELETE(basic_binary_semaphore) /*< disable copy construction >*/
+ BOOST_COPY_ASSIGNEMENT_DELETE(basic_binary_semaphore) /*< disable copy asignement >*/
+
+ //!Creates a semaphore with the given initial count.
+ //!exception if there is an error.*/
+ inline basic_binary_semaphore(int initialCount):basic_semaphore<ScopeTag>(initialCount>0?1:0) {};
+ inline void post()
+ {
+ scoped_lock lock(this->m_mut);
+ if(this->m_count == 0){
+ this->m_cond.notify_one();
+ ++(this->m_count);
+ }
+ }
+};
+typedef basic_binary_semaphore<> binary_semaphore;
+
 }
 }
 

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-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -42,20 +42,14 @@
     template<typename Mutex>
     class unique_locker<Mutex,multi_threaded_tag>: public unique_lock_type<Mutex>::type {
         //typename scope_tag<Mutex>::type == multi_threaded_tag
- private:
+ public:
         typedef Mutex lockable_type;
         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>&);
- //unique_locker& operator=(unique_locker&);
- //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()
- {}
+ unique_locker(): base_type() {}
 
         explicit unique_locker(Mutex& m_): base_type(m_)
         {}
@@ -65,22 +59,34 @@
         {}
         unique_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::try_to_lock)
         {}
+
+ unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+ {}
         template<typename TimeDuration>
         unique_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, target_time)
         {}
- unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+
+ unique_locker(nothrow_timeout_t&, system_time const& target_time, Mutex& m_)
+ : base_type(m_, target_time)
         {}
         template<typename TimeDuration>
- unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t)
+ unique_locker(nothrow_timeout_t&, TimeDuration const& target_time, Mutex& m_)
+ : base_type(m_, target_time)
+ {}
+
+ unique_locker(Mutex& m_,system_time const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
- lock_for(target_time);
+ lock_until(target_time);
         }
- unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t)
+ template<typename TimeDuration>
+ unique_locker(Mutex& m_,TimeDuration const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
- lock_until(target_time);
+ lock_for(target_time);
         }
+
+
         template<typename TimeDuration>
         unique_locker(TimeDuration const& target_time, Mutex& m_)
             : base_type(m_, defer_lock)
@@ -168,8 +174,8 @@
         {
             return static_cast<Mutex*>(this->base_type.mutex());
         }
- bool is_locking(lockable_type* l) const {
- return l==mutex();
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
         } /*< strict lockers specific function >*/
 
         template<typename TimeDuration>
@@ -197,21 +203,18 @@
         friend class shared_locker<Mutex,scope_tag_type>;
         friend class upgrade_locker<Mutex,scope_tag_type>;
     };
-
+
     template<typename Mutex>
     class try_unique_locker<Mutex,multi_threaded_tag>: public unique_locker<Mutex,multi_threaded_tag> {
         //typename scope_tag<Mutex>::type == multi_threaded_tag
- private:
+ public:
         typedef Mutex lockable_type;
         typedef multi_threaded_tag scope_tag_type;
         typedef unique_locker<Mutex,multi_threaded_tag> base_type;
- //try_unique_locker(try_unique_locker&);
- explicit try_unique_locker(try_unique_locker<Mutex, scope_tag_type>&);
- //try_unique_locker& operator=(try_unique_locker&);
- try_unique_locker& operator=(try_unique_locker<Mutex, scope_tag_type>& other);
- public:
- try_unique_locker(): base_type()
- {}
+
+ try_unique_locker(): base_type() {}
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(try_unique_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(try_unique_locker) /*< disable copy asignement >*/
 
         explicit try_unique_locker(Mutex& m_): base_type(m_, boost::defer_lock)
         { this->try_lock(); }
@@ -223,33 +226,46 @@
         {}
         try_unique_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::try_to_lock)
         {}
+
+ try_unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+ {}
         template<typename TimeDuration>
         try_unique_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, target_time)
         {}
- try_unique_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+
+ try_unique_locker(nothrow_timeout_t, system_time const& target_time, Mutex& m_)
+ : base_type(m_, target_time)
         {}
         template<typename TimeDuration>
- try_unique_locker(Mutex& m_,TimeDuration const& target_time, throw_lock_t)
- : base_type(m_, defer_lock)
- {
- this->lock_for(target_time);
- }
- try_unique_locker(Mutex& m_,system_time const& target_time, throw_lock_t)
+ try_unique_locker(nothrow_timeout_t, TimeDuration const& target_time, Mutex& m_)
+ : base_type(m_, target_time)
+ {}
+
+
+ try_unique_locker(Mutex& m_,system_time const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
             this->lock_until(target_time);
         }
         template<typename TimeDuration>
- try_unique_locker(TimeDuration const& target_time, Mutex& m_)
+ try_unique_locker(Mutex& m_,TimeDuration const& target_time, throw_timeout_t)
             : base_type(m_, defer_lock)
         {
             this->lock_for(target_time);
         }
+
         try_unique_locker(system_time const& target_time, Mutex& m_)
             : base_type(m_, defer_lock)
         {
             this->lock_until(target_time);
         }
+ template<typename TimeDuration>
+ try_unique_locker(TimeDuration const& target_time, Mutex& m_)
+ : base_type(m_, defer_lock)
+ {
+ this->lock_for(target_time);
+ }
+
 #ifdef BOOST_HAS_RVALUE_REFS
         try_unique_locker(try_unique_locker&& other): base_type(other)
         {}
@@ -325,7 +341,7 @@
         friend class shared_locker<Mutex,scope_tag_type>;
         friend class upgrade_locker<Mutex,scope_tag_type>;
     };
-
+
     template<typename Mutex>
     class shared_locker<Mutex,multi_threaded_tag>: public shared_lock_type<Mutex>::type {
         //typename scope_tag<Mutex>::type == multi_threaded_tag
@@ -334,12 +350,9 @@
         typedef multi_threaded_tag scope_tag_type;
         typedef typename shared_lock_type<Mutex>::type base_type;
 
- private:
- explicit shared_locker(shared_locker&);
- shared_locker& operator=(shared_locker&);
- public:
- shared_locker(): base_type()
- {}
+ shared_locker(): base_type() {}
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(shared_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(shared_locker) /*< disable copy asignement >*/
 
         explicit shared_locker(Mutex& m_): base_type(m_)
         {}
@@ -349,27 +362,36 @@
         {}
         shared_locker(Mutex& m_,try_to_lock_t): base_type(m_, boost::try_to_lock)
         {}
- shared_locker(Mutex& m_,system_time const& target_time): base_type(m_, target_time)
+
+ shared_locker(Mutex& m_,system_time const& target_time)
+ : base_type(m_, target_time)
         {}
         template<typename TimeDuration>
- shared_locker(Mutex& m_,TimeDuration const& target_time): base_type(m_, boost::get_system_time()+target_time)
+ shared_locker(Mutex& m_,TimeDuration const& target_time)
+ : base_type(m_, target_time)
+ {}
+
+ shared_locker(nothrow_timeout_t, system_time const& target_time, Mutex& m_)
+ : base_type(m_, target_time)
         {}
- shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
+ template<typename TimeDuration>
+ shared_locker(nothrow_timeout_t, TimeDuration const& target_time, Mutex& m_)
+ {
+ lock_for(target_time);
+ }
+
+ shared_locker(Mutex& m_,system_time const& target_time,throw_timeout_t)
             : base_type(m_, boost::defer_lock)
         {
             lock_until(target_time);
         }
         template<typename TimeDuration>
- shared_locker(Mutex& m_,TimeDuration const& target_time,throw_lock_t)
+ shared_locker(Mutex& m_,TimeDuration const& target_time,throw_timeout_t)
             : base_type(m_, boost::defer_lock)
         {
             lock_for(target_time);
         }
- shared_locker(Mutex& m_,system_time const& target_time,throw_lock_t)
- : base_type(m_, boost::defer_lock)
- {
- lock_until(target_time);
- }
+
         template<typename TimeDuration>
         shared_locker(TimeDuration const& target_time, Mutex& m_)
         {
@@ -446,10 +468,10 @@
             return static_cast<Mutex*>(this->base_type.mutex());
         }
 
- bool is_locking(lockable_type* l) const {
- return l==mutex();
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
         } /*< strict lockers specific function >*/
-
+
         bool try_lock_until(boost::system_time const& absolute_time)
         {
             return this->timed_lock(absolute_time);
@@ -495,12 +517,10 @@
         typedef Mutex lockable_type;
         typedef multi_threaded_tag scope_tag_type;
         typedef typename upgrade_lock_type<Mutex>::type base_type;
- private:
- explicit upgrade_locker(upgrade_locker&);
- upgrade_locker& operator=(upgrade_locker&);
- public:
- upgrade_locker(): base_type()
- {}
+
+ upgrade_locker(): base_type() {}
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(upgrade_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(upgrade_locker) /*< disable copy asignement >*/
 
         explicit upgrade_locker(Mutex& m_): base_type(m_)
         {
@@ -557,8 +577,8 @@
             return static_cast<Mutex*>(this->base_type.mutex());
         }
 
- bool is_locking(lockable_type* l) const {
- return l==mutex();
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
         } /*< strict lockers specific function >*/
 
         friend class shared_locker<Mutex, scope_tag_type>;
@@ -573,10 +593,10 @@
         typedef Mutex lockable_type;
         typedef multi_threaded_tag scope_tag_type;
         typedef typename upgrade_to_unique_locker_type<Mutex>::type base_type;
- private:
- explicit upgrade_to_unique_locker(upgrade_to_unique_locker&);
- upgrade_to_unique_locker& operator=(upgrade_to_unique_locker&);
- public:
+
+ BOOST_NON_CONST_COPY_CONSTRUCTOR_DELETE(upgrade_to_unique_locker) /*< disable copy construction >*/
+ BOOST_NON_CONST_COPY_ASSIGNEMENT_DELETE(upgrade_to_unique_locker) /*< disable copy asignement >*/
+
         explicit upgrade_to_unique_locker(upgrade_locker<Mutex, multi_threaded_tag>& m_): base_type(m_)
         {}
         ~upgrade_to_unique_locker()
@@ -601,8 +621,8 @@
             return static_cast<Mutex*>(this->base_type.mutex());
         }
 
- bool is_locking(lockable_type* l) const {
- return l==mutex();
+ bool is_locking(lockable_type* l) const {
+ return l==mutex();
         } /*< strict lockers specific function >*/
     };
 

Modified: sandbox/synchro/boost/synchro/thread_synchronization_family.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread_synchronization_family.hpp (original)
+++ sandbox/synchro/boost/synchro/thread_synchronization_family.hpp 2009-02-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -16,6 +16,7 @@
 #include <boost/synchro/thread/shared_mutex.hpp>
 #include <boost/synchro/thread/locks.hpp>
 #include <boost/thread/condition_variable.hpp>
+#include <boost/synchro/synchronization_family.hpp>
 
 namespace boost {
 namespace synchro {
@@ -24,8 +25,8 @@
 //!Describes thread synchronization family to use with Sync framework
 //!based on boost synchronization objects.
 //[thread_synchronization_family
-struct thread_synchronization_family
-{
+template <>
+struct synchronization_family<multi_threaded_tag> {
    typedef thread_mutex mutex_type;
    typedef thread_recursive_mutex recursive_mutex_type;
    typedef thread_timed_mutex timed_mutex_type;
@@ -35,6 +36,7 @@
    typedef boost::condition_variable_any condition_type_any;
 };
 //]
+typedef synchronization_family<multi_threaded_tag> thread_synchronization_family;
 
 
 }

Modified: sandbox/synchro/boost/synchro/timeout_exception.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/timeout_exception.hpp (original)
+++ sandbox/synchro/boost/synchro/timeout_exception.hpp 2009-02-18 18:16:52 EST (Wed, 18 Feb 2009)
@@ -21,10 +21,12 @@
         timeout_exception() : std::logic_error("timeout exception") {}
     };
 
+ #if 0
     struct throw_timeout_t {};
     struct nothrow_timeout_t {};
     const throw_timeout_t throw_timeout ={};
     const nothrow_timeout_t no_throw_timeout ={};
+ #endif
 
 }
 }


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk