[Boost-commit] svn:boost r51243 - in sandbox/synchro/boost/synchro: . lockers process thread

Subject: [Boost-commit] svn:boost r51243 - in sandbox/synchro/boost/synchro: . lockers process thread
From: vicente.botet_at_[hidden]
Date: 2009-02-14 03:53:14

Author: viboes
Date: 2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
New Revision: 51243
URL: http://svn.boost.org/trac/boost/changeset/51243

Log:
Boost.Synchro V0.0.0
Adding timeout exceptions
Added:
   sandbox/synchro/boost/synchro/condition_lockable.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/timeout_exception.hpp   (contents, props changed)
Text files modified: 
   sandbox/synchro/boost/synchro/lockable_adapter.hpp               |    21 +++++++++--                             
   sandbox/synchro/boost/synchro/lockers/strict_locker.hpp          |     2                                         
   sandbox/synchro/boost/synchro/process/mutex.hpp                  |     7 +++                                     
   sandbox/synchro/boost/synchro/process/named_mutex.hpp            |     8 +++                                     
   sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp  |     7 +++                                     
   sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp |    15 +++++++-                                
   sandbox/synchro/boost/synchro/process/recursive_mutex.hpp        |     7 +++                                     
   sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp       |    71 +++++++++++++++++++++++---------------- 
   sandbox/synchro/boost/synchro/thread/mutex.hpp                   |    17 ++++++---                               
   sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp         |    18 +++++-----                              
   sandbox/synchro/boost/synchro/thread/shared_mutex.hpp            |     9 +++++                                   
   11 files changed, 127 insertions(+), 55 deletions(-)

Added: sandbox/synchro/boost/synchro/condition_lockable.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/condition_lockable.hpp	2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
@@ -0,0 +1,97 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/synchro for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHRO_CONDITION_LOCKABLE__HPP
+#define BOOST_SYNCHRO_CONDITION_LOCKABLE__HPP
+
+#include <boost/synchro/lockable_concepts.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/interprocess/interprocess_condition.hpp>
+#include <boost/synchro/thread/mutex.hpp>
+#include <boost/synchro/condition_backdoor.hpp>
+#include <boost/synchro/condition_safe.hpp>
+#include <boost/synchro/timeout_exception.hpp>
+
+namespace boost { namespace synchro {
+
+//[condition_lockable
+template <
+    typename Lockable=thread_mutex,
+    class Condition=condition_safe<typename best_condition<Lockable>::type >
+>
+class condition_lockable;
+
+template <typename Lockable, class Condition >
+class condition_lockable : public Lockable {
+    BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>));
+public:
+    typedef Lockable lockable_type;
+    typedef Condition condition;
+
+    condition_lockable() {}
+    ~condition_lockable() {}
+  
+    template<typename Predicate>
+    void lock_when(condition &cond, Predicate pred){
+        typename condition::backdoor(cond).wait_when(*this, pred);
+    }
+    template<typename Predicate>
+    void lock_when_until(condition &cond, Predicate pred,
+            boost::system_time const& abs_time){
+        typename condition::backdoor(cond).wait_when_until(*this, pred, abs_time);
+    }
+    template<typename Predicate, typename duration_type>
+    void lock_when_for(condition &cond, Predicate pred,
+            duration_type const& rel_time){
+        typename condition::backdoor(cond).wait_when_for(*this, pred, rel_time);
+    }
+        
+    void relock_on(condition & cond) {
+        typename condition::backdoor(cond).wait(*this);
+    }
+    void relock_on_until(condition & cond, boost::system_time const& abs_time) {
+           typename condition::backdoor(cond).wait_until(*this, abs_time);
+    }
+    template<typename duration_type>
+    void relock_on_for(condition & cond, duration_type const& rel_time) {
+        typename condition::backdoor(cond).wait_for(*this, rel_time);
+    }
+
+    template<typename Predicate>
+    void relock_when(condition &cond, Predicate pred){
+        typename condition::backdoor(cond).wait_when(*this, pred);
+    }
+    template<typename Predicate>
+    void relock_when_until(condition &cond, Predicate pred,
+            boost::system_time const& abs_time){
+        typename condition::backdoor(cond).wait_when_until(*this, pred, abs_time);
+    }
+    template<typename Predicate, typename duration_type>
+    void relock_when_for(condition &cond, Predicate pred,
+            duration_type const& rel_time){
+        typename condition::backdoor(cond).wait_when_for(*this, pred, rel_time);
+    }
+
+
+private:
+    //friend typename best_condition<Lockable>::type;
+    //friend typename best_condition_any<Lockable>::type;
+    friend class boost::condition_variable;
+    friend class boost::condition_variable_any;
+    friend class boost::interprocess::condition;
+};
+//]
+
+typedef condition_lockable<> thread_condition_mutex;
+typedef condition_lockable<interprocess_mutex> interprocess_condition_mutex;
+
+}
+}
+#endif

Modified: sandbox/synchro/boost/synchro/lockable_adapter.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockable_adapter.hpp	(original)
+++ sandbox/synchro/boost/synchro/lockable_adapter.hpp	2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
@@ -12,6 +12,7 @@
 #define BOOST_SYNCHRO_LOCKABLE_ADAPTER__HPP
 
 #include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/thread/thread_time.hpp>
 
@@ -55,6 +56,13 @@
     template<typename TimeDuration>
     bool try_lock_for(TimeDuration const & relative_time)
     {return the_lock().try_lock_for(relative_time);}
+    
+    void lock_until(system_time const & abs_time)
+    {the_lock().lock_until(abs_time);}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {return the_lock().lock_for(relative_time);}
+    
 protected:
     TimedLock& the_lock() {return *static_cast<TimedLock*>(&this->lock_);}
 };
@@ -78,10 +86,13 @@
     {the_lock().unlock_shared();}
     bool try_lock_shared_until(system_time const& t)
     {return the_lock().try_lock_shared_until(t);}
+    void lock_shared_until(system_time const& t)
+    {the_lock().lock_shared_until(t);}
 
 protected:
     SharableLock& the_lock() {return *static_cast<SharableLock*>(&this->lock_);}
 };
+
 //]
 
 //[upgrade_lockable_adapter
@@ -97,11 +108,9 @@
     void lock_upgrade()
     {the_lock().lock_upgrade();}
 
-   bool try_lock_upgrade()
-   {  return the_lock().try_lock_upgrade(); }
+    bool try_lock_upgrade()
+    {  return the_lock().try_lock_upgrade(); }
 
-    
-    
     void unlock_upgrade()
     {the_lock().unlock_upgrade();}
 
@@ -115,6 +124,8 @@
     {the_lock().unlock_upgrade_and_lock_shared();}
     bool try_lock_upgrade_until(system_time const&t)
     {return the_lock().try_lock_upgrade_until(t);}
+    void lock_upgrade_until(system_time const&t)
+    {the_lock().lock_upgrade_until(t);}
 
 protected:
     UpgradableLock& the_lock() {return *static_cast<UpgradableLock*>(&this->lock_);}
@@ -124,7 +135,7 @@
 
 //[lockable_adapter
 template <
-      typename Lockable
+        typename Lockable
       , typename category=typename category_tag<Lockable>::type
       , typename timed_interface=typename timed_interface_tag<Lockable>::type
 > struct lockable_adapter;

Modified: sandbox/synchro/boost/synchro/lockers/strict_locker.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/lockers/strict_locker.hpp	(original)
+++ sandbox/synchro/boost/synchro/lockers/strict_locker.hpp	2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
@@ -72,7 +72,7 @@
     operator bool_type() const;
     bool operator!() const;
     bool owns_lock() const;
-    lockable_type* mutex() const;
+    bool is_locking(lockable_type* l) const; /*< strict locker specific function >*/
 
     BOOST_ADRESS_OF_DELETE(strict_locker)
     BOOST_HEAP_ALLOCATION_DELETE()

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 03:53:13 EST (Sat, 14 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/interprocess/sync/interprocess_condition.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
 
@@ -44,6 +45,12 @@
     template<typename TimeDuration>
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
+
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
     
     //bool try_lock_shared_until(system_time const& abs_time)
     //{return timed_lock_shared(abs_time);}

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 03:53:13 EST (Sat, 14 Feb 2009)
@@ -14,6 +14,7 @@
 #include <boost/interprocess/sync/named_mutex.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
 class named_mutex
@@ -50,7 +51,12 @@
     template<typename TimeDuration>
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
-    
+
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}    
 };    
 #if 0
 typedef boost::interprocess::named_mutex named_mutex;

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 03:53:13 EST (Sat, 14 Feb 2009)
@@ -14,6 +14,7 @@
 #include <boost/interprocess/sync/named_recursive_mutex.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
 class named_recursive_mutex
@@ -51,7 +52,11 @@
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
    
-
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
 };    
 
 #if 0

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 03:53:13 EST (Sat, 14 Feb 2009)
@@ -14,6 +14,7 @@
 #include <boost/interprocess/sync/named_upgradable_mutex.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
 
@@ -48,7 +49,13 @@
     template<typename TimeDuration>
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
-        
+
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
+    
     void lock_shared()
     {lock_sharable();}
 
@@ -57,6 +64,8 @@
 
     bool try_lock_shared_until(const boost::posix_time::ptime &abs_time)
     {return timed_lock_sharable(abs_time);}
+    void lock_shared_until(const boost::posix_time::ptime &abs_time)
+    {if(!timed_lock_sharable(abs_time)) throw timeout_exception();}
 
     void unlock_shared()
     {unlock_sharable();}
@@ -67,8 +76,10 @@
     bool try_lock_upgrade()
     {return try_lock_upgradable();}
 
-    bool tru_lock_upgrade_until(const boost::posix_time::ptime &abs_time)
+    bool try_lock_upgrade_until(const boost::posix_time::ptime &abs_time)
     {return timed_lock_upgradable(abs_time);}
+    void lock_upgrade_until(const boost::posix_time::ptime &abs_time)
+    {if(!timed_lock_upgradable(abs_time)) throw timeout_exception();}
 
     void unlock_upgrade()
     {unlock_upgradable();}

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 03:53:13 EST (Sat, 14 Feb 2009)
@@ -14,6 +14,7 @@
 #include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
 
@@ -45,6 +46,12 @@
     template<typename TimeDuration>
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
+
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
     
     //bool try_lock_shared_until(system_time const& abs_time)
     //{return timed_lock_shared(abs_time);}

Modified: sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp	2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
@@ -14,6 +14,7 @@
 #include <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/process/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
 
@@ -44,53 +45,63 @@
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
 
+    void try_lock_until(throw_timeout_t&, system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void try_lock_for(throw_timeout_t&, TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
+    
     void lock_shared()
     {lock_sharable();}
 
-   bool try_lock_shared()
-   {return try_lock_sharable();}
+    bool try_lock_shared()
+    {return try_lock_sharable();}
 
-   bool try_lock_shared_until(const boost::posix_time::ptime &abs_time)
-   {return timed_lock_sharable(abs_time);}
+    bool try_lock_shared_until(const boost::posix_time::ptime &abs_time)
+    {return timed_lock_sharable(abs_time);}
+    void try_lock_shared_until(throw_timeout_t&, const boost::posix_time::ptime &abs_time)
+    {if(!timed_lock_sharable(abs_time)) throw timeout_exception();}
 
-   void unlock_shared()
-   {unlock_sharable();}
+    void unlock_shared()
+    {unlock_sharable();}
 
-   void lock_upgrade()
-   {lock_upgradable();}
+    void lock_upgrade()
+    {lock_upgradable();}
 
-   bool try_lock_upgrade()
-   {return try_lock_upgradable();}
+    bool try_lock_upgrade()
+    {return try_lock_upgradable();}
 
-   bool try_lock_upgrade_until(const boost::posix_time::ptime &abs_time)
-   {return timed_lock_upgradable(abs_time);}
+    bool try_lock_upgrade_until(const boost::posix_time::ptime &abs_time)
+    {return timed_lock_upgradable(abs_time);}
+    void tru_lock_upgrade_until(throw_timeout_t&, const boost::posix_time::ptime &abs_time)
+    {if(!timed_lock_upgradable(abs_time)) throw timeout_exception();}
 
-   void unlock_upgrade()
-   {unlock_upgradable();}
+    void unlock_upgrade()
+    {unlock_upgradable();}
 
-   void unlock_and_lock_upgrade()
-   {unlock_and_lock_upgrade();}
+    void unlock_and_lock_upgrade()
+    {unlock_and_lock_upgrade();}
 
-   void unlock_and_lock_shared()
-   {unlock_and_lock_sharable();}
+    void unlock_and_lock_shared()
+    {unlock_and_lock_sharable();}
 
-   void unlock_upgrade_and_lock_shared()
-   {unlock_upgradable_and_lock_sharable();}
+    void unlock_upgrade_and_lock_shared()
+    {unlock_upgradable_and_lock_sharable();}
 
-   void unlock_upgrade_and_lock()
-   {unlock_upgrade_and_lock();}
+    void unlock_upgrade_and_lock()
+    {unlock_upgrade_and_lock();}
 
-   bool try_unlock_upgrade_and_lock()
-   {return try_unlock_upgradable_and_lock();}
+    bool try_unlock_upgrade_and_lock()
+    {return try_unlock_upgradable_and_lock();}
 
-   bool timed_unlock_upgrade_and_lock(const boost::posix_time::ptime &abs_time)
-   {return timed_unlock_upgradable_and_lock(abs_time);}
+    bool try_unlock_upgrade_and_lock_until(const boost::posix_time::ptime &abs_time)
+    {return timed_unlock_upgradable_and_lock(abs_time);}
 
-   bool try_unlock_share_and_lock()
-   {return try_unlock_sharable_and_lock();}
+    bool try_unlock_share_and_lock()
+    {return try_unlock_sharable_and_lock();}
 
-   bool try_unlock_share_and_lock_upgrade()
-   {return try_unlock_sharable_and_lock_upgradable();}
+    bool try_unlock_share_and_lock_upgrade()
+    {return try_unlock_sharable_and_lock_upgradable();}
 
 };
 

Modified: sandbox/synchro/boost/synchro/thread/mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/thread/mutex.hpp	2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
@@ -17,6 +17,7 @@
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/thread/thread_time.hpp>
 #include <boost/synchro/thread/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 
 namespace boost { namespace synchro {
@@ -41,11 +42,7 @@
     typedef boost::condition_variable  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
 
-    thread_mutex() : lock_traits_base<multi_threaded_tag,exclusive_lock_tag,
-                        non_recursive_tag, hasnt_timed_interface_tag, 
-                        process_lifetime_tag,anonymous_tag,
-                        mutex>()
-    {}
+    thread_mutex() {}
 };
 
 template <>
@@ -118,16 +115,24 @@
     thread_timed_mutex &operator=(const thread_mutex &);
 
 public:
-
+    
     typedef boost::condition_variable_any  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
 
+    thread_timed_mutex () {}
+        
     bool try_lock_until(system_time const & abs_time)
     {return timed_lock(abs_time);}
     template<typename TimeDuration>
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
 
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
+    
 };    
 
 #if 0

Modified: sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp
==============================================================================
--- sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp	(original)
+++ sandbox/synchro/boost/synchro/thread/recursive_mutex.hpp	2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/synchro/thread/lockable_scope_traits.hpp>
 #include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
 
@@ -102,15 +103,8 @@
     thread_recursive_timed_mutex &operator=(const thread_recursive_timed_mutex &);
 
 public:
-    thread_recursive_timed_mutex() : lock_traits_base<
-    multi_threaded_tag,
-    exclusive_lock_tag,
-    recursive_tag,
-    has_timed_interface_tag,
-    process_lifetime_tag,
-    anonymous_tag,
-    recursive_timed_mutex
->(){}
+    thread_recursive_timed_mutex() {}
+        
     typedef boost::condition_variable_any  best_condition_type;
     typedef boost::condition_variable_any  best_condition_any_type;
 
@@ -120,6 +114,12 @@
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
 
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
+    
 };    
 
 #if 0

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 03:53:13 EST (Sat, 14 Feb 2009)
@@ -15,6 +15,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/synchro/lockable_traits.hpp>
 #include <boost/synchro/thread/lockable_scope_traits.hpp>
+#include <boost/synchro/timeout_exception.hpp>
 
 namespace boost { namespace synchro {
     
@@ -45,10 +46,18 @@
     template<typename TimeDuration>
     bool try_lock_for(TimeDuration const & relative_time)
     {return timed_lock(relative_time);}
+
+    void lock_until(system_time const & abs_time)
+    {if(!timed_lock(abs_time)) throw timeout_exception();}
+    template<typename TimeDuration>
+    void lock_for(TimeDuration const & relative_time)
+    {if(!timed_lock(relative_time)) throw timeout_exception();}
     
     bool try_lock_shared_until(system_time const& abs_time)
     {return timed_lock_shared(abs_time);}
 
+    void lock_shared_until(system_time const& abs_time)
+    {if(!timed_lock_shared(abs_time)) throw timeout_exception();}
     
 };    
 

Added: sandbox/synchro/boost/synchro/timeout_exception.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/timeout_exception.hpp	2009-02-14 03:53:13 EST (Sat, 14 Feb 2009)
@@ -0,0 +1,31 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008-2009. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/synchro for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_SYNCHRO_TIMEOUT_EXCEPTION__HPP
+#define BOOST_SYNCHRO_TIMEOUT_EXCEPTION__HPP
+
+#include <exception>
+#include <stdexcept>
+
+namespace boost { namespace synchro {
+
+    class timeout_exception : public std::logic_error {
+    public:
+        timeout_exception() : std::logic_error("timeout exception") {}
+    };
+
+    struct throw_timeout_t {};
+    struct nothrow_timeout_t {};
+    const throw_timeout_t throw_timeout ={};
+    const nothrow_timeout_t no_throw_timeout ={};
+
+}
+}
+#endif