Update local boost version to version 1.62

[features.git] / 3rdparty / boost / boost / function / function_template.hpp

diff --git a/3rdparty/boost/boost/function/function_template.hpp b/3rdparty/boost/boost/function/function_template.hpp
index 211b81dbe3e28f6f7dc746fb0973432b0fb9e1f8..82c81d769733ab595760586d9de59a01c85e2922 100644 (file)
--- a/3rdparty/boost/boost/function/function_template.hpp
+++ b/3rdparty/boost/boost/function/function_template.hpp
@@ -16,7 +16,7 @@
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
 #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)
 
 
 #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)
         {
         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);
         }
       };
           return f(BOOST_FUNCTION_ARGS);
         }
       };


@@ -114,7 +114,7 @@ namespace boost {
                BOOST_FUNCTION_PARMS)
 
         {
                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));
         }
       };
           BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
         }
       };


@@ -132,9 +132,9 @@ namespace boost {
         {
           FunctionObj* f;
           if (function_allows_small_object_optimization<FunctionObj>::value)
         {
           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
           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);
         }
       };
           return (*f)(BOOST_FUNCTION_ARGS);
         }
       };


@@ -153,9 +153,9 @@ namespace boost {
         {
           FunctionObj* f;
           if (function_allows_small_object_optimization<FunctionObj>::value)
         {
           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
           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));
         }
       };
           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
         }
       };


@@ -171,8 +171,8 @@ namespace boost {
                         BOOST_FUNCTION_PARMS)
 
         {
                         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);
         }
       };
           return (*f)(BOOST_FUNCTION_ARGS);
         }
       };


@@ -189,8 +189,8 @@ namespace boost {
                BOOST_FUNCTION_PARMS)
 
         {
                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));
         }
       };
           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
         }
       };


@@ -208,8 +208,8 @@ namespace boost {
                         BOOST_FUNCTION_PARMS)
 
         {
                         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);
         }
       };
           return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
         }
       };


@@ -226,8 +226,8 @@ namespace boost {
                BOOST_FUNCTION_PARMS)
 
         {
                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));
         }
       };
           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
 
       /* 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
 
          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>
       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
         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>
             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());
         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>
         // 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
         {
         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>
         }
         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_());
         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>
 
         // Assign to a function object allocated on the heap.
         template<typename FunctionObj>

-        void 
+        void

         assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
         {
         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>
         }
         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;
         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);
           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>
         }
 
         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_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 {
                            mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {


@@ -613,7 +613,7 @@ namespace boost {
           }
         }
         template<typename FunctionObj,typename Allocator>
           }
         }
         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))) {
         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>
 
         // 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
         {
                   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>
           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());
                   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);
     }
     {
       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
 #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
     ~BOOST_FUNCTION_FUNCTION() { clear(); }
 
     result_type operator()(BOOST_FUNCTION_PARMS) const


@@ -840,12 +840,11 @@ namespace boost {
       BOOST_CATCH_END
       return *this;
     }
       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)
     {
 #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;
 
       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::
       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;
                         BOOST_FUNCTION_TEMPLATE_ARGS>
         handler_type;

-      
+

       typedef typename handler_type::invoker_type invoker_type;
       typedef typename handler_type::manager_type manager_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 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)) {
         { { &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);
             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;
     }
 
         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::
       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;
                          BOOST_FUNCTION_TEMPLATE_ARGS,
                          Allocator>
         handler_type;

-      
+

       typedef typename handler_type::invoker_type invoker_type;
       typedef typename handler_type::manager_type manager_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 };
 
       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 &&
         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);
             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;
     }
 
         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;
 
       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
   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);
   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;
   }
     self_type(static_cast<self_type&&>(f)).swap(*this);
     return *this;
   }

-#endif  
+#endif

 
   template<typename Functor>
 #ifndef BOOST_NO_SFINAE
 
   template<typename Functor>
 #ifndef BOOST_NO_SFINAE


@@ -1140,14 +1139,14 @@ public:
     self_type(f).swap(*this);
     return *this;
   }
     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;
   }
 #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
 };
 
 #undef BOOST_FUNCTION_PARTIAL_SPEC


@@ -1187,4 +1186,4 @@ public:
 
 #if defined(BOOST_MSVC)
 #   pragma warning( pop )
 
 #if defined(BOOST_MSVC)
 #   pragma warning( pop )

-#endif       
+#endif