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
}