FM / thread

/usr/include/boost/thread

Name	Size	Mode	Actions
concurrent_queues/	-	0755	rm
csbl/	-	0755	rm
detail/	-	0755	rm
executors/	-	0755	rm
experimental/	-	0755	rm
futures/	-	0755	rm
pthread/	-	0755	rm
v2/	-	0755	rm
win32/	-	0755	rm
barrier.hpp	7421	0644	edit dl rm
caller_context.hpp	1526	0644	edit dl rm
completion_latch.hpp	6579	0644	edit dl rm
condition.hpp	490	0644	edit dl rm
condition_variable.hpp	634	0644	edit dl rm
cv_status.hpp	531	0644	edit dl rm
exceptional_ptr.hpp	1098	0644	edit dl rm
exceptions.hpp	6286	0644	edit dl rm
executor.hpp	476	0644	edit dl rm
externally_locked.hpp	10792	0644	edit dl rm
externally_locked_stream.hpp	4784	0644	edit dl rm
future.hpp	203792	0644	edit dl rm
interruption.hpp	596	0644	edit dl rm
is_locked_by_this_thread.hpp	1062	0644	edit dl rm
latch.hpp	4967	0644	edit dl rm
lockable_adapter.hpp	6043	0644	edit dl rm
lockable_concepts.hpp	4114	0644	edit dl rm
lockable_traits.hpp	7853	0644	edit dl rm
locks.hpp	572	0644	edit dl rm
lock_algorithms.hpp	13201	0644	edit dl rm
lock_concepts.hpp	4792	0644	edit dl rm
lock_factories.hpp	2317	0644	edit dl rm
lock_guard.hpp	2290	0644	edit dl rm
lock_options.hpp	701	0644	edit dl rm
lock_traits.hpp	1234	0644	edit dl rm
lock_types.hpp	34418	0644	edit dl rm
mutex.hpp	1166	0644	edit dl rm
null_mutex.hpp	6346	0644	edit dl rm
once.hpp	1324	0644	edit dl rm
ostream_buffer.hpp	925	0644	edit dl rm
poly_lockable.hpp	2100	0644	edit dl rm
poly_lockable_adapter.hpp	2124	0644	edit dl rm
poly_shared_lockable.hpp	5807	0644	edit dl rm
poly_shared_lockable_adapter.hpp	4792	0644	edit dl rm
recursive_mutex.hpp	1535	0644	edit dl rm
reverse_lock.hpp	1316	0644	edit dl rm
scoped_thread.hpp	8547	0644	edit dl rm
shared_lock_guard.hpp	1192	0644	edit dl rm
shared_mutex.hpp	1400	0644	edit dl rm
strict_lock.hpp	6246	0644	edit dl rm
synchronized_value.hpp	31110	0644	edit dl rm
sync_bounded_queue.hpp	595	0644	edit dl rm
sync_queue.hpp	571	0644	edit dl rm
testable_mutex.hpp	3925	0644	edit dl rm
thread.hpp	385	0644	edit dl rm
thread_functors.hpp	1366	0644	edit dl rm
thread_guard.hpp	1069	0644	edit dl rm
thread_only.hpp	803	0644	edit dl rm
thread_pool.hpp	531	0644	edit dl rm
thread_time.hpp	1590	0644	edit dl rm
tss.hpp	2603	0644	edit dl rm
user_scheduler.hpp	5222	0644	edit dl rm
with_lock_guard.hpp	6052	0644	edit dl rm
xtime.hpp	2390	0644	edit dl rm

Edit: /usr/include/boost/thread/lockable_traits.hpp (7853B)

#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 boost
{
  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=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_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(boost::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(boost::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(boost::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

// 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 #include #include #include #ifdef BOOST_NO_CXX11_SFINAE_EXPR #include #else #include #endif #include // todo make use of integral_constant, true_type and false_type namespace boost { 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::value> \ struct has_member_called_##member_name \ { \ BOOST_STATIC_CONSTANT(bool, value=false); \ }; \ \ template \ struct has_member_called_##member_name \ { \ typedef char true_type; \ struct false_type \ { \ true_type dummy[2]; \ }; \ \ struct fallback { int member_name; }; \ struct derived: \ T, fallback \ { \ derived(); \ }; \ \ template struct tester; \ \ template \ static false_type has_member(tester<&U::member_name>*); \ template \ static true_type has_member(...); \ \ BOOST_STATIC_CONSTANT( \ bool, value=sizeof(has_member(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::value > struct has_member_lock { BOOST_STATIC_CONSTANT(bool, value=false); }; template struct has_member_lock { typedef char true_type; struct false_type { true_type dummy[2]; }; template static true_type has_member(V (U::*)()); template static false_type has_member(U); BOOST_STATIC_CONSTANT( bool,value=sizeof(has_member_lock::has_member(&T::lock))==sizeof(true_type)); }; template::value > struct has_member_unlock { BOOST_STATIC_CONSTANT(bool, value=false); }; template struct has_member_unlock { typedef char true_type; struct false_type { true_type dummy[2]; }; template static true_type has_member(V (U::*)()); template static false_type has_member(U); BOOST_STATIC_CONSTANT( bool,value=sizeof(has_member_unlock::has_member(&T::unlock))==sizeof(true_type)); }; template::value > struct has_member_try_lock { BOOST_STATIC_CONSTANT(bool, value=false); }; template struct has_member_try_lock { typedef char true_type; struct false_type { true_type dummy[2]; }; template static true_type has_member(bool (U::*)()); template static false_type has_member(U); BOOST_STATIC_CONSTANT( bool,value=sizeof(has_member_try_lock::has_member(&T::try_lock))==sizeof(true_type)); }; #else template struct has_member_lock : false_type {}; template struct has_member_lock().lock())) > : true_type {}; template struct has_member_unlock : false_type {}; template struct has_member_unlock().unlock())) > : true_type {}; template struct has_member_try_lock : false_type {}; template struct has_member_try_lock().try_lock())) > : true_type {}; #endif } template struct is_basic_lockable { BOOST_STATIC_CONSTANT(bool, value = detail::has_member_lock::value && detail::has_member_unlock::value); }; template struct is_lockable { BOOST_STATIC_CONSTANT(bool, value = is_basic_lockable::value && detail::has_member_try_lock::value); }; #else template struct is_basic_lockable { BOOST_STATIC_CONSTANT(bool, value = false); }; template struct is_lockable { BOOST_STATIC_CONSTANT(bool, value = false); }; #endif template struct is_recursive_mutex_sur_parole { BOOST_STATIC_CONSTANT(bool, value = false); }; template struct is_recursive_mutex_sur_parolle : is_recursive_mutex_sur_parole { }; template struct is_recursive_basic_lockable { BOOST_STATIC_CONSTANT(bool, value = is_basic_lockable::value && is_recursive_mutex_sur_parolle::value); }; template struct is_recursive_lockable { BOOST_STATIC_CONSTANT(bool, value = is_lockable::value && is_recursive_mutex_sur_parolle::value); }; } template struct is_mutex_type { BOOST_STATIC_CONSTANT(bool, value = sync::is_lockable::value); }; } #include #endif