[Boost-commit] svn:boost r65408 - in sandbox/sync/boost/sync/lockable_traits: . detail

Subject: [Boost-commit] svn:boost r65408 - in sandbox/sync/boost/sync/lockable_traits: . detail
From: vicente.botet_at_[hidden]
Date: 2010-09-13 01:27:08

Author: viboes
Date: 2010-09-13 01:27:07 EDT (Mon, 13 Sep 2010)
New Revision: 65408
URL: http://svn.boost.org/trac/boost/changeset/65408

Log:
Added is_lockable_type
Added:
   sandbox/sync/boost/sync/lockable_traits/
   sandbox/sync/boost/sync/lockable_traits/detail/
   sandbox/sync/boost/sync/lockable_traits/detail/has_members.hpp   (contents, props changed)
   sandbox/sync/boost/sync/lockable_traits/is_lockable_type.hpp   (contents, props changed)

Added: sandbox/sync/boost/sync/lockable_traits/detail/has_members.hpp
==============================================================================
--- (empty file)
+++ sandbox/sync/boost/sync/lockable_traits/detail/has_members.hpp	2010-09-13 01:27:07 EDT (Mon, 13 Sep 2010)
@@ -0,0 +1,146 @@
+// 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)
+// (C) Copyright 2007 Anthony Williams
+// (C) Copyright 2010 Vicente J. Botet Escriba
+
+#ifndef BOOST_SYNC_HAS_MEMBERS_HPP
+#define BOOST_SYNC_HAS_MEMBERS_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/is_class.hpp>
+
+namespace boost
+{
+
+#ifndef BOOST_SYNC_NO_AUTO_DETECT_TYPES
+#if defined(BOOST_NO_SFINAE) ||                           \
+    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \
+    BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#define BOOST_SYNC_NO_AUTO_DETECT_TYPES
+#endif
+#endif
+
+#ifndef BOOST_SYNC_NO_AUTO_DETECT_TYPES
+    namespace detail
+    {
+#define BOOST_DEFINE_HAS_MEMBER_CALLED(member_name)                     \
+        template<typename T, bool=boost::is_class<T>::value>            \
+        struct has_member_called_##member_name                          \
+        {                                                               \
+            BOOST_STATIC_CONSTANT(bool, value=false);                   \
+        };                                                              \
+                                                                        \
+        template<typename T>                                            \
+        struct has_member_called_##member_name<T,true>                  \
+        {                                                               \
+            typedef char true_type;                                     \
+            struct false_type                                           \
+            {                                                           \
+                true_type dummy[2];                                     \
+            };                                                          \
+                                                                        \
+            struct fallback { int member_name; };                       \
+            struct derived:                                             \
+                T, fallback                                             \
+            {                                                           \
+                derived();                                              \
+            };                                                          \
+                                                                        \
+            template<int fallback::*> struct tester;                    \
+                                                                        \
+            template<typename U>                                        \
+                static false_type has_member(tester<&U::member_name>*); \
+            template<typename U>                                        \
+                static true_type has_member(...);                       \
+                                                                        \
+            BOOST_STATIC_CONSTANT(                                      \
+                bool, value=sizeof(has_member<derived>(0))==sizeof(true_type)); \
+        }
+
+        BOOST_DEFINE_HAS_MEMBER_CALLED(lock);
+        BOOST_DEFINE_HAS_MEMBER_CALLED(unlock);
+        BOOST_DEFINE_HAS_MEMBER_CALLED(try_lock);
+
+        template<typename T,bool=has_member_called_lock<T>::value >
+        struct has_member_lock
+        {
+            BOOST_STATIC_CONSTANT(bool, value=false);
+        };
+        
+        template<typename T>
+        struct has_member_lock<T,true>
+        {
+            typedef char true_type;
+            struct false_type
+            {
+                true_type dummy[2];
+            };
+            
+            template<typename U,typename V>
+            static true_type has_member(V (U::*)());
+            template<typename U>
+            static false_type has_member(U);
+            
+            BOOST_STATIC_CONSTANT(
+                bool,value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type));
+        };
+        
+        template<typename T,bool=has_member_called_unlock<T>::value >
+        struct has_member_unlock
+        {
+            BOOST_STATIC_CONSTANT(bool, value=false);
+        };
+        
+        template<typename T>
+        struct has_member_unlock<T,true>
+        {
+            typedef char true_type;
+            struct false_type
+            {
+                true_type dummy[2];
+            };
+            
+            template<typename U,typename V>
+            static true_type has_member(V (U::*)());
+            template<typename U>
+            static false_type has_member(U);
+            
+            BOOST_STATIC_CONSTANT(
+                bool,value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type));
+        };
+        
+        template<typename T,bool=has_member_called_try_lock<T>::value >
+        struct has_member_try_lock
+        {
+            BOOST_STATIC_CONSTANT(bool, value=false);
+        };
+        
+        template<typename T>
+        struct has_member_try_lock<T,true>
+        {
+            typedef char true_type;
+            struct false_type
+            {
+                true_type dummy[2];
+            };
+            
+            template<typename U>
+            static true_type has_member(bool (U::*)());
+            template<typename U>
+            static false_type has_member(U);
+            
+            BOOST_STATIC_CONSTANT(
+                bool,value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type));
+        };
+
+    }
+    
+#endif    
+
+    
+}
+
+
+#endif

Added: sandbox/sync/boost/sync/lockable_traits/is_lockable_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/sync/boost/sync/lockable_traits/is_lockable_type.hpp	2010-09-13 01:27:07 EDT (Mon, 13 Sep 2010)
@@ -0,0 +1,45 @@
+// 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)
+// (C) Copyright 2007 Anthony Williams
+// (C) Copyright 2010 Vicente J. Botet Escriba
+
+#ifndef BOOST_SYNC_IS_LOCKABLE_TYPE_HPP
+#define BOOST_SYNC_IS_LOCKABLE_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/sync/lockable_traits/detail/has_members.hpp>
+
+namespace boost
+{
+
+#ifndef BOOST_SYNC_NO_AUTO_DETECT_TYPES   
+
+    template<typename T>
+    struct is_mutex_type
+    {
+        BOOST_STATIC_CONSTANT(bool, value = 
+            detail::has_member_lock<T>::value &&
+            detail::has_member_unlock<T>::value &&
+            detail::has_member_try_lock<T>::value);
+        
+    };
+#else
+    template<typename T>
+    struct is_mutex_type
+    {
+        BOOST_STATIC_CONSTANT(bool, value = false);
+    };
+#endif    
+
+    template<typename T>
+    struct is_lockable_type
+    {
+        BOOST_STATIC_CONSTANT(bool, value=is_mutex_type<T>::value);
+    };
+    
+    
+}
+
+
+#endif