text: // 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 2011-2012 Vicente J. Botet Escriba
  
  #ifndef BOOST_THREAD_LOCKABLE_TRAITS_HPP
  #define BOOST_THREAD_LOCKABLE_TRAITS_HPP
  
  #include <boost/thread/detail/config.hpp>
  
  #include <boost/assert.hpp>
  #include <boost/detail/workaround.hpp>
  #include <boost/type_traits/integral_constant.hpp>
  #ifdef BOOST_NO_CXX11_SFINAE_EXPR
  #include <boost/type_traits/is_class.hpp>
  #else
  #include <boost/type_traits/declval.hpp>
  #endif
  
  #include <boost/config/abi_prefix.hpp>
  
  // todo make use of integral_constant, true_type and false_type
  
  namespace lslboost
  {
    namespace sync
    {
  
  #if defined(BOOST_NO_SFINAE) ||                           \
      BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \
      BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
  #if ! defined BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
  #define BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
  #endif
  #endif
  
  #ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
      namespace detail
      {
  #ifdef BOOST_NO_CXX11_SFINAE_EXPR
  #define BOOST_THREAD_DEFINE_HAS_MEMBER_CALLED(member_name)                     \
          template<typename T, bool=lslboost::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_THREAD_DEFINE_HAS_MEMBER_CALLED(lock)
  ;      BOOST_THREAD_DEFINE_HAS_MEMBER_CALLED(unlock);
        BOOST_THREAD_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));
        };
  #else
        template<typename T,typename Enabled=void>
        struct has_member_lock : false_type {};
  
        template<typename T>
        struct has_member_lock<T,
            decltype(void(lslboost::declval<T&>().lock()))
        > : true_type {};
  
        template<typename T,typename Enabled=void>
        struct has_member_unlock : false_type {};
  
        template<typename T>
        struct has_member_unlock<T,
            decltype(void(lslboost::declval<T&>().unlock()))
        > : true_type {};
  
        template<typename T,typename Enabled=bool>
        struct has_member_try_lock : false_type {};
  
        template<typename T>
        struct has_member_try_lock<T,
            decltype(bool(lslboost::declval<T&>().try_lock()))
        > : true_type {};
  #endif
  
      }
  
      template<typename T>
      struct is_basic_lockable
      {
        BOOST_STATIC_CONSTANT(bool, value = detail::has_member_lock<T>::value &&
            detail::has_member_unlock<T>::value);
      };
      template<typename T>
      struct is_lockable
      {
        BOOST_STATIC_CONSTANT(bool, value =
            is_basic_lockable<T>::value &&
            detail::has_member_try_lock<T>::value);
      };
  
  #else
      template<typename T>
      struct is_basic_lockable
      {
        BOOST_STATIC_CONSTANT(bool, value = false);
      };
      template<typename T>
      struct is_lockable
      {
        BOOST_STATIC_CONSTANT(bool, value = false);
      };
  #endif
  
      template<typename T>
      struct is_recursive_mutex_sur_parole
      {
        BOOST_STATIC_CONSTANT(bool, value = false);
      };
      template<typename T>
      struct is_recursive_mutex_sur_parolle : is_recursive_mutex_sur_parole<T>
      {
      };
  
      template<typename T>
      struct is_recursive_basic_lockable
      {
        BOOST_STATIC_CONSTANT(bool, value = is_basic_lockable<T>::value &&
            is_recursive_mutex_sur_parolle<T>::value);
      };
      template<typename T>
      struct is_recursive_lockable
      {
        BOOST_STATIC_CONSTANT(bool, value = is_lockable<T>::value &&
            is_recursive_mutex_sur_parolle<T>::value);
      };
    }
    template<typename T>
    struct is_mutex_type
    {
      BOOST_STATIC_CONSTANT(bool, value = sync::is_lockable<T>::value);
    };
  
  }
  #include <boost/config/abi_suffix.hpp>
  
  #endif
  