Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r51244 - in sandbox/synchro/boost/synchro: . dsl iccl lockers process queues thread
From: vicente.botet_at_[hidden]
Date: 2009-02-14 07:34:27


Author: viboes
Date: 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
New Revision: 51244
URL: http://svn.boost.org/trac/boost/changeset/51244

Log:
Boost.Synchro V0.0.0
Text files modified:
   sandbox/synchro/boost/synchro/condition_backdoor.hpp | 18 ++++++++--------
   sandbox/synchro/boost/synchro/condition_safe.hpp | 18 ++++++++--------
   sandbox/synchro/boost/synchro/dsl/thread_model.hpp | 12 +++++-----
   sandbox/synchro/boost/synchro/iccl/thread_locking_traits.hpp | 26 +++++++++++-----------
   sandbox/synchro/boost/synchro/lockers/externally_locked.hpp | 8 +++---
   sandbox/synchro/boost/synchro/lockers/nested_reverse_locker.hpp | 22 ++++++++++----------
   sandbox/synchro/boost/synchro/lockers/on_dereference_locking_ptr.hpp | 6 ++--
   sandbox/synchro/boost/synchro/lockers/reverse_lock.hpp | 18 ++++++++--------
   sandbox/synchro/boost/synchro/lockers/reverse_locker.hpp | 4 +-
   sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp | 16 +++++++-------
   sandbox/synchro/boost/synchro/process/locks.hpp | 6 ++--
   sandbox/synchro/boost/synchro/process/mutex.hpp | 16 +++++++-------
   sandbox/synchro/boost/synchro/process/named_mutex.hpp | 30 +++++++++++++-------------
   sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp | 28 ++++++++++++------------
   sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp | 44 ++++++++++++++++++++--------------------
   sandbox/synchro/boost/synchro/process/recursive_mutex.hpp | 16 +++++++-------
   sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp | 20 +++++++++---------
   sandbox/synchro/boost/synchro/queues/synchro_buffer_family.hpp | 24 ++++++++++----------
   sandbox/synchro/boost/synchro/thread/lockable_scope_traits.hpp | 14 ++++++------
   sandbox/synchro/boost/synchro/thread/locks.hpp | 6 ++--
   sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp | 32 ++++++++++++++--------------
   sandbox/synchro/boost/synchro/thread/shared_mutex.hpp | 16 +++++++-------
   22 files changed, 200 insertions(+), 200 deletions(-)

Modified: sandbox/synchro/boost/synchro/condition_backdoor.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/condition_backdoor.hpp (original)
+++ sandbox/synchro/boost/synchro/condition_backdoor.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -22,39 +22,39 @@
     class Condition
>
 struct condition_backdoor {
- condition_backdoor(condition_safe<Condition>&cnd): that_(cnd) {}
+ condition_backdoor(condition_safe<Condition>&cnd): that_(cnd) {}
     template <typename Locker, typename Predicate>
     void wait_when(Locker& lock, Predicate pred){
- that_.wait_when(lock, pred);
+ that_.wait_when(lock, pred);
     }
     template <typename Locker>
     void wait(Locker& lock) {
- that_.wait(lock);
+ that_.wait(lock);
     }
     template <typename Locker>
     bool wait_until(Locker& lock, boost::system_time const& abs_time) {
- return that_.wait_until(lock, abs_time);
+ return that_.wait_until(lock, abs_time);
     }
 
     template<typename Locker, typename duration_type>
     bool wait_for(Locker& lock, duration_type const& rel_time) {
- return that_.wait_for(lock, rel_time);
+ return that_.wait_for(lock, rel_time);
     }
 
     template<typename Locker, typename predicate_type>
     bool wait_when_until(Locker& lock, predicate_type pred, boost::system_time const& abs_time) {
- return that_.timed_wait(lock, pred, abs_time);
+ return that_.timed_wait(lock, pred, abs_time);
     }
     template <typename Locker>
     void notify_one(Locker& lock) {
- that_.notify_one(lock);
+ that_.notify_one(lock);
     }
     template <typename Locker>
     void notify_all(Locker& lock) {
- that_.notify_all(lock);
+ that_.notify_all(lock);
     }
 private:
- condition_safe<Condition>& that_;
+ condition_safe<Condition>& that_;
 };
 
 }

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -27,42 +27,42 @@
>
 class condition_safe {
 public:
- typedef Condition condition;
- typedef condition_backdoor<Condition> backdoor;
+ typedef Condition condition;
+ typedef condition_backdoor<Condition> backdoor;
     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);
+ cond_.wait(lock, pred);
     }
     template <typename Locker>
     void wait(Locker& lock) {
- cond_.wait(lock);
+ cond_.wait(lock);
     }
 
     template <typename Locker>
     bool wait_until(Locker& lock, boost::system_time const& abs_time) {
- return cond_.timed_wait(lock);;
+ return cond_.timed_wait(lock);;
     }
 
     template<typename Locker, typename duration_type>
     bool wait_for(Locker& lock,duration_type const& rel_time) {
- return cond_.timed_wait(lock);
+ return cond_.timed_wait(lock);
     }
 
 // template<typename Locker, typename predicate_type>
 // bool wait_when(Locker& lock, predicate_type pred) {
-// return cond_.wait(lock, pred);
+// return cond_.wait(lock, pred);
 // }
     template<typename Locker, typename predicate_type>
     bool wait_when_until(Locker& lock, predicate_type pred, boost::system_time const& abs_time) {
- return cond_.timed_wait(lock, pred, abs_time);
+ return cond_.timed_wait(lock, pred, abs_time);
     }
     template<typename Locker, typename duration_type, typename predicate_type>
     bool wait_when_for(Locker& lock, predicate_type pred, duration_type const& rel_time) {
- return cond_.timed_wait(lock, pred, rel_time);
+ return cond_.timed_wait(lock, pred, rel_time);
     }
 private:
     Condition cond_;

Modified: sandbox/synchro/boost/synchro/dsl/thread_model.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/dsl/thread_model.hpp (original)
+++ sandbox/synchro/boost/synchro/dsl/thread_model.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -26,38 +26,38 @@
 // LockingStrategy
 template <typename LockingTraits=parameter::void_>
 struct externally_locked {
- typedef LockingTraits locking_traits;
+ typedef LockingTraits locking_traits;
 };
 BOOST_DETAIL_IS_XXX_DEF(externally_locked, externally_locked, 1)
 
 template <typename LockingTraits=parameter::void_>
 struct internally_locked {
- typedef LockingTraits locking_traits;
+ typedef LockingTraits locking_traits;
 };
 BOOST_DETAIL_IS_XXX_DEF(internally_locked, internally_locked, 1)
 
 template <typename LockingTraits=parameter::void_>
 struct no_locking {
- typedef LockingTraits locking_traits;
+ typedef LockingTraits locking_traits;
 };
 BOOST_DETAIL_IS_XXX_DEF(no_locking, no_locking, 1)
 
 
 template <typename LockingStrategy=no_locking<iccl::null_locking_traits> >
 struct mono_threaded {
- typedef LockingStrategy locking_strategy;
+ typedef LockingStrategy locking_strategy;
 };
 BOOST_DETAIL_IS_XXX_DEF(mono_threaded, mono_threaded, 1)
 
 template <typename LockingStrategy=internally_locked<iccl::thread_locking_traits> >
 struct multi_threaded {
- typedef LockingStrategy locking_strategy;
+ typedef LockingStrategy locking_strategy;
 };
 BOOST_DETAIL_IS_XXX_DEF(multi_threaded, multi_threaded, 1)
 
 template <typename LockingStrategy=internally_locked<iccl::process_locking_traits> >
 struct multi_process {
- typedef LockingStrategy locking_strategy;
+ typedef LockingStrategy locking_strategy;
 };
 BOOST_DETAIL_IS_XXX_DEF(multi_process, multi_process, 1)
 

Modified: sandbox/synchro/boost/synchro/iccl/thread_locking_traits.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/iccl/thread_locking_traits.hpp (original)
+++ sandbox/synchro/boost/synchro/iccl/thread_locking_traits.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -19,30 +19,30 @@
 
 namespace detail {
 struct null_tag{
- template <typename T> null_tag(T&) {}
+ template <typename T> null_tag(T&) {}
 };
 
 }
 struct null_locking_traits {
- typedef detail::null_tag mutex_type;
- typedef detail::null_tag scoped_lock;
- static const int try_to_lock() {return 0;}
+ typedef detail::null_tag mutex_type;
+ typedef detail::null_tag scoped_lock;
+ static const int try_to_lock() {return 0;}
 };
 
 
 struct thread_locking_traits {
- typedef boost::mutex mutex_type;
- typedef boost::mutex::scoped_lock scoped_lock;
- static const boost::try_to_lock_t try_to_lock() {return boost::try_to_lock;}
+ typedef boost::mutex mutex_type;
+ typedef boost::mutex::scoped_lock scoped_lock;
+ static const boost::try_to_lock_t try_to_lock() {return boost::try_to_lock;}
 };
 
 struct process_locking_traits {
- typedef boost::interprocess::interprocess_mutex mutex_type;
- typedef boost::interprocess::scoped_lock<mutex_type> scoped_lock;
- static boost::interprocess::detail::try_to_lock_type try_to_lock()
- {
- return boost::interprocess::try_to_lock;
- }
+ typedef boost::interprocess::interprocess_mutex mutex_type;
+ typedef boost::interprocess::scoped_lock<mutex_type> scoped_lock;
+ static boost::interprocess::detail::try_to_lock_type try_to_lock()
+ {
+ return boost::interprocess::try_to_lock;
+ }
 };
 
 

Modified: sandbox/synchro/boost/synchro/lockers/externally_locked.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers/externally_locked.hpp (original)
+++ sandbox/synchro/boost/synchro/lockers/externally_locked.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -33,7 +33,7 @@
 class externally_locked {
     BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
 
-// /*<-*/ typedef boost::lock_error lock_error; /*->*/
+// /*<-*/ typedef boost::lock_error lock_error; /*->*/
     typedef typename syntactic_lock_traits<Lockable>::lock_error lock_error; /*< needed until Boost Thread and Interprocess unify the exceptions >*/
 public:
     externally_locked(T& obj, Lockable& lockable)
@@ -66,8 +66,8 @@
 //[externally_locked_any
 template <typename T, typename Lockable>
 class externally_locked_any {
- /*<-*/ typedef typename syntactic_lock_traits<Lockable>::lock_error lock_error; /*->*/
-// /*<-*/ typedef boost::lock_error lock_error; /*->*/
+ /*<-*/ typedef typename syntactic_lock_traits<Lockable>::lock_error lock_error; /*->*/
+// /*<-*/ typedef boost::lock_error lock_error; /*->*/
 public:
 /*<-*/ externally_locked_any(T& obj, Lockable& lockable)
         : obj_(obj)
@@ -85,7 +85,7 @@
 
         BOOST_STATIC_ASSERT((is_strict_locker<Locker>::value)); /*< locker is a strict locker "sur parolle" >*/
         BOOST_STATIC_ASSERT((is_same<Lockable,
- typename lockable_type<Locker>::type>::value)); /*< that locks the same type >*/
+ typename lockable_type<Locker>::type>::value)); /*< that locks the same type >*/
 #ifndef BOOST_SYNCHRO_EXTERNALLY_LOCKED_DONT_CHECK_OWNERSHIP /*< define BOOST_SYNCHRO_EXTERNALLY_LOCKED_NO_CHECK_OWNERSHIP if you don't want to check locker ownership >*/
         if (! locker ) throw lock_error(); /*< run time check throw if no locked >*/
 #endif

Modified: sandbox/synchro/boost/synchro/lockers/nested_reverse_locker.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers/nested_reverse_locker.hpp (original)
+++ sandbox/synchro/boost/synchro/lockers/nested_reverse_locker.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -24,8 +24,8 @@
  * unique_lock<mutex> lock(smtx);
  * // ... some read operations
  * { // non locked block
- * nested_reverse_locker<unique_lock<mutex> > rlock(lock);
- * // ... some code not needing
+ * nested_reverse_locker<unique_lock<mutex> > rlock(lock);
+ * // ... some code not needing
  * } // locked again
  * // ...
  */
@@ -49,22 +49,22 @@
         }
 #endif
         if (tmp_locker_) { /*< ensures it is unlocked >*/
- tmp_locker_.unlock();
- was_locked_=true;
+ tmp_locker_.unlock();
+ was_locked_=true;
         }
     }
     ~nested_reverse_locker() {
- if (was_locked_) {
- tmp_locker_.lock();
- }
+ if (was_locked_) {
+ tmp_locker_.lock();
+ }
         locker_=tmp_locker_.move(); /*< Move ownership to nesting locker >*/
     }
 
 protected:
- Locker& locker_;
- Locker tmp_locker_;
- bool was_locked_;
- nested_reverse_locker();
+ Locker& locker_;
+ Locker tmp_locker_;
+ bool was_locked_;
+ nested_reverse_locker();
 };
 
 }

Modified: sandbox/synchro/boost/synchro/lockers/on_dereference_locking_ptr.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers/on_dereference_locking_ptr.hpp (original)
+++ sandbox/synchro/boost/synchro/lockers/on_dereference_locking_ptr.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -80,8 +80,8 @@
       return target_;
     }
   private:
- Lockable *target_;
- bool locked_;
+ Lockable *target_;
+ bool locked_;
   };
 
   explicit on_dereference_locking_ptr(Lockable &target)
@@ -93,7 +93,7 @@
     return pointer(target);
   }
 private:
- Lockable *target;
+ Lockable *target;
 };
 
 

Modified: sandbox/synchro/boost/synchro/lockers/reverse_lock.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers/reverse_lock.hpp (original)
+++ sandbox/synchro/boost/synchro/lockers/reverse_lock.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -26,8 +26,8 @@
  * shared_lock<mutex> lock(smtx);
  * // ... some read operations
  * { // non locked block
- * reverse_lock<shared_lock<mutex> > rlock(lock);
- * // ... some code not needing
+ * reverse_lock<shared_lock<mutex> > rlock(lock);
+ * // ... some code not needing
  * } // locked again
  * // ...
  */
@@ -37,7 +37,7 @@
 template <typename SharableMutex>
 class exclusive_lockable_adapter
 {
- exclusive_lockable_adapter(SharableMutex& mtx): mtx_(mtx) {}
+ exclusive_lockable_adapter(SharableMutex& mtx): mtx_(mtx) {}
     ~exclusive_lockable_adapter() {}
     void lock()
     {mtx_.lock_shared();}
@@ -47,23 +47,23 @@
     { return mtx_.try_lock_shared();}
 
 protected:
- SharableMutex& mtx_;
+ SharableMutex& mtx_;
 };
 
 
 /*
  * template <class Lockable>
  * void f(Lokable&l) const {
- * boos::shared_lock<Lokable> lock(smtx);
+ * boos::shared_lock<Lokable> lock(smtx);
  * // ... some read operations
  * }
  * // elsewhere
- * boost::mutex mtx;
+ * boost::mutex mtx;
  * //
  * {
- * shared_lockable_adapter smtx(mtx);
- * f(smtx);
- * //..
+ * shared_lockable_adapter smtx(mtx);
+ * f(smtx);
+ * //..
  * }
  *
  */

Modified: sandbox/synchro/boost/synchro/lockers/reverse_locker.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers/reverse_locker.hpp (original)
+++ sandbox/synchro/boost/synchro/lockers/reverse_locker.hpp 2009-02-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -26,8 +26,8 @@
  * mutex mtx;
  * // ... some read operations
  * { // non locked block
- * reverse_locker<boost::mutex> > rlock(mutex);
- * // ... some code not needing
+ * reverse_locker<boost::mutex> > rlock(mutex);
+ * // ... some code not needing
  * } // locked again
  * // ...
  */

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -36,19 +36,19 @@
     typedef boost::interprocess::try_to_lock_type try_to_lock_t;
 
 
- static const defer_lock_t& defer_lock() {return boost::interprocess::defer_lock;}
- static const adopt_lock_t& adopt_lock() {return boost::interprocess::accept_ownership;}
- static const try_to_lock_t& try_to_lock() {return boost::interprocess::try_to_lock;}
+ static const defer_lock_t& defer_lock() {return boost::interprocess::defer_lock;}
+ static const adopt_lock_t& adopt_lock() {return boost::interprocess::accept_ownership;}
+ static const try_to_lock_t& try_to_lock() {return boost::interprocess::try_to_lock;}
 
 };
 template<typename Lockable>
 struct lockable_scope_traits<multi_process_tag, Lockable> : scope_traits<multi_process_tag>
 {
- typedef Lockable lockable_type;
- typedef boost::interprocess::scoped_lock<lockable_type> scoped_lock;
- typedef boost::interprocess::scoped_lock<lockable_type> unique_lock;
- typedef boost::interprocess::sharable_lock<lockable_type> shared_lock;
- typedef boost::interprocess::upgradable_lock<lockable_type> upgrade_lock;
+ typedef Lockable lockable_type;
+ typedef boost::interprocess::scoped_lock<lockable_type> scoped_lock;
+ typedef boost::interprocess::scoped_lock<lockable_type> unique_lock;
+ typedef boost::interprocess::sharable_lock<lockable_type> shared_lock;
+ typedef boost::interprocess::upgradable_lock<lockable_type> upgrade_lock;
 
 };
 //template<typename Lockable>

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -21,15 +21,15 @@
 
 template <typename T>
 struct lockable_type<boost::interprocess::scoped_lock<T> > {
- typedef T type;
+ typedef T type;
 };
 template <typename T>
 struct lockable_type<boost::interprocess::sharable_lock<T> > {
- typedef T type;
+ typedef T type;
 };
 template <typename T>
 struct lockable_type<boost::interprocess::upgradable_lock<T> > {
- typedef T type;
+ typedef T type;
 };
 
 }

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -61,39 +61,39 @@
 
 template<>
 struct timed_interface_tag<boost::interprocess::interprocess_mutex> {
- typedef has_timed_interface_tag type;
+ typedef has_timed_interface_tag type;
 };
 template<>
 struct reentrancy_tag<boost::interprocess::interprocess_mutex> {
- typedef non_recursive_tag type;
+ typedef non_recursive_tag type;
 };
 template<>
 struct category_tag<boost::interprocess::interprocess_mutex> {
- typedef exclusive_lock_tag type;
+ typedef exclusive_lock_tag type;
 };
 template<>
 struct scope_tag<boost::interprocess::interprocess_mutex> {
- typedef multi_process_tag type;
+ typedef multi_process_tag type;
 };
 
 template<>
 struct lifetime_tag<boost::interprocess::interprocess_mutex> {
- typedef kernel_lifetime_tag type;
+ typedef kernel_lifetime_tag type;
 };
 
 template<>
 struct naming_tag<boost::interprocess::interprocess_mutex> {
- typedef anonymous_tag type;
+ typedef anonymous_tag type;
 };
 
 template <>
 struct best_condition<boost::interprocess::interprocess_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 template <>
 struct best_condition_any<boost::interprocess::interprocess_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 #endif

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -32,19 +32,19 @@
     //Non-copyable
     named_mutex(const named_mutex &);
     named_mutex &operator=(const named_mutex &);
- named_mutex();
+ named_mutex();
 
 public:
 
     typedef boost::interprocess::interprocess_condition best_condition_type;
     typedef boost::interprocess::interprocess_condition best_condition_any_type;
 
- 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)
- : interprocess::named_mutex(open_or_create, name) {};
- named_mutex(interprocess::open_only_t open_only, const char *name)
- : interprocess::named_mutex(open_only, name) {};
+ 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)
+ : interprocess::named_mutex(open_or_create, name) {};
+ named_mutex(interprocess::open_only_t open_only, const char *name)
+ : interprocess::named_mutex(open_only, name) {};
 
     bool try_lock_until(system_time const & abs_time)
     {return this->timed_lock(abs_time);}
@@ -63,39 +63,39 @@
 
 template<>
 struct timed_interface_tag<boost::interprocess::named_mutex> {
- typedef has_timed_interface_tag type;
+ typedef has_timed_interface_tag type;
 };
 template<>
 struct reentrancy_tag<boost::interprocess::named_mutex> {
- typedef non_recursive_tag type;
+ typedef non_recursive_tag type;
 };
 template<>
 struct category_tag<boost::interprocess::named_mutex> {
- typedef exclusive_lock_tag type;
+ typedef exclusive_lock_tag type;
 };
 template<>
 struct scope_tag<boost::interprocess::named_mutex> {
- typedef multi_process_tag type;
+ typedef multi_process_tag type;
 };
 
 template<>
 struct lifetime_tag<boost::interprocess::named_mutex> {
- typedef kernel_lifetime_tag type;
+ typedef kernel_lifetime_tag type;
 };
 
 template<>
 struct naming_tag<boost::interprocess::named_mutex> {
- typedef named_tag type;
+ typedef named_tag type;
 };
 
 template <>
 struct best_condition<boost::interprocess::named_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 template <>
 struct best_condition_any<boost::interprocess::named_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -39,12 +39,12 @@
     typedef boost::interprocess::interprocess_condition best_condition_type;
     typedef boost::interprocess::interprocess_condition best_condition_any_type;
 
- 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)
- : interprocess::named_recursive_mutex(open_or_create, name) {};
- named_recursive_mutex(interprocess::open_only_t open_only, const char *name)
- : interprocess::named_recursive_mutex(open_only, name) {};
+ 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)
+ : interprocess::named_recursive_mutex(open_or_create, name) {};
+ named_recursive_mutex(interprocess::open_only_t open_only, const char *name)
+ : interprocess::named_recursive_mutex(open_only, name) {};
 
     bool try_lock_until(system_time const & abs_time)
     {return this->timed_lock(abs_time);}
@@ -64,39 +64,39 @@
 
 template<>
 struct timed_interface_tag<boost::interprocess::named_recursive_mutex> {
- typedef has_timed_interface_tag type;
+ typedef has_timed_interface_tag type;
 };
 template<>
 struct reentrancy_tag<boost::interprocess::named_recursive_mutex> {
- typedef recursive_tag type;
+ typedef recursive_tag type;
 };
 template<>
 struct category_tag<boost::interprocess::named_recursive_mutex> {
- typedef exclusive_lock_tag type;
+ typedef exclusive_lock_tag type;
 };
 template<>
 struct scope_tag<boost::interprocess::named_recursive_mutex> {
- typedef multi_process_tag type;
+ typedef multi_process_tag type;
 };
 
 template<>
 struct lifetime_tag<boost::interprocess::named_recursive_mutex> {
- typedef kernel_lifetime_tag type;
+ typedef kernel_lifetime_tag type;
 };
 
 template<>
 struct naming_tag<boost::interprocess::named_recursive_mutex> {
- typedef anonymous_tag type;
+ typedef anonymous_tag type;
 };
 
 template <>
 struct best_condition<boost::interprocess::named_recursive_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 template <>
 struct best_condition_any<boost::interprocess::named_recursive_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 #endif

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -19,30 +19,30 @@
 namespace boost { namespace synchro {
 
 class interprocess_named_upgradable_mutex
- : public interprocess::named_upgradable_mutex,
+ : public interprocess::named_upgradable_mutex,
       public lock_traits_base<
- multi_process_tag,
- upgradable_lock_tag,
- non_recursive_tag,
- has_timed_interface_tag,
+ multi_process_tag,
+ upgradable_lock_tag,
+ non_recursive_tag,
+ has_timed_interface_tag,
         kernel_lifetime_tag,
         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();
+ 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;
+ typedef boost::interprocess::interprocess_condition condition_type;
+ typedef boost::interprocess::interprocess_condition condition_any_type;
 #if 1
- 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)
- : interprocess::named_upgradable_mutex(open_or_create, name) {};
- interprocess_named_upgradable_mutex(interprocess::open_only_t open_only, const char *name)
- : interprocess::named_upgradable_mutex(open_only, name) {};
+ 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)
+ : interprocess::named_upgradable_mutex(open_or_create, name) {};
+ interprocess_named_upgradable_mutex(interprocess::open_only_t open_only, const char *name)
+ : interprocess::named_upgradable_mutex(open_only, name) {};
 #endif
     bool try_lock_until(system_time const & abs_time)
     {return timed_lock(abs_time);}
@@ -116,25 +116,25 @@
 
 //template<>
 //struct timed_interface_tag<boost::synchro::named_upgradable_mutex> {
-// typedef has_timed_interface_tag type;
+// typedef has_timed_interface_tag type;
 //};
 //template<>
 //struct reentrancy_tag<boost::synchro::named_upgradable_mutex> {
-// typedef non_recursive_tag type;
+// typedef non_recursive_tag type;
 //};
 //template<>
 //struct category_tag<boost::synchro::named_upgradable_mutex> {
-// typedef upgradable_lock_tag type;
+// typedef upgradable_lock_tag type;
 //};
 //template<>
 //struct scope_tag<boost::synchro::named_upgradable_mutex> {
-// typedef multi_process_tag type;
+// typedef multi_process_tag type;
 //};
 
 #if 0
 template<>
 struct syntactic_lock_traits<boost::synchro::named_upgradable_mutex>
- : syntactic_process_lock_traits<boost::synchro::named_upgradable_mutex> {};
+ : syntactic_process_lock_traits<boost::synchro::named_upgradable_mutex> {};
 #endif
 
 }

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -62,40 +62,40 @@
 
 template<>
 struct timed_interface_tag<boost::interprocess::interprocess_recursive_mutex> {
- typedef has_timed_interface_tag type;
+ typedef has_timed_interface_tag type;
 };
 template<>
 struct reentrancy_tag<boost::interprocess::interprocess_recursive_mutex> {
- typedef recursive_tag type;
+ typedef recursive_tag type;
 };
 template<>
 struct category_tag<boost::interprocess::interprocess_recursive_mutex> {
- typedef exclusive_lock_tag type;
+ typedef exclusive_lock_tag type;
 };
 template<>
 struct scope_tag<boost::interprocess::interprocess_recursive_mutex> {
- typedef multi_process_tag type;
+ typedef multi_process_tag type;
 };
 
 template<>
 struct lifetime_tag<boost::interprocess::interprocess_recursive_mutex> {
- typedef kernel_lifetime_tag type;
+ typedef kernel_lifetime_tag type;
 };
 
 template<>
 struct naming_tag<boost::interprocess::interprocess_recursive_mutex> {
- typedef anonymous_tag type;
+ typedef anonymous_tag type;
 };
 
 
 template <>
 struct best_condition<boost::interprocess::interprocess_recursive_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 template <>
 struct best_condition_any<boost::interprocess::interprocess_recursive_mutex> {
- typedef boost::interprocess::interprocess_condition type;
+ typedef boost::interprocess::interprocess_condition type;
 };
 
 #endif

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -20,13 +20,13 @@
 
 class interprocess_upgradable_mutex
 : public lock_traits_base<
- multi_process_tag,
- upgradable_lock_tag,
- non_recursive_tag,
- has_timed_interface_tag,
+ multi_process_tag,
+ upgradable_lock_tag,
+ non_recursive_tag,
+ has_timed_interface_tag,
     kernel_lifetime_tag,
     anonymous_tag,
- interprocess::interprocess_upgradable_mutex
+ interprocess::interprocess_upgradable_mutex
>
 {
 
@@ -108,25 +108,25 @@
 
 //template<>
 //struct timed_interface_tag<boost::synchro::interprocess_upgradable_mutex> {
-// typedef has_timed_interface_tag type;
+// typedef has_timed_interface_tag type;
 //};
 //template<>
 //struct reentrancy_tag<boost::synchro::interprocess_upgradable_mutex> {
-// typedef non_recursive_tag type;
+// typedef non_recursive_tag type;
 //};
 //template<>
 //struct category_tag<boost::synchro::interprocess_upgradable_mutex> {
-// typedef upgradable_lock_tag type;
+// typedef upgradable_lock_tag type;
 //};
 //template<>
 //struct scope_tag<boost::synchro::interprocess_upgradable_mutex> {
-// typedef multi_process_tag type;
+// typedef multi_process_tag type;
 //};
 
 #if 0
 template<>
 struct syntactic_lock_traits<boost::synchro::interprocess_upgradable_mutex>
- : syntactic_process_lock_traits<boost::synchro::interprocess_upgradable_mutex> {};
+ : syntactic_process_lock_traits<boost::synchro::interprocess_upgradable_mutex> {};
 #endif
 }
 }

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -22,12 +22,12 @@
 template <typename T, unsigned size>
 class sync_buffer
 {
- typedef boost::mutex mutex_type;
- typedef boost::condition_variable condition_type;
- typedef boost::unique_lock<mutex_type> unique_lock_type;
- mutex_type mtx_;
- condition_type not_full_;
- condition_type not_empty_;
+ typedef boost::mutex mutex_type;
+ typedef boost::condition_variable condition_type;
+ typedef boost::unique_lock<mutex_type> unique_lock_type;
+ mutex_type mtx_;
+ condition_type not_full_;
+ condition_type not_empty_;
 
     T data_[size+1];
     unsigned in_, out_;
@@ -68,12 +68,12 @@
 template <typename T, unsigned size, typename Sync>
 class sync_buffer
 {
- typedef typename Sync::mutex_type mutex_type;
- typedef typename Sync::condition_type condition_type;
- typedef typename unique_lock_type<mutex_type>::type unique_lock_type;
- mutex_type mtx_;
- condition_type not_full_;
- condition_type not_empty_;
+ typedef typename Sync::mutex_type mutex_type;
+ typedef typename Sync::condition_type condition_type;
+ typedef typename unique_lock_type<mutex_type>::type unique_lock_type;
+ mutex_type mtx_;
+ condition_type not_full_;
+ condition_type not_empty_;
 
     T data_[size+1];
     unsigned in_, out_;

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -21,10 +21,10 @@
 template<>
 struct scope_traits<multi_threaded_tag>
 {
- typedef boost::lock_error lock_error;
+ typedef boost::lock_error lock_error;
     template <typename T>
     struct moved_object : boost::detail::thread_move_t<T> {
- moved_object(T& t_): boost::detail::thread_move_t<T>(t_) {}
+ moved_object(T& t_): boost::detail::thread_move_t<T>(t_) {}
     };
     typedef boost::defer_lock_t defer_lock_t;
     typedef boost::adopt_lock_t adopt_lock_t;
@@ -54,11 +54,11 @@
 template<typename Lockable>
 struct lockable_scope_traits<multi_threaded_tag, Lockable> : scope_traits<multi_threaded_tag>
 {
- typedef Lockable lockable_type;
- typedef boost::unique_lock<lockable_type> scoped_lock;
- typedef boost::unique_lock<lockable_type> unique_lock;
- typedef boost::shared_lock<lockable_type> shared_lock;
- typedef boost::upgrade_lock<lockable_type> upgrade_lock;
+ typedef Lockable lockable_type;
+ typedef boost::unique_lock<lockable_type> scoped_lock;
+ typedef boost::unique_lock<lockable_type> unique_lock;
+ typedef boost::shared_lock<lockable_type> shared_lock;
+ typedef boost::upgrade_lock<lockable_type> upgrade_lock;
 
 
 };

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -19,15 +19,15 @@
 
 template <typename T>
 struct lockable_type<boost::unique_lock<T> > {
- typedef T type;
+ typedef T type;
 };
 template <typename T>
 struct lockable_type<boost::shared_lock<T> > {
- typedef T type;
+ typedef T type;
 };
 template <typename T>
 struct lockable_type<boost::upgrade_lock<T> > {
- typedef T type;
+ typedef T type;
 };
 
 

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -47,41 +47,41 @@
 
 template<>
 struct timed_interface_tag<boost::recursive_mutex> {
- typedef hasnt_timed_interface_tag type;
+ typedef hasnt_timed_interface_tag type;
 };
 
 template<>
 struct reentrancy_tag<boost::recursive_mutex> {
- typedef recursive_tag type;
+ typedef recursive_tag type;
 };
 
 template<>
 struct category_tag<boost::recursive_mutex> {
- typedef exclusive_lock_tag type;
+ typedef exclusive_lock_tag type;
 };
 
 template<>
 struct scope_tag<boost::recursive_mutex> {
- typedef multi_threaded_tag type;
+ typedef multi_threaded_tag type;
 };
 
 template<>
 struct lifetime_tag<boost::recursive_mutex> {
- typedef process_lifetime_tag type;
+ typedef process_lifetime_tag type;
 };
 
 template<>
 struct naming_tag<boost::recursive_mutex> {
- typedef anonymous_tag type;
+ typedef anonymous_tag type;
 };
 
 template <>
 struct best_condition<boost::recursive_mutex> {
- typedef boost::condition_variable_any type;
+ typedef boost::condition_variable_any type;
 };
 template <>
 struct best_condition_any<boost::recursive_mutex> {
- typedef boost::condition_variable_any type;
+ typedef boost::condition_variable_any type;
 };
 #endif
 
@@ -127,38 +127,38 @@
 
 template<>
 struct timed_interface_tag<boost::recursive_timed_mutex> {
- typedef has_timed_interface_tag type;
+ typedef has_timed_interface_tag type;
 };
 template<>
 struct reentrancy_tag<boost::recursive_timed_mutex> {
- typedef recursive_tag type;
+ typedef recursive_tag type;
 };
 template<>
 struct category_tag<boost::recursive_timed_mutex> {
- typedef exclusive_lock_tag type;
+ typedef exclusive_lock_tag type;
 };
 template<>
 struct scope_tag<boost::recursive_timed_mutex> {
- typedef multi_threaded_tag type;
+ typedef multi_threaded_tag type;
 };
 
 template<>
 struct lifetime_tag<boost::recursive_timed_mutex> {
- typedef process_lifetime_tag type;
+ typedef process_lifetime_tag type;
 };
 
 template<>
 struct naming_tag<boost::recursive_timed_mutex> {
- typedef anonymous_tag type;
+ typedef anonymous_tag type;
 };
 
 template <>
 struct best_condition<boost::recursive_timed_mutex> {
- typedef boost::condition_variable_any type;
+ typedef boost::condition_variable_any type;
 };
 template <>
 struct best_condition_any<boost::recursive_timed_mutex> {
- typedef boost::condition_variable_any type;
+ typedef boost::condition_variable_any type;
 };
 
 #endif

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-14 07:34:24 EST (Sat, 14 Feb 2009)
@@ -67,39 +67,39 @@
 
 template<>
 struct timed_interface_tag<boost::shared_mutex> {
- typedef has_timed_interface_tag type;
+ typedef has_timed_interface_tag type;
 };
 template<>
 struct reentrancy_tag<boost::shared_mutex> {
- typedef non_recursive_tag type;
+ typedef non_recursive_tag type;
 };
 template<>
 struct category_tag<boost::shared_mutex> {
- typedef upgradable_lock_tag type;
+ typedef upgradable_lock_tag type;
 };
 template<>
 struct scope_tag<boost::shared_mutex> {
- typedef multi_threaded_tag type;
+ typedef multi_threaded_tag type;
 };
 
 template<>
 struct lifetime_tag<boost::shared_mutex> {
- typedef process_lifetime_tag type;
+ typedef process_lifetime_tag type;
 };
 
 template<>
 struct naming_tag<boost::shared_mutex> {
- typedef anonymous_tag type;
+ typedef anonymous_tag type;
 };
 
 template <>
 struct best_condition<boost::shared_mutex> {
- typedef boost::condition_variable_any type;
+ typedef boost::condition_variable_any type;
 };
 
 template <>
 struct best_condition_any<boost::shared_mutex> {
- typedef boost::condition_variable_any type;
+ typedef boost::condition_variable_any type;
 };
 #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