[Boost-commit] svn:boost r51157 - sandbox/synchro/boost/synchro/process

Subject: [Boost-commit] svn:boost r51157 - sandbox/synchro/boost/synchro/process
From: vicente.botet_at_[hidden]
Date: 2009-02-09 17:38:18

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

Log:
Boost.Synchro V0.0.0
Added:
   sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/process/locks.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/process/mutex.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/process/named_mutex.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/process/recursive_mutex.hpp   (contents, props changed)
   sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp   (contents, props changed)

Added: sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/lockable_scope_traits.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,74 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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_PROCESS_SYNTACTIC_LOCK_TRAITS__HPP
+#define BOOST_SYNCHRO_PROCESS_SYNTACTIC_LOCK_TRAITS__HPP
+
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/sync/sharable_lock.hpp>
+#include <boost/interprocess/sync/upgradable_lock.hpp>
+#include <boost/interprocess/sync/lock_options.hpp>
+#include <boost/interprocess/detail/move.hpp>
+#include <boost/synchro/lockable_scope_traits.hpp>
+#include "boost/synchro/lockable_traits.hpp"
+
+namespace boost { namespace synchro {
+
+template<>
+struct scope_traits<multi_process_tag>
+{
+
+    typedef boost::interprocess::lock_exception lock_error;
+    template <typename T>
+    struct moved_object : boost::interprocess::detail::moved_object<T> {
+        moved_object(T& t_): boost::interprocess::detail::moved_object<T>(t_) {}
+    };
+
+    typedef boost::interprocess::detail::defer_lock_type defer_lock_t;
+    typedef boost::interprocess::detail::accept_ownership_type adopt_lock_t;
+    typedef boost::interprocess::detail::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;}
+
+};
+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;
+
+};
+//template<typename Lockable>
+//lockable_scope_traits<multi_process_tag, Lockable>::defer_lock_t
+////boost::interprocess::detail::defer_lock_type
+//lockable_scope_traits<multi_process_tag, Lockable>::defer_lock ={};
+////(lockable_scope_traits<multi_process_tag, Lockable>::defer_lock_type());
+//
+//template<typename Lockable>
+//const lockable_scope_traits<multi_process_tag, Lockable>::adopt_lock_t
+//lockable_scope_traits<multi_process_tag, Lockable>::adopt_lock
+//={};
+//
+//template<typename Lockable>
+//const lockable_scope_traits<multi_process_tag, Lockable>::try_to_lock_t
+//lockable_scope_traits<multi_process_tag, Lockable>::try_to_lock
+//={};
+
+
+}
+}
+
+#endif

Added: sandbox/synchro/boost/synchro/process/locks.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/locks.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,38 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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_PROCESS_LOCK__HPP
+#define BOOST_SYNCHRO_PROCESS_LOCKS__HPP
+
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/sync/sharable_lock.hpp>
+#include <boost/interprocess/sync/upgradable_lock.hpp>
+#include "boost/synchro/lockable_traits.hpp"
+
+namespace boost { namespace synchro {
+
+
+template <typename T>
+struct lockable_type<boost::interprocess::scoped_lock<T> > {
+	typedef T type;
+};
+template <typename T>
+struct lockable_type<boost::interprocess::sharable_lock<T> > {
+	typedef T type;
+};
+template <typename T>
+struct lockable_type<boost::interprocess::upgradable_lock<T> > {
+	typedef T type;
+};
+
+}
+}
+
+#endif

Added: sandbox/synchro/boost/synchro/process/mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/mutex.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,64 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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_PROCESS_MUTEX__HPP
+#define BOOST_SYNCHRO_PROCESS_MUTEX__HPP
+
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/interprocess_condition.hpp>
+#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/process/lockable_scope_traits.hpp>
+
+namespace boost { namespace synchro {
+
+typedef boost::interprocess::interprocess_mutex interprocess_mutex;
+
+template<>
+struct timed_interface_tag<boost::interprocess::interprocess_mutex> {
+	typedef has_timed_interface_tag type;
+};
+template<>
+struct reentrancy_tag<boost::interprocess::interprocess_mutex> {
+	typedef non_recursive_tag type;
+};
+template<>
+struct category_tag<boost::interprocess::interprocess_mutex> {
+	typedef exclusive_lock_tag type;
+};
+template<>
+struct scope_tag<boost::interprocess::interprocess_mutex> {
+	typedef multi_process_tag type;
+};
+
+template<>
+struct lifetime_tag<boost::interprocess::interprocess_mutex> {
+	typedef kernel_lifetime_tag type;
+};
+
+template<>
+struct naming_tag<boost::interprocess::interprocess_mutex> {
+	typedef anonymous_tag type;
+};
+
+template <>
+struct best_condition<boost::interprocess::interprocess_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+template <>
+struct best_condition_any<boost::interprocess::interprocess_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+
+}
+}
+
+#endif

Added: sandbox/synchro/boost/synchro/process/named_mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/named_mutex.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,69 @@
+#ifndef BOOST_SYNCHRO_PROCESS_NAMED_MUTEX__HPP
+#define BOOST_SYNCHRO_PROCESS_NAMED_MUTEX__HPP
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/interprocess/sync/named_mutex.hpp>
+#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/process/lockable_scope_traits.hpp>
+
+namespace boost { namespace synchro {
+
+typedef boost::interprocess::named_mutex named_mutex;
+
+template<>
+struct timed_interface_tag<boost::interprocess::named_mutex> {
+	typedef has_timed_interface_tag type;
+};
+template<>
+struct reentrancy_tag<boost::interprocess::named_mutex> {
+	typedef non_recursive_tag type;
+};
+template<>
+struct category_tag<boost::interprocess::named_mutex> {
+	typedef exclusive_lock_tag type;
+};
+template<>
+struct scope_tag<boost::interprocess::named_mutex> {
+	typedef multi_process_tag type;
+};
+
+template<>
+struct lifetime_tag<boost::interprocess::named_mutex> {
+	typedef kernel_lifetime_tag type;
+};
+
+template<>
+struct naming_tag<boost::interprocess::named_mutex> {
+	typedef named_tag type;
+};
+
+template <>
+struct best_condition<boost::interprocess::named_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+template <>
+struct best_condition_any<boost::interprocess::named_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+
+#if 0
+template<>
+struct syntactic_lock_traits<boost::interprocess::named_mutex>
+	: syntactic_process_lock_traits<boost::interprocess::named_mutex> {};
+#endif
+
+}
+}
+
+#endif

Added: sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/named_recursive_mutex.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,68 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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_PROCESS_NAMED_RECURSIVE_MUTEX__HPP
+#define BOOST_SYNCHRO_PROCESS_NAMED_RECURSIVE_MUTEX__HPP
+
+#include <boost/interprocess/sync/named_recursive_mutex.hpp>
+#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/process/lockable_scope_traits.hpp>
+
+namespace boost { namespace synchro {
+
+typedef boost::interprocess::named_recursive_mutex named_recursive_mutex;
+
+template<>
+struct timed_interface_tag<boost::interprocess::named_recursive_mutex> {
+	typedef has_timed_interface_tag type;
+};
+template<>
+struct reentrancy_tag<boost::interprocess::named_recursive_mutex> {
+	typedef recursive_tag type;
+};
+template<>
+struct category_tag<boost::interprocess::named_recursive_mutex> {
+	typedef exclusive_lock_tag type;
+};
+template<>
+struct scope_tag<boost::interprocess::named_recursive_mutex> {
+	typedef multi_process_tag type;
+};
+
+template<>
+struct lifetime_tag<boost::interprocess::named_recursive_mutex> {
+	typedef kernel_lifetime_tag type;
+};
+
+template<>
+struct naming_tag<boost::interprocess::named_recursive_mutex> {
+	typedef anonymous_tag type;
+};
+
+template <>
+struct best_condition<boost::interprocess::named_recursive_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+template <>
+struct best_condition_any<boost::interprocess::named_recursive_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+#if 0
+template<>
+struct syntactic_lock_traits<boost::interprocess::named_mutex>
+	: syntactic_process_lock_traits<boost::interprocess::named_mutex> {};
+#endif
+
+}
+}
+
+#endif

Added: sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/named_upgradable_mutex.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,126 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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_PROCESS_NAMED_UPGRADABLE_MUTEX__HPP
+#define BOOST_SYNCHRO_PROCESS_NAMED_UPGRADABLE_MUTEX__HPP
+
+#include <boost/interprocess/sync/named_upgradable_mutex.hpp>
+#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/process/lockable_scope_traits.hpp>
+
+namespace boost { namespace synchro {
+
+class interprocess_named_upgradable_mutex
+	: public lock_traits_base<
+		multi_process_tag,
+		upgradable_lock_tag,
+		non_recursive_tag,
+		has_timed_interface_tag,
+        kernel_lifetime_tag,
+        named_tag,
+		interprocess::named_upgradable_mutex
+	>
+{
+   //Non-copyable
+	interprocess_named_upgradable_mutex();
+	interprocess_named_upgradable_mutex(const interprocess_upgradable_mutex &);
+	interprocess_named_upgradable_mutex &operator=(const interprocess_named_upgradable_mutex &);
+public:
+	typedef boost::interprocess::interprocess_condition  condition_type;
+	typedef boost::interprocess::interprocess_condition  condition_any_type;
+#if 0
+	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
+   void lock_shared()
+   {lock_sharable();}
+
+   bool try_lock_shared()
+   {return try_lock_sharable();}
+
+   bool timed_lock_shared(const boost::posix_time::ptime &abs_time)
+   {return timed_lock_sharable(abs_time);}
+
+   void unlock_shared()
+   {unlock_sharable();}
+
+   void lock_upgrade()
+   {lock_upgradable();}
+
+   bool try_lock_upgrade()
+   {return try_lock_upgradable();}
+
+   bool timed_lock_upgrade(const boost::posix_time::ptime &abs_time)
+   {return timed_lock_upgradable(abs_time);}
+
+   void unlock_upgrade()
+   {unlock_upgradable();}
+
+   void unlock_and_lock_upgrade()
+   {unlock_and_lock_upgrade();}
+
+   void unlock_and_lock_shared()
+   {unlock_and_lock_sharable();}
+
+#if 0
+   void unlock_upgrade_and_lock_shared();
+   {unlock_upgradable_and_lock_sharable();}
+#endif
+   void unlock_upgrade_and_lock()
+   {unlock_upgrade_and_lock();}
+
+   bool try_unlock_upgrade_and_lock()
+   {return try_unlock_upgradable_and_lock();}
+
+#if 0
+   bool timed_unlock_upgrade_and_lock(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_upgrade();
+   {return try_unlock_sharable_and_lock_upgradable();}
+#endif
+
+};
+
+
+//template<>
+//struct timed_interface_tag<boost::synchro::named_upgradable_mutex> {
+//	typedef has_timed_interface_tag type;
+//};
+//template<>
+//struct reentrancy_tag<boost::synchro::named_upgradable_mutex> {
+//	typedef non_recursive_tag type;
+//};
+//template<>
+//struct category_tag<boost::synchro::named_upgradable_mutex> {
+//	typedef upgradable_lock_tag type;
+//};
+//template<>
+//struct scope_tag<boost::synchro::named_upgradable_mutex> {
+//	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> {};
+#endif
+
+}
+}
+
+#endif

Added: sandbox/synchro/boost/synchro/process/recursive_mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/recursive_mutex.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,70 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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_PROCESS_RECURSIVE_MUTEX__HPP
+#define BOOST_SYNCHRO_PROCESS_RECURSIVE_MUTEX__HPP
+
+#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
+#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/process/lockable_scope_traits.hpp>
+
+namespace boost { namespace synchro {
+
+typedef boost::interprocess::interprocess_recursive_mutex interprocess_recursive_mutex;
+
+template<>
+struct timed_interface_tag<boost::interprocess::interprocess_recursive_mutex> {
+	typedef has_timed_interface_tag type;
+};
+template<>
+struct reentrancy_tag<boost::interprocess::interprocess_recursive_mutex> {
+	typedef recursive_tag type;
+};
+template<>
+struct category_tag<boost::interprocess::interprocess_recursive_mutex> {
+	typedef exclusive_lock_tag type;
+};
+template<>
+struct scope_tag<boost::interprocess::interprocess_recursive_mutex> {
+	typedef multi_process_tag type;
+};
+
+template<>
+struct lifetime_tag<boost::interprocess::interprocess_recursive_mutex> {
+	typedef kernel_lifetime_tag type;
+};
+
+template<>
+struct naming_tag<boost::interprocess::interprocess_recursive_mutex> {
+	typedef anonymous_tag type;
+};
+
+
+template <>
+struct best_condition<boost::interprocess::interprocess_recursive_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+template <>
+struct best_condition_any<boost::interprocess::interprocess_recursive_mutex> {
+	typedef boost::interprocess::interprocess_condition type;
+};
+
+
+#if 0
+template<>
+struct syntactic_lock_traits<boost::interprocess::interprocess_recursive_mutex>
+	: syntactic_process_lock_traits<boost::interprocess::interprocess_recursive_mutex> {};
+#endif
+
+}
+}
+
+#endif

Added: sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp
==============================================================================
--- (empty file)
+++ sandbox/synchro/boost/synchro/process/upgradable_mutex.hpp	2009-02-09 17:38:17 EST (Mon, 09 Feb 2009)
@@ -0,0 +1,117 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2008. 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_PROCESS_UPGRADABLE_MUTEX__HPP
+#define BOOST_SYNCHRO_PROCESS_UPGRADABLE_MUTEX__HPP
+
+#include <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
+#include <boost/synchro/lockable_traits.hpp>
+#include <boost/synchro/process/lockable_scope_traits.hpp>
+
+namespace boost { namespace synchro {
+
+class interprocess_upgradable_mutex
+: public lock_traits_base<
+	multi_process_tag,
+	upgradable_lock_tag,
+	non_recursive_tag,
+	has_timed_interface_tag,
+    kernel_lifetime_tag,
+    anonymous_tag,
+	interprocess::interprocess_upgradable_mutex
+>
+{
+
+    //Non-copyable
+    interprocess_upgradable_mutex(const interprocess_upgradable_mutex &);
+    interprocess_upgradable_mutex &operator=(const interprocess_upgradable_mutex &);
+
+public:
+
+	typedef boost::interprocess::interprocess_condition  condition_type;
+	typedef boost::interprocess::interprocess_condition  condition_any_type;
+
+   void lock_shared()
+   {lock_sharable();}
+
+   bool try_lock_shared()
+   {return try_lock_sharable();}
+
+   bool timed_lock_shared(const boost::posix_time::ptime &abs_time)
+   {return timed_lock_sharable(abs_time);}
+
+   void unlock_shared()
+   {unlock_sharable();}
+
+   void lock_upgrade()
+   {lock_upgradable();}
+
+   bool try_lock_upgrade()
+   {return try_lock_upgradable();}
+
+   bool timed_lock_upgrade(const boost::posix_time::ptime &abs_time)
+   {return timed_lock_upgradable(abs_time);}
+
+   void unlock_upgrade()
+   {unlock_upgradable();}
+
+   void unlock_and_lock_upgrade()
+   {unlock_and_lock_upgrade();}
+
+   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()
+   {unlock_upgrade_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_share_and_lock()
+   {return try_unlock_sharable_and_lock();}
+
+   bool try_unlock_share_and_lock_upgrade()
+   {return try_unlock_sharable_and_lock_upgradable();}
+
+};
+
+
+//template<>
+//struct timed_interface_tag<boost::synchro::interprocess_upgradable_mutex> {
+//	typedef has_timed_interface_tag type;
+//};
+//template<>
+//struct reentrancy_tag<boost::synchro::interprocess_upgradable_mutex> {
+//	typedef non_recursive_tag type;
+//};
+//template<>
+//struct category_tag<boost::synchro::interprocess_upgradable_mutex> {
+//	typedef upgradable_lock_tag type;
+//};
+//template<>
+//struct scope_tag<boost::synchro::interprocess_upgradable_mutex> {
+//	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> {};
+#endif
+}
+}
+
+#endif