diff options
author | Stefan Radomski <github@mintwerk.de> | 2017-01-13 11:58:41 (GMT) |
---|---|---|
committer | Stefan Radomski <github@mintwerk.de> | 2017-01-13 11:58:41 (GMT) |
commit | 0aa0fe08dc308c94379c47d0bf9745e341cb4c81 (patch) | |
tree | 514b009d3d1658af6988e059874014fc26fc0395 /contrib/src/boost/function/function_template.hpp | |
parent | 6952ce94491e4b7bc2acded0788e4609ca2c76e8 (diff) | |
download | uscxml-0aa0fe08dc308c94379c47d0bf9745e341cb4c81.zip uscxml-0aa0fe08dc308c94379c47d0bf9745e341cb4c81.tar.gz uscxml-0aa0fe08dc308c94379c47d0bf9745e341cb4c81.tar.bz2 |
Updated boost headers
Diffstat (limited to 'contrib/src/boost/function/function_template.hpp')
-rw-r--r-- | contrib/src/boost/function/function_template.hpp | 115 |
1 files changed, 57 insertions, 58 deletions
diff --git a/contrib/src/boost/function/function_template.hpp b/contrib/src/boost/function/function_template.hpp index 211b81d..82c81d7 100644 --- a/contrib/src/boost/function/function_template.hpp +++ b/contrib/src/boost/function/function_template.hpp @@ -16,7 +16,7 @@ #if defined(BOOST_MSVC) # pragma warning( push ) # pragma warning( disable : 4127 ) // "conditional expression is constant" -#endif +#endif #define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T) @@ -97,7 +97,7 @@ namespace boost { static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS) { - FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr); + FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr); return f(BOOST_FUNCTION_ARGS); } }; @@ -114,7 +114,7 @@ namespace boost { BOOST_FUNCTION_PARMS) { - FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr); + FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr); BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS)); } }; @@ -132,9 +132,9 @@ namespace boost { { FunctionObj* f; if (function_allows_small_object_optimization<FunctionObj>::value) - f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data); + f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data); else - f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); + f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr); return (*f)(BOOST_FUNCTION_ARGS); } }; @@ -153,9 +153,9 @@ namespace boost { { FunctionObj* f; if (function_allows_small_object_optimization<FunctionObj>::value) - f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data); + f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data); else - f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); + f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr); BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS)); } }; @@ -171,8 +171,8 @@ namespace boost { BOOST_FUNCTION_PARMS) { - FunctionObj* f = - reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); + FunctionObj* f = + reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr); return (*f)(BOOST_FUNCTION_ARGS); } }; @@ -189,8 +189,8 @@ namespace boost { BOOST_FUNCTION_PARMS) { - FunctionObj* f = - reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); + FunctionObj* f = + reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr); BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS)); } }; @@ -208,8 +208,8 @@ namespace boost { BOOST_FUNCTION_PARMS) { - MemberPtr* f = - reinterpret_cast<MemberPtr*>(&function_obj_ptr.data); + MemberPtr* f = + reinterpret_cast<MemberPtr*>(function_obj_ptr.data); return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS); } }; @@ -226,8 +226,8 @@ namespace boost { BOOST_FUNCTION_PARMS) { - MemberPtr* f = - reinterpret_cast<MemberPtr*>(&function_obj_ptr.data); + MemberPtr* f = + reinterpret_cast<MemberPtr*>(function_obj_ptr.data); BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS)); } }; @@ -322,7 +322,7 @@ namespace boost { /* Given the tag returned by get_function_tag, retrieve the actual invoker that will be used for the given function - object. + object. Each specialization contains an "apply" nested class template that accepts the function object, return type, function @@ -513,21 +513,21 @@ namespace boost { private: // Function pointers template<typename FunctionPtr> - bool + bool assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const { this->clear(functor); if (f) { // should be a reinterpret cast, but some compilers insist // on giving cv-qualifiers to free functions - functor.func_ptr = reinterpret_cast<void (*)()>(f); + functor.members.func_ptr = reinterpret_cast<void (*)()>(f); return true; } else { return false; } } template<typename FunctionPtr,typename Allocator> - bool + bool assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const { return assign_to(f,functor,function_ptr_tag()); @@ -566,13 +566,13 @@ namespace boost { // Function objects // Assign to a function object using the small object optimization template<typename FunctionObj> - void + void assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const { - new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f); + new (reinterpret_cast<void*>(functor.data)) FunctionObj(f); } template<typename FunctionObj,typename Allocator> - void + void assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const { assign_functor(f,functor,mpl::true_()); @@ -580,13 +580,13 @@ namespace boost { // Assign to a function object allocated on the heap. template<typename FunctionObj> - void + void assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const { - functor.obj_ptr = new FunctionObj(f); + functor.members.obj_ptr = new FunctionObj(f); } template<typename FunctionObj,typename Allocator> - void + void assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const { typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type; @@ -597,15 +597,15 @@ namespace boost { wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); wrapper_allocator.construct(copy, functor_wrapper_type(f,a)); functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy); - functor.obj_ptr = new_f; + functor.members.obj_ptr = new_f; } template<typename FunctionObj> - bool + bool assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const { if (!boost::detail::function::has_empty_target(boost::addressof(f))) { - assign_functor(f, functor, + assign_functor(f, functor, mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>()); return true; } else { @@ -613,7 +613,7 @@ namespace boost { } } template<typename FunctionObj,typename Allocator> - bool + bool assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const { if (!boost::detail::function::has_empty_target(boost::addressof(f))) { @@ -627,18 +627,18 @@ namespace boost { // Reference to a function object template<typename FunctionObj> - bool - assign_to(const reference_wrapper<FunctionObj>& f, + bool + assign_to(const reference_wrapper<FunctionObj>& f, function_buffer& functor, function_obj_ref_tag) const { - functor.obj_ref.obj_ptr = (void *)(f.get_pointer()); - functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value; - functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value; + functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer()); + functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value; + functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value; return true; } template<typename FunctionObj,typename Allocator> - bool - assign_to_a(const reference_wrapper<FunctionObj>& f, + bool + assign_to_a(const reference_wrapper<FunctionObj>& f, function_buffer& functor, Allocator, function_obj_ref_tag) const { return assign_to(f,functor,function_obj_ref_tag()); @@ -752,14 +752,14 @@ namespace boost { { this->assign_to_own(f); } - + #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base() { this->move_assign(f); } #endif - + ~BOOST_FUNCTION_FUNCTION() { clear(); } result_type operator()(BOOST_FUNCTION_PARMS) const @@ -840,12 +840,11 @@ namespace boost { BOOST_CATCH_END return *this; } - + #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES // Move assignment from another BOOST_FUNCTION_FUNCTION BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f) { - if (&f == this) return *this; @@ -922,10 +921,10 @@ namespace boost { typedef typename boost::detail::function::get_function_tag<Functor>::type tag; typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker; typedef typename get_invoker:: - template apply<Functor, R BOOST_FUNCTION_COMMA + template apply<Functor, R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> handler_type; - + typedef typename handler_type::invoker_type invoker_type; typedef typename handler_type::manager_type manager_type; @@ -933,7 +932,7 @@ namespace boost { // static initialization. Otherwise, we will have a race // condition here in multi-threaded code. See // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/. - static const vtable_type stored_vtable = + static const vtable_type stored_vtable = { { &manager_type::manage }, &invoker_type::invoke }; if (stored_vtable.assign_to(f, functor)) { @@ -944,7 +943,7 @@ namespace boost { boost::detail::function::function_allows_small_object_optimization<Functor>::value) value |= static_cast<std::size_t>(0x01); vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value); - } else + } else vtable = 0; } @@ -956,11 +955,11 @@ namespace boost { typedef typename boost::detail::function::get_function_tag<Functor>::type tag; typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker; typedef typename get_invoker:: - template apply_a<Functor, R BOOST_FUNCTION_COMMA + template apply_a<Functor, R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator> handler_type; - + typedef typename handler_type::invoker_type invoker_type; typedef typename handler_type::manager_type manager_type; @@ -971,7 +970,7 @@ namespace boost { static const vtable_type stored_vtable = { { &manager_type::manage }, &invoker_type::invoke }; - if (stored_vtable.assign_to_a(f, functor, a)) { + if (stored_vtable.assign_to_a(f, functor, a)) { std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base); // coverity[pointless_expression]: suppress coverity warnings on apparant if(const). if (boost::has_trivial_copy_constructor<Functor>::value && @@ -979,15 +978,15 @@ namespace boost { boost::detail::function::function_allows_small_object_optimization<Functor>::value) value |= static_cast<std::size_t>(0x01); vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value); - } else + } else vtable = 0; } - // Moves the value from the specified argument to *this. If the argument - // has its function object allocated on the heap, move_assign will pass - // its buffer to *this, and set the argument's buffer pointer to NULL. - void move_assign(BOOST_FUNCTION_FUNCTION& f) - { + // Moves the value from the specified argument to *this. If the argument + // has its function object allocated on the heap, move_assign will pass + // its buffer to *this, and set the argument's buffer pointer to NULL. + void move_assign(BOOST_FUNCTION_FUNCTION& f) + { if (&f == this) return; @@ -1098,7 +1097,7 @@ public: function(self_type&& f): base_type(static_cast<base_type&&>(f)){} function(base_type&& f): base_type(static_cast<base_type&&>(f)){} #endif - + self_type& operator=(const self_type& f) { self_type(f).swap(*this); @@ -1111,7 +1110,7 @@ public: self_type(static_cast<self_type&&>(f)).swap(*this); return *this; } -#endif +#endif template<typename Functor> #ifndef BOOST_NO_SFINAE @@ -1140,14 +1139,14 @@ public: self_type(f).swap(*this); return *this; } - + #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES self_type& operator=(base_type&& f) { self_type(static_cast<base_type&&>(f)).swap(*this); return *this; } -#endif +#endif }; #undef BOOST_FUNCTION_PARTIAL_SPEC @@ -1187,4 +1186,4 @@ public: #if defined(BOOST_MSVC) # pragma warning( pop ) -#endif +#endif |