update boost

linx64/include/boost/function/function_base.hpp

@@ -11,31 +11,27 @@
 #ifndef BOOST_FUNCTION_BASE_HEADER
 #define BOOST_FUNCTION_BASE_HEADER
 
-#include <stdexcept>
-#include <string>
-#include <memory>
-#include <new>
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/integer.hpp>
-#include <boost/type_index.hpp>
+#include <boost/function/function_fwd.hpp>
+#include <boost/function_equal.hpp>
+#include <boost/core/typeinfo.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/type_traits/has_trivial_copy.hpp>
 #include <boost/type_traits/has_trivial_destructor.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/composite_traits.hpp>
-#include <boost/ref.hpp>
 #include <boost/type_traits/conditional.hpp>
-#include <boost/config/workaround.hpp>
 #include <boost/type_traits/alignment_of.hpp>
-#ifndef BOOST_NO_SFINAE
 #include <boost/type_traits/enable_if.hpp>
-#else
 #include <boost/type_traits/integral_constant.hpp>
-#endif
-#include <boost/function_equal.hpp>
-#include <boost/function/function_fwd.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <stdexcept>
+#include <string>
+#include <memory>
+#include <new>
 
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@@ -74,7 +70,7 @@ namespace boost {
         // For pointers to std::type_info objects
         struct type_t {
           // (get_functor_type_tag, check_functor_type_tag).
-          const boost::typeindex::type_info* type;
+          const boost::core::typeinfo* type;
 
           // Whether the type is const-qualified.
           bool const_qualified;
@@ -86,12 +82,21 @@ namespace boost {
         typedef void (*func_ptr_t)();
         mutable func_ptr_t func_ptr;
 
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
+# pragma warning(push)
+# pragma warning(disable: 5243)
+#endif
+
         // For bound member pointers
         struct bound_memfunc_ptr_t {
           void (X::*memfunc_ptr)(int);
           void* obj_ptr;
         } bound_memfunc_ptr;
 
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
+# pragma warning(pop)
+#endif
+
         // For references to function objects. We explicitly keep
         // track of the cv-qualifiers on the object referenced.
         struct obj_ref_t {
@@ -195,7 +200,7 @@ namespace boost {
             {
               // Check whether we have the same type. We can add
               // cv-qualifiers, but we can't take them away.
-              if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
+              if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(F)
                   && (!in_buffer.members.obj_ref.is_const_qualified
                       || out_buffer.members.type.const_qualified)
                   && (!in_buffer.members.obj_ref.is_volatile_qualified
@@ -207,7 +212,7 @@ namespace boost {
             return;
 
           case get_functor_type_tag:
-            out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(F);
             out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
             out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
             return;
@@ -267,12 +272,12 @@ namespace boost {
           } else if (op == destroy_functor_tag)
             out_buffer.members.func_ptr = 0;
           else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
               out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
             else
               out_buffer.members.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
           }
@@ -299,12 +304,12 @@ namespace boost {
              (void)f; // suppress warning about the value of f not being used (MSVC)
              f->~Functor();
           } else if (op == check_functor_type_tag) {
-             if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+             if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
               out_buffer.members.obj_ptr = in_buffer.data;
             else
               out_buffer.members.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
           }
@@ -358,12 +363,12 @@ namespace boost {
             delete f;
             out_buffer.members.obj_ptr = 0;
           } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
               out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
             else
               out_buffer.members.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
           }
@@ -396,16 +401,12 @@ namespace boost {
                functor_manager_operation_type op)
         {
           typedef typename get_function_tag<functor_type>::type tag_type;
-          switch (op) {
-          case get_functor_type_tag:
-            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+          if (op == get_functor_type_tag) {
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
-            return;
-
-          default:
+          } else {
             manager(in_buffer, out_buffer, op, tag_type());
-            return;
           }
         }
       };
@@ -480,12 +481,12 @@ namespace boost {
             wrapper_allocator.deallocate(victim,1);
             out_buffer.members.obj_ptr = 0;
           } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
               out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
             else
               out_buffer.members.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
           }
@@ -510,16 +511,12 @@ namespace boost {
                functor_manager_operation_type op)
         {
           typedef typename get_function_tag<functor_type>::type tag_type;
-          switch (op) {
-          case get_functor_type_tag:
-            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+          if (op == get_functor_type_tag) {
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
-            return;
-
-          default:
+          } else {
             manager(in_buffer, out_buffer, op, tag_type());
-            return;
           }
         }
       };
@@ -615,9 +612,9 @@ public:
 
   /** Retrieve the type of the stored function object, or type_id<void>()
       if this is empty. */
-  const boost::typeindex::type_info& target_type() const
+  const boost::core::typeinfo& target_type() const
   {
-    if (!vtable) return boost::typeindex::type_id<void>().type_info();
+    if (!vtable) return BOOST_CORE_TYPEID(void);
 
     detail::function::function_buffer type;
     get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
@@ -630,7 +627,7 @@ public:
       if (!vtable) return 0;
 
       detail::function::function_buffer type_result;
-      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
       type_result.members.type.const_qualified = is_const<Functor>::value;
       type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
       get_vtable()->manager(functor, type_result,
@@ -644,7 +641,7 @@ public:
       if (!vtable) return 0;
 
       detail::function::function_buffer type_result;
-      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
       type_result.members.type.const_qualified = true;
       type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
       get_vtable()->manager(functor, type_result,