FM / detail

/usr/include/boost/thread/detail

Name	Size	Mode	Actions
atomic_redef_macros.hpp	644	0644	edit dl rm
atomic_undef_macros.hpp	913	0644	edit dl rm
config.hpp	18149	0644	edit dl rm
counter.hpp	2441	0644	edit dl rm
delete.hpp	1712	0644	edit dl rm
force_cast.hpp	998	0644	edit dl rm
function_wrapper.hpp	2092	0644	edit dl rm
invoke.hpp	51343	0644	edit dl rm
invoker.hpp	23078	0644	edit dl rm
is_convertible.hpp	1345	0644	edit dl rm
lockable_wrapper.hpp	980	0644	edit dl rm
log.hpp	2471	0644	edit dl rm
make_tuple_indices.hpp	9004	0644	edit dl rm
memory.hpp	1465	0644	edit dl rm
move.hpp	10548	0644	edit dl rm
nullary_function.hpp	5758	0644	edit dl rm
platform.hpp	2860	0644	edit dl rm
platform_time.hpp	15345	0644	edit dl rm
singleton.hpp	1188	0644	edit dl rm
thread.hpp	26312	0644	edit dl rm
thread_group.hpp	4279	0644	edit dl rm
thread_heap_alloc.hpp	631	0644	edit dl rm
thread_interruption.hpp	1228	0644	edit dl rm
thread_safety.hpp	5855	0644	edit dl rm
tss_hooks.hpp	2531	0644	edit dl rm
variadic_footer.hpp	262	0644	edit dl rm
variadic_header.hpp	537	0644	edit dl rm

Edit: /usr/include/boost/thread/detail/nullary_function.hpp (5758B)

#ifndef BOOST_THREAD_DETAIL_NULLARY_FUNCTION_HPP
#define BOOST_THREAD_DETAIL_NULLARY_FUNCTION_HPP

#include <boost/config.hpp>
#include <boost/thread/detail/memory.hpp>
#include <boost/thread/detail/move.hpp>
#include <boost/thread/csbl/memory/shared_ptr.hpp>
#include <boost/type_traits/decay.hpp>
#include <boost/type_traits/is_same.hpp>

namespace boost
{
  namespace detail
  {

template <typename F>
    class nullary_function;
    template <>
    class nullary_function<void()>
    {
      struct impl_base
      {
        virtual void call()=0;
        virtual ~impl_base()
        {
        }
      };
      csbl::shared_ptr<impl_base> impl;
      template <typename F>
      struct impl_type: impl_base
      {
        F f;
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
        impl_type(F &f_)
          : f(f_)
        {}
#endif
        impl_type(BOOST_THREAD_RV_REF(F) f_)
          : f(boost::move(f_))
        {}

void call()
        {
          f();
        }
      };
      struct impl_type_ptr: impl_base
      {
        void (*f)();
        impl_type_ptr(void (*f_)())
          : f(f_)
        {}
        void call()
        {
          f();
        }
      };
    public:
      BOOST_THREAD_COPYABLE_AND_MOVABLE(nullary_function)

explicit nullary_function(void (*f)()):
      impl(new impl_type_ptr(f))
      {}

#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
      template<typename F>
      explicit nullary_function(F& f
                                , typename disable_if<is_same<typename decay<F>::type, nullary_function>, int* >::type=0
                                ):
      impl(new impl_type<F>(f))
      {}
#endif
      template<typename F>
      nullary_function(BOOST_THREAD_RV_REF(F) f
                       , typename disable_if<is_same<typename decay<F>::type, nullary_function>, int* >::type=0
                       ):
      impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f))))
      {}

nullary_function()
        : impl()
      {
      }
      nullary_function(nullary_function const& other) BOOST_NOEXCEPT :
      impl(other.impl)
      {
      }
      nullary_function(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT :
#if defined BOOST_NO_CXX11_SMART_PTR
      impl(BOOST_THREAD_RV(other).impl)
      {
        BOOST_THREAD_RV(other).impl.reset();
      }
#else
      impl(boost::move(other.impl))
      {
      }
#endif
      ~nullary_function()
      {
      }

nullary_function& operator=(BOOST_THREAD_COPY_ASSIGN_REF(nullary_function) other) BOOST_NOEXCEPT
      {
        impl=other.impl;
        return *this;
      }
      nullary_function& operator=(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT
      {
#if defined BOOST_NO_CXX11_SMART_PTR
        impl=BOOST_THREAD_RV(other).impl;
        BOOST_THREAD_RV(other).impl.reset();
#else
        impl = boost::move(other.impl);
#endif
        return *this;
      }

void operator()()
      { if (impl) impl->call();}

};

template <typename R>
    class nullary_function<R()>
    {
      struct impl_base
      {
        virtual R call()=0;
        virtual ~impl_base()
        {
        }
      };
      csbl::shared_ptr<impl_base> impl;
      template <typename F>
      struct impl_type: impl_base
      {
        F f;
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
        impl_type(F &f_)
          : f(f_)
        {}
#endif
        impl_type(BOOST_THREAD_RV_REF(F) f_)
          : f(boost::move(f_))
        {}

R call()
        {
          return f();
        }
      };
      struct impl_type_ptr: impl_base
      {
        R (*f)();
        impl_type_ptr(R (*f_)())
          : f(f_)
        {}

R call()
        {
          return f();
        }
      };
    public:
      BOOST_THREAD_COPYABLE_AND_MOVABLE(nullary_function)

nullary_function(R (*f)()):
      impl(new impl_type_ptr(f))
      {}
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
      template<typename F>
      nullary_function(F& f):
      impl(new impl_type<F>(f))
      {}
#endif
      template<typename F>
      nullary_function(BOOST_THREAD_RV_REF(F) f):
      impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f))))
      {}

nullary_function(nullary_function const& other) BOOST_NOEXCEPT :
      impl(other.impl)
      {
      }
      nullary_function(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT :
#if defined BOOST_NO_CXX11_SMART_PTR
      impl(BOOST_THREAD_RV(other).impl)
      {
        BOOST_THREAD_RV(other).impl.reset();
      }
#else
      impl(boost::move(other.impl))
      {
      }
#endif
      nullary_function()
        : impl()
      {
      }
      ~nullary_function()
      {
      }

R operator()()
      { if (impl) return impl->call(); else return R();}

};
  }
  BOOST_THREAD_DCL_MOVABLE_BEG(F) detail::nullary_function<F> BOOST_THREAD_DCL_MOVABLE_END
}

#endif // header

// Copyright (C) 2013 Vicente J. Botet Escriba // // 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) // // 2013,2018 Vicente J. Botet Escriba // Adapt to boost from CCIA C++11 implementation // Make use of Boost.Move #ifndef BOOST_THREAD_DETAIL_NULLARY_FUNCTION_HPP #define BOOST_THREAD_DETAIL_NULLARY_FUNCTION_HPP #include #include #include #include #include #include namespace boost { namespace detail { template class nullary_function; template <> class nullary_function { struct impl_base { virtual void call()=0; virtual ~impl_base() { } }; csbl::shared_ptr impl; template struct impl_type: impl_base { F f; #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES impl_type(F &f_) : f(f_) {} #endif impl_type(BOOST_THREAD_RV_REF(F) f_) : f(boost::move(f_)) {} void call() { f(); } }; struct impl_type_ptr: impl_base { void (*f)(); impl_type_ptr(void (*f_)()) : f(f_) {} void call() { f(); } }; public: BOOST_THREAD_COPYABLE_AND_MOVABLE(nullary_function) explicit nullary_function(void (*f)()): impl(new impl_type_ptr(f)) {} #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES template explicit nullary_function(F& f , typename disable_if::type, nullary_function>, int* >::type=0 ): impl(new impl_type(f)) {} #endif template nullary_function(BOOST_THREAD_RV_REF(F) f , typename disable_if::type, nullary_function>, int* >::type=0 ): impl(new impl_type::type>(thread_detail::decay_copy(boost::forward(f)))) {} nullary_function() : impl() { } nullary_function(nullary_function const& other) BOOST_NOEXCEPT : impl(other.impl) { } nullary_function(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT : #if defined BOOST_NO_CXX11_SMART_PTR impl(BOOST_THREAD_RV(other).impl) { BOOST_THREAD_RV(other).impl.reset(); } #else impl(boost::move(other.impl)) { } #endif ~nullary_function() { } nullary_function& operator=(BOOST_THREAD_COPY_ASSIGN_REF(nullary_function) other) BOOST_NOEXCEPT { impl=other.impl; return *this; } nullary_function& operator=(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT { #if defined BOOST_NO_CXX11_SMART_PTR impl=BOOST_THREAD_RV(other).impl; BOOST_THREAD_RV(other).impl.reset(); #else impl = boost::move(other.impl); #endif return *this; } void operator()() { if (impl) impl->call();} }; template class nullary_function { struct impl_base { virtual R call()=0; virtual ~impl_base() { } }; csbl::shared_ptr impl; template struct impl_type: impl_base { F f; #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES impl_type(F &f_) : f(f_) {} #endif impl_type(BOOST_THREAD_RV_REF(F) f_) : f(boost::move(f_)) {} R call() { return f(); } }; struct impl_type_ptr: impl_base { R (*f)(); impl_type_ptr(R (*f_)()) : f(f_) {} R call() { return f(); } }; public: BOOST_THREAD_COPYABLE_AND_MOVABLE(nullary_function) nullary_function(R (*f)()): impl(new impl_type_ptr(f)) {} #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES template nullary_function(F& f): impl(new impl_type(f)) {} #endif template nullary_function(BOOST_THREAD_RV_REF(F) f): impl(new impl_type::type>(thread_detail::decay_copy(boost::forward(f)))) {} nullary_function(nullary_function const& other) BOOST_NOEXCEPT : impl(other.impl) { } nullary_function(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT : #if defined BOOST_NO_CXX11_SMART_PTR impl(BOOST_THREAD_RV(other).impl) { BOOST_THREAD_RV(other).impl.reset(); } #else impl(boost::move(other.impl)) { } #endif nullary_function() : impl() { } ~nullary_function() { } nullary_function& operator=(BOOST_THREAD_COPY_ASSIGN_REF(nullary_function) other) BOOST_NOEXCEPT { impl=other.impl; return *this; } nullary_function& operator=(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT { #if defined BOOST_NO_CXX11_SMART_PTR impl=BOOST_THREAD_RV(other).impl; BOOST_THREAD_RV(other).impl.reset(); #else impl = boost::move(other.impl); #endif return *this; } R operator()() { if (impl) return impl->call(); else return R();} }; } BOOST_THREAD_DCL_MOVABLE_BEG(F) detail::nullary_function BOOST_THREAD_DCL_MOVABLE_END } #endif // header