From 7b3cbf3d37020fec5a25c50df4e94d65de9ba7c0 Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Wed, 27 May 2015 18:13:52 -0300
Subject: [PATCH 1/9] Add some missing serialization #includes

---
 hpx/components/iostreams/server/output_stream.hpp | 3 ++-
 hpx/runtime/agas/component_namespace.hpp          | 1 +
 hpx/runtime/agas/locality_namespace.hpp           | 1 +
 hpx/runtime/agas/primary_namespace.hpp            | 1 +
 hpx/runtime/agas/server/component_namespace.hpp   | 1 +
 hpx/runtime/agas/server/locality_namespace.hpp    | 1 +
 hpx/runtime/agas/server/primary_namespace.hpp     | 1 +
 hpx/runtime/agas/server/symbol_namespace.hpp      | 1 +
 hpx/runtime/agas/symbol_namespace.hpp             | 1 +
 hpx/runtime/parcelset/locality.hpp                | 1 +
 10 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/hpx/components/iostreams/server/output_stream.hpp b/hpx/components/iostreams/server/output_stream.hpp
index b0d117efcc57..32db2b351824 100644
--- a/hpx/components/iostreams/server/output_stream.hpp
+++ b/hpx/components/iostreams/server/output_stream.hpp
@@ -8,8 +8,9 @@
 #define HPX_4AFE0EEA_49F8_4F4C_8945_7B55BF395DA0
 
 #include <hpx/hpx_fwd.hpp>
-#include <hpx/runtime/components/server/managed_component_base.hpp>
 #include <hpx/runtime/actions/component_action.hpp>
+#include <hpx/runtime/components/server/managed_component_base.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 
 #include <hpx/components/iostreams/export_definitions.hpp>
 #include <hpx/components/iostreams/write_functions.hpp>
diff --git a/hpx/runtime/agas/component_namespace.hpp b/hpx/runtime/agas/component_namespace.hpp
index b9edeed57649..950f3734840b 100644
--- a/hpx/runtime/agas/component_namespace.hpp
+++ b/hpx/runtime/agas/component_namespace.hpp
@@ -10,6 +10,7 @@
 
 #include <hpx/include/client.hpp>
 #include <hpx/runtime/agas/stubs/component_namespace.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 
 namespace hpx { namespace agas
 {
diff --git a/hpx/runtime/agas/locality_namespace.hpp b/hpx/runtime/agas/locality_namespace.hpp
index 41c004bfc127..2131dc5d28d1 100644
--- a/hpx/runtime/agas/locality_namespace.hpp
+++ b/hpx/runtime/agas/locality_namespace.hpp
@@ -11,6 +11,7 @@
 
 #include <hpx/include/client.hpp>
 #include <hpx/runtime/agas/stubs/locality_namespace.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 
 namespace hpx { namespace agas
 {
diff --git a/hpx/runtime/agas/primary_namespace.hpp b/hpx/runtime/agas/primary_namespace.hpp
index ae350517cdfe..457b1e0b3db4 100644
--- a/hpx/runtime/agas/primary_namespace.hpp
+++ b/hpx/runtime/agas/primary_namespace.hpp
@@ -10,6 +10,7 @@
 
 #include <hpx/include/client.hpp>
 #include <hpx/runtime/agas/stubs/primary_namespace.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 
 namespace hpx { namespace agas
 {
diff --git a/hpx/runtime/agas/server/component_namespace.hpp b/hpx/runtime/agas/server/component_namespace.hpp
index b513f5a421fa..f9e7505648d3 100644
--- a/hpx/runtime/agas/server/component_namespace.hpp
+++ b/hpx/runtime/agas/server/component_namespace.hpp
@@ -16,6 +16,7 @@
 #include <hpx/runtime/agas/namespace_action_code.hpp>
 #include <hpx/runtime/components/component_type.hpp>
 #include <hpx/runtime/components/server/fixed_component_base.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 #include <hpx/util/insert_checked.hpp>
 #include <hpx/util/logging.hpp>
 #include <hpx/util/function.hpp>
diff --git a/hpx/runtime/agas/server/locality_namespace.hpp b/hpx/runtime/agas/server/locality_namespace.hpp
index e60d433505ce..efa914c5fb85 100644
--- a/hpx/runtime/agas/server/locality_namespace.hpp
+++ b/hpx/runtime/agas/server/locality_namespace.hpp
@@ -18,6 +18,7 @@
 #include <hpx/runtime/components/component_type.hpp>
 #include <hpx/runtime/components/server/fixed_component_base.hpp>
 #include <hpx/runtime/parcelset/locality.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 #include <hpx/util/insert_checked.hpp>
 #include <hpx/util/logging.hpp>
 #include <hpx/util/high_resolution_clock.hpp>
diff --git a/hpx/runtime/agas/server/primary_namespace.hpp b/hpx/runtime/agas/server/primary_namespace.hpp
index ff7d87926a22..05cc2e2aafbb 100644
--- a/hpx/runtime/agas/server/primary_namespace.hpp
+++ b/hpx/runtime/agas/server/primary_namespace.hpp
@@ -17,6 +17,7 @@
 #include <hpx/runtime/agas/namespace_action_code.hpp>
 #include <hpx/runtime/components/component_type.hpp>
 #include <hpx/runtime/components/server/fixed_component_base.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 #include <hpx/util/insert_checked.hpp>
 #include <hpx/util/logging.hpp>
 #include <hpx/util/high_resolution_clock.hpp>
diff --git a/hpx/runtime/agas/server/symbol_namespace.hpp b/hpx/runtime/agas/server/symbol_namespace.hpp
index 5e5395e949a1..9b244bd0dcd0 100644
--- a/hpx/runtime/agas/server/symbol_namespace.hpp
+++ b/hpx/runtime/agas/server/symbol_namespace.hpp
@@ -15,6 +15,7 @@
 #include <hpx/runtime/agas/namespace_action_code.hpp>
 #include <hpx/runtime/components/component_type.hpp>
 #include <hpx/runtime/components/server/fixed_component_base.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 #include <hpx/util/insert_checked.hpp>
 #include <hpx/util/logging.hpp>
 #include <hpx/util/function.hpp>
diff --git a/hpx/runtime/agas/symbol_namespace.hpp b/hpx/runtime/agas/symbol_namespace.hpp
index 6649209b6c40..40e0368fc280 100644
--- a/hpx/runtime/agas/symbol_namespace.hpp
+++ b/hpx/runtime/agas/symbol_namespace.hpp
@@ -10,6 +10,7 @@
 
 #include <hpx/include/client.hpp>
 #include <hpx/runtime/agas/stubs/symbol_namespace.hpp>
+#include <hpx/runtime/serialization/vector.hpp>
 
 namespace hpx { namespace agas
 {
diff --git a/hpx/runtime/parcelset/locality.hpp b/hpx/runtime/parcelset/locality.hpp
index 59a8e1fb12f3..a253362e42ff 100644
--- a/hpx/runtime/parcelset/locality.hpp
+++ b/hpx/runtime/parcelset/locality.hpp
@@ -12,6 +12,7 @@
 
 #include <hpx/hpx_fwd.hpp>
 #include <hpx/exception.hpp>
+#include <hpx/runtime/serialization/map.hpp>
 #include <hpx/util/safe_bool.hpp>
 
 #include <boost/config.hpp>

From 1c43e938716f8ccc39b2bc1f8723e68883d4a73e Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Wed, 27 May 2015 18:13:59 -0300
Subject: [PATCH 2/9] Remove tuple dependency on serialize_sequence

Reimplement tuple serialization support as a pack expansion. Minimize dependencies on runtime/serialization.
---
 hpx/runtime/actions/transfer_action.hpp |  5 ++--
 hpx/util/tuple.hpp                      | 37 ++++++++++++-------------
 2 files changed, 20 insertions(+), 22 deletions(-)

diff --git a/hpx/runtime/actions/transfer_action.hpp b/hpx/runtime/actions/transfer_action.hpp
index b3f2472a6bc4..200da296a63a 100644
--- a/hpx/runtime/actions/transfer_action.hpp
+++ b/hpx/runtime/actions/transfer_action.hpp
@@ -16,7 +16,6 @@
 #include <hpx/runtime/actions/continuation.hpp>
 #include <hpx/runtime/threads/thread_helpers.hpp>
 #include <hpx/runtime/threads/thread_init_data.hpp>
-#include <hpx/runtime/serialization/serialize_sequence.hpp>
 #include <hpx/runtime/serialization/output_archive.hpp>
 #include <hpx/runtime/serialization/input_archive.hpp>
 #include <hpx/runtime/serialization/base_object.hpp>
@@ -382,7 +381,7 @@ namespace hpx { namespace actions
         // loading ...
         void serialize(hpx::serialization::input_archive & ar)
         {
-            serialization::serialize_sequence(ar, arguments_);
+            ar >> arguments_;
 
             // Always serialize the parent information to maintain binary
             // compatibility on the wire.
@@ -402,7 +401,7 @@ namespace hpx { namespace actions
         // saving ...
         void serialize(hpx::serialization::output_archive & ar)
         {
-            serialization::serialize_sequence(ar, arguments_);
+            ar << arguments_;
 
             // Always serialize the parent information to maintain binary
             // compatibility on the wire.
diff --git a/hpx/util/tuple.hpp b/hpx/util/tuple.hpp
index a41e14c76f02..1d6c631f94c4 100644
--- a/hpx/util/tuple.hpp
+++ b/hpx/util/tuple.hpp
@@ -1,6 +1,6 @@
 //  Copyright (c) 2011-2013 Thomas Heller
 //  Copyright (c) 2011-2013 Hartmut Kaiser
-//  Copyright (c) 2013 Agustin Berge
+//  Copyright (c) 2013-2015 Agustin Berge
 //
 //  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)
@@ -9,8 +9,6 @@
 #define HPX_UTIL_TUPLE_HPP
 
 #include <hpx/config.hpp>
-#include <hpx/runtime/serialization/serialize.hpp>
-#include <hpx/runtime/serialization/serialize_sequence.hpp>
 #include <hpx/traits/is_bitwise_serializable.hpp>
 #include <hpx/util/decay.hpp>
 #include <hpx/util/move.hpp>
@@ -266,6 +264,15 @@ namespace hpx { namespace util
                         I, typename detail::at_index<I, Ts...>::type
                     > const&>(*this).value();
             }
+
+            template <typename Archive>
+            void serialize(Archive& ar, unsigned int const version)
+            {
+                int const _sequencer[] = {
+                    ((ar & this->get<Is>()), 0)...
+                };
+                (void)_sequencer;
+            }
         };
 
         ///////////////////////////////////////////////////////////////////////
@@ -940,34 +947,26 @@ namespace hpx { namespace traits
     {};
 }}
 
-namespace hpx { namespace serialization {
-
+namespace hpx { namespace serialization
+{
     ///////////////////////////////////////////////////////////////////////////
     template <typename Archive, typename ...Ts>
     BOOST_FORCEINLINE
     void serialize(
         Archive& ar
       , ::hpx::util::tuple<Ts...>& t
-      , unsigned int const version
+      , unsigned int const version = 0
     )
     {
-        ::hpx::serialization::serialize_sequence(ar, t);
+        t._impl.serialize(ar, version);
     }
 
-    // These are needed to avoid conflicts with serialize_empty_type
+    template <typename Archive>
     BOOST_FORCEINLINE
     void serialize(
-        serialization::output_archive&
-      , ::hpx::util::tuple<>&
-      , unsigned int const
-    )
-    {}
-
-    BOOST_FORCEINLINE
-    void serialize(
-        serialization::input_archive&
-      , ::hpx::util::tuple<>&
-      , unsigned int const
+        Archive& ar
+      , ::hpx::util::tuple<>& t
+      , unsigned int const version = 0
     )
     {}
 }}

From ed52f4bd692f46dcf2662cd8df24d0bc25eaa4f7 Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Wed, 27 May 2015 18:41:04 -0300
Subject: [PATCH 3/9] Reduce tuple dependency on fusion

---
 hpx/util/detail/fusion_adapt_tuple.hpp | 321 ++++++++++++++++---------
 1 file changed, 204 insertions(+), 117 deletions(-)

diff --git a/hpx/util/detail/fusion_adapt_tuple.hpp b/hpx/util/detail/fusion_adapt_tuple.hpp
index 1f41d36e6be5..baac134c9d52 100644
--- a/hpx/util/detail/fusion_adapt_tuple.hpp
+++ b/hpx/util/detail/fusion_adapt_tuple.hpp
@@ -1,5 +1,5 @@
 //  Copyright (c) 2001-2011 Joel de Guzman
-//  Copyright (c) 2013 Agustin Berge
+//  Copyright (c) 2013-2015 Agustin Berge
 //
 //  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)
@@ -10,9 +10,6 @@
 #include <hpx/config.hpp>
 #include <hpx/util/tuple.hpp>
 
-#include <boost/preprocessor/min.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
-
 ///////////////////////////////////////////////////////////////////////////////
 /// tag_of.hpp
 #include <boost/fusion/support/tag_of_fwd.hpp>
@@ -29,11 +26,9 @@ namespace boost { namespace fusion
     namespace traits
     {
         template <typename ...Ts>
-        struct tag_of<
-            hpx::util::tuple<Ts...>
-        >
+        struct tag_of< ::hpx::util::tuple<Ts...>, void>
         {
-            typedef hpx::util::detail::tuple_tag type;
+            typedef ::hpx::util::detail::tuple_tag type;
         };
     }
 }}
@@ -44,17 +39,13 @@ namespace boost { namespace mpl
     struct sequence_tag;
 
     template <typename ...Ts>
-    struct sequence_tag<hpx::util::tuple<
-        Ts...>
-    >
+    struct sequence_tag< ::hpx::util::tuple<Ts...> >
     {
         typedef fusion::fusion_sequence_tag type;
     };
 
     template <typename ...Ts>
-    struct sequence_tag<hpx::util::tuple<
-        Ts...> const
-    >
+    struct sequence_tag< ::hpx::util::tuple<Ts...> const>
     {
         typedef fusion::fusion_sequence_tag type;
     };
@@ -62,21 +53,21 @@ namespace boost { namespace mpl
 
 ///////////////////////////////////////////////////////////////////////////////
 /// is_sequence_impl.hpp
-#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 
 namespace boost { namespace fusion
 {
     namespace extension
     {
-        template<typename Tag>
+        template <typename Tag>
         struct is_sequence_impl;
 
-        template<>
-        struct is_sequence_impl<hpx::util::detail::tuple_tag>
+        template <>
+        struct is_sequence_impl< ::hpx::util::detail::tuple_tag>
         {
-            template<typename Sequence>
+            template <typename Sequence>
             struct apply
-              : mpl::true_
+              : boost::true_type
             {};
         };
     }
@@ -84,21 +75,21 @@ namespace boost { namespace fusion
 
 ///////////////////////////////////////////////////////////////////////////////
 /// is_view_impl.hpp
-#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 
 namespace boost { namespace fusion
 {
     namespace extension
     {
-        template<typename Tag>
+        template <typename Tag>
         struct is_view_impl;
 
-        template<>
-        struct is_view_impl<hpx::util::detail::tuple_tag>
+        template <>
+        struct is_view_impl< ::hpx::util::detail::tuple_tag>
         {
-            template<typename T>
+            template <typename T>
             struct apply
-              : mpl::false_
+              : boost::false_type
             {};
         };
     }
@@ -113,13 +104,13 @@ namespace boost { namespace fusion
 
     namespace extension
     {
-        template<typename T>
+        template <typename T>
         struct category_of_impl;
 
-        template<>
-        struct category_of_impl<hpx::util::detail::tuple_tag>
+        template <>
+        struct category_of_impl< ::hpx::util::detail::tuple_tag>
         {
-            template<typename T>
+            template <typename T>
             struct apply
             {
                 typedef random_access_traversal_tag type;
@@ -129,99 +120,190 @@ namespace boost { namespace fusion
 }}
 
 ///////////////////////////////////////////////////////////////////////////////
-/// hpx_tuple_iterator.hpp
-#include <boost/fusion/iterator/iterator_facade.hpp>
-#include <boost/mpl/int.hpp>
+/// tuple_iterator.hpp
+#include <boost/fusion/support/tag_of_fwd.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <cstddef>
+#include <type_traits>
+
+namespace hpx { namespace util { namespace detail
+{
+    struct tuple_iterator_tag;
+
+    template <typename Tuple, std::size_t Index>
+    struct tuple_iterator
+    {
+        typedef Tuple tuple_type;
+        static std::size_t const index = Index;
+        typedef tuple_iterator<Tuple const, Index> identity;
+
+        explicit tuple_iterator(Tuple& tuple)
+          : tuple_(tuple)
+        {}
+
+        Tuple& tuple_;
+    };
+
+    template <typename Tuple, std::size_t Index>
+    typename tuple_element<Index, Tuple>::type&
+    operator*(tuple_iterator<Tuple, Index> i)
+    {
+        return util::get<Index>(i.tuple_);
+    }
+}}}
 
 namespace boost { namespace fusion
 {
-    struct random_access_traversal_tag;
+    namespace traits
+    {
+        template <typename Tuple, std::size_t Index>
+        struct tag_of< ::hpx::util::detail::tuple_iterator<Tuple, Index>, void>
+        {
+            typedef ::hpx::util::detail::tuple_iterator_tag type;
+        };
+    }
 
-    template <typename Tuple, int Index>
-    struct hpx_tuple_iterator_identity;
+    struct random_access_traversal_tag;
 
-    template <typename Tuple, int Index>
-    struct hpx_tuple_iterator
-      : iterator_facade<
-            hpx_tuple_iterator<Tuple, Index>
-          , random_access_traversal_tag
-        >
+    namespace extension
     {
-        typedef Tuple tuple_type;
-        static int const index = Index;
-        typedef hpx_tuple_iterator_identity<
-            typename add_const<Tuple>::type, Index>
-            identity;
-
-        explicit hpx_tuple_iterator(Tuple& tuple_)
-          : tuple(tuple_) {}
-
-        Tuple& tuple;
-
-        template <typename Iterator>
-        struct value_of
-          : hpx::util::tuple_element<
-                Iterator::index
-              , typename Iterator::tuple_type
-            >
-        {};
-
-        template <typename Iterator>
-        struct deref
+        template <typename T>
+        struct category_of_impl;
+
+        template <>
+        struct category_of_impl< ::hpx::util::detail::tuple_iterator_tag>
+        {
+            template <typename T>
+            struct apply
+            {
+                typedef random_access_traversal_tag type;
+            };
+        };
+
+        template <typename Tag>
+        struct value_of_impl;
+
+        template <>
+        struct value_of_impl< ::hpx::util::detail::tuple_iterator_tag>
         {
-            typedef typename
-                hpx::util::tuple_element<
+            template <typename Iterator>
+            struct apply
+              : ::hpx::util::tuple_element<
                     Iterator::index
                   , typename Iterator::tuple_type
-                >::type
-                element;
-            typedef element& type;
+                >
+            {};
+        };
+
+        template <typename Tag>
+        struct deref_impl;
 
-            static type call(Iterator const& iter)
+        template <>
+        struct deref_impl< ::hpx::util::detail::tuple_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
             {
-                return hpx::util::get<Index>(iter.tuple);
-            }
+                static int const index = Iterator::index;
+                typedef typename
+                    ::hpx::util::tuple_element<
+                        Iterator::index
+                      , typename Iterator::tuple_type
+                    >::type
+                    element;
+                typedef element& type;
+
+                static type call(Iterator const& iter)
+                {
+                    return ::hpx::util::get<index>(iter.tuple_);
+                }
+            };
         };
 
-        template <typename Iterator, typename I>
-        struct advance
-        {
-            static int const index = Iterator::index;
-            typedef typename Iterator::tuple_type tuple_type;
-            typedef hpx_tuple_iterator<tuple_type, index+I::value> type;
+        template <typename Tag>
+        struct advance_impl;
 
-            static type call(Iterator const& i)
+        template <>
+        struct advance_impl< ::hpx::util::detail::tuple_iterator_tag>
+        {
+            template <typename Iterator, typename I>
+            struct apply
             {
-                return type(i.tuple);
-            }
+                static int const index = Iterator::index;
+                typedef typename Iterator::tuple_type tuple_type;
+                typedef ::hpx::util::detail::tuple_iterator<
+                    tuple_type, index + I::value> type;
+
+                static type call(Iterator const& i)
+                {
+                    return type(i.tuple_);
+                }
+            };
         };
 
-        template <typename Iterator>
-        struct next
-          : advance<Iterator, mpl::int_<1> >
-        {};
+        template <typename Tag>
+        struct next_impl;
 
-        template <typename Iterator>
-        struct prior
-          : advance<Iterator, mpl::int_<-1> >
-        {};
+        template <>
+        struct next_impl< ::hpx::util::detail::tuple_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+              : advance_impl< ::hpx::util::detail::tuple_iterator_tag>::
+                    template apply<Iterator, boost::integral_constant<int, 1> >
+            {};
+        };
 
-        template <typename I1, typename I2>
-        struct equal_to
-          : is_same<typename I1::identity, typename I2::identity>
-        {};
+        template <typename Tag>
+        struct prior_impl;
 
-        template <typename First, typename Last>
-        struct distance
+        template <>
+        struct prior_impl< ::hpx::util::detail::tuple_iterator_tag>
         {
-            typedef mpl::int_<Last::index-First::index> type;
+            template <typename Iterator>
+            struct apply
+              : advance_impl< ::hpx::util::detail::tuple_iterator_tag>::
+                    template apply<Iterator, boost::integral_constant<int, -1> >
+            {};
+        };
+
+        template <typename Tag>
+        struct equal_to_impl;
+
+        template <>
+        struct equal_to_impl< ::hpx::util::detail::tuple_iterator_tag>
+        {
+            template <typename I1, typename I2>
+            struct apply
+              : boost::integral_constant<
+                    bool,
+                    std::is_same<typename I1::identity, typename I2::identity>::value
+                >
+            {};
+        };
 
-            static type call(First const&, Last const&)
+        template <typename Tag>
+        struct distance_impl;
+
+        template <>
+        struct distance_impl< ::hpx::util::detail::tuple_iterator_tag>
+        {
+            template <typename First, typename Last>
+            struct apply
             {
-                return type();
-            }
+                typedef boost::integral_constant<
+                    int,
+                    Last::index - First::index
+                > type;
+
+                static type call(First const&, Last const&)
+                {
+                    return type();
+                }
+            };
         };
-    };
+    }
 }}
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -231,23 +313,23 @@ namespace boost { namespace fusion
 {
     namespace extension
     {
-        template<typename T>
+        template <typename T>
         struct at_impl;
 
         template <>
-        struct at_impl<hpx::util::detail::tuple_tag>
+        struct at_impl< ::hpx::util::detail::tuple_tag>
         {
             template <typename Sequence, typename I>
             struct apply
             {
                 typedef typename
-                    hpx::util::tuple_element<I::value, Sequence>::type
+                    ::hpx::util::tuple_element<I::value, Sequence>::type
                     element;
                 typedef element& type;
 
                 static type call(Sequence& seq)
                 {
-                    return hpx::util::get<I::value>(seq);
+                    return ::hpx::util::get<I::value>(seq);
                 }
             };
         };
@@ -261,16 +343,16 @@ namespace boost { namespace fusion
 {
     namespace extension
     {
-        template<typename T>
+        template <typename T>
         struct begin_impl;
 
         template <>
-        struct begin_impl<hpx::util::detail::tuple_tag>
+        struct begin_impl< ::hpx::util::detail::tuple_tag>
         {
             template <typename Sequence>
             struct apply
             {
-                typedef hpx_tuple_iterator<Sequence, 0> type;
+                typedef ::hpx::util::detail::tuple_iterator<Sequence, 0> type;
 
                 static type call(Sequence& v)
                 {
@@ -288,17 +370,17 @@ namespace boost { namespace fusion
 {
     namespace extension
     {
-        template<typename T>
+        template <typename T>
         struct end_impl;
 
         template <>
-        struct end_impl<hpx::util::detail::tuple_tag>
+        struct end_impl< ::hpx::util::detail::tuple_tag>
         {
             template <typename Sequence>
             struct apply
             {
-                static int const size = hpx::util::tuple_size<Sequence>::value;
-                typedef hpx_tuple_iterator<Sequence, size> type;
+                static int const size = ::hpx::util::tuple_size<Sequence>::value;
+                typedef ::hpx::util::detail::tuple_iterator<Sequence, size> type;
 
                 static type call(Sequence& v)
                 {
@@ -311,21 +393,26 @@ namespace boost { namespace fusion
 
 ///////////////////////////////////////////////////////////////////////////////
 /// size_impl.hpp
-#include <boost/mpl/int.hpp>
+#include <boost/mpl/size_t.hpp>
+
+#include <cstddef>
 
 namespace boost { namespace fusion
 {
     namespace extension
     {
-        template<typename T>
+        template <typename T>
         struct size_impl;
 
         template <>
-        struct size_impl<hpx::util::detail::tuple_tag>
+        struct size_impl< ::hpx::util::detail::tuple_tag>
         {
             template <typename Sequence>
             struct apply
-              : mpl::int_<hpx::util::tuple_size<Sequence>::value>
+              : boost::integral_constant<
+                    std::size_t,
+                    ::hpx::util::tuple_size<Sequence>::value
+                >
             {};
         };
     }
@@ -337,15 +424,15 @@ namespace boost { namespace fusion
 {
     namespace extension
     {
-        template<typename T>
+        template <typename T>
         struct value_at_impl;
 
         template <>
-        struct value_at_impl<hpx::util::detail::tuple_tag>
+        struct value_at_impl< ::hpx::util::detail::tuple_tag>
         {
             template <typename Sequence, typename I>
             struct apply
-              : hpx::util::tuple_element<I::value, Sequence>
+              : ::hpx::util::tuple_element<I::value, Sequence>
             {};
         };
     }

From 7dd7b91a1e698d45e893149a60487898eddfb18d Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Wed, 27 May 2015 21:09:14 -0300
Subject: [PATCH 4/9] Remove tuple dependency on qualify_as

---
 hpx/util/tuple.hpp | 61 +++++++++++++++++++++++++---------------------
 1 file changed, 33 insertions(+), 28 deletions(-)

diff --git a/hpx/util/tuple.hpp b/hpx/util/tuple.hpp
index 1d6c631f94c4..9c466a9ddae8 100644
--- a/hpx/util/tuple.hpp
+++ b/hpx/util/tuple.hpp
@@ -13,7 +13,6 @@
 #include <hpx/util/decay.hpp>
 #include <hpx/util/move.hpp>
 #include <hpx/util/detail/pack.hpp>
-#include <hpx/util/detail/qualify_as.hpp>
 
 #include <boost/array.hpp>
 #include <boost/mpl/bool.hpp>
@@ -680,11 +679,11 @@ namespace hpx { namespace util
           : boost::mpl::size_t<Size>
         {};
 
-        template <std::size_t Size, typename HeadTuple, typename ...TailTuples>
+        template <std::size_t Size, typename Head, typename ...Tail>
         struct tuple_cat_size_impl<
-            Size, detail::pack<HeadTuple, TailTuples...>
+            Size, detail::pack<Head, Tail...>
         > : tuple_cat_size_impl<
-                (Size + tuple_size<HeadTuple>::value), detail::pack<TailTuples...>
+                (Size + tuple_size<Head>::value), detail::pack<Tail...>
             >
         {};
 
@@ -697,51 +696,57 @@ namespace hpx { namespace util
         template <std::size_t I, typename Tuples, typename Enable = void>
         struct tuple_cat_element;
 
-        template <std::size_t I, typename HeadTuple, typename ...TailTuples>
+        template <std::size_t I, typename Head, typename ...Tail>
         struct tuple_cat_element<
-            I, detail::pack<HeadTuple, TailTuples...>
+            I, detail::pack<Head, Tail...>
           , typename boost::enable_if_c<
-                (I < tuple_size<HeadTuple>::value)
+                (I < tuple_size<Head>::value)
             >::type
-        > : tuple_element<I, HeadTuple>
+        > : tuple_element<I, Head>
         {
-            typedef tuple_element<I, HeadTuple> base_type;
+            typedef tuple_element<I, Head> base_type;
 
-            template <typename HeadTuple_, typename ...TailTuples_>
             static BOOST_CONSTEXPR BOOST_FORCEINLINE
-            typename detail::qualify_as<
-                typename base_type::type
-              , HeadTuple_&
-            >::type
-            get(HeadTuple_& head, TailTuples_& ...tail) BOOST_NOEXCEPT
+            typename base_type::type&
+            get(Head& head, Tail& ...tail) BOOST_NOEXCEPT
+            {
+                return base_type::get(head);
+            }
+
+            static BOOST_CONSTEXPR BOOST_FORCEINLINE
+            typename base_type::type const&
+            get(Head const& head, Tail& ...tail) BOOST_NOEXCEPT
             {
                 return base_type::get(head);
             }
         };
 
-        template <std::size_t I, typename HeadTuple, typename ...TailTuples>
+        template <std::size_t I, typename Head, typename ...Tail>
         struct tuple_cat_element<
-            I, detail::pack<HeadTuple, TailTuples...>
+            I, detail::pack<Head, Tail...>
           , typename boost::enable_if_c<
-                (I >= tuple_size<HeadTuple>::value)
+                (I >= tuple_size<Head>::value)
             >::type
         > : tuple_cat_element<
-                I - tuple_size<HeadTuple>::value
-              , detail::pack<TailTuples...>
+                I - tuple_size<Head>::value
+              , detail::pack<Tail...>
             >
         {
             typedef tuple_cat_element<
-                I - tuple_size<HeadTuple>::value
-              , detail::pack<TailTuples...>
+                I - tuple_size<Head>::value
+              , detail::pack<Tail...>
             > base_type;
 
-            template <typename HeadTuple_, typename ...TailTuples_>
             static BOOST_CONSTEXPR BOOST_FORCEINLINE
-            typename detail::qualify_as<
-                typename base_type::type
-              , HeadTuple_&
-            >::type
-            get(HeadTuple_& head, TailTuples_& ...tail) BOOST_NOEXCEPT
+            typename base_type::type&
+            get(Head& head, Tail& ...tail) BOOST_NOEXCEPT
+            {
+                return base_type::get(tail...);
+            }
+
+            static BOOST_CONSTEXPR BOOST_FORCEINLINE
+            typename base_type::type const&
+            get(Head const& head, Tail& ...tail) BOOST_NOEXCEPT
             {
                 return base_type::get(tail...);
             }

From 5cfc3d2067cb1e34b07478dae5ad802815e69057 Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Wed, 27 May 2015 21:12:03 -0300
Subject: [PATCH 5/9] Remove tuple dependency on boost::swap

---
 hpx/util/tuple.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hpx/util/tuple.hpp b/hpx/util/tuple.hpp
index 9c466a9ddae8..2a2b89f5103a 100644
--- a/hpx/util/tuple.hpp
+++ b/hpx/util/tuple.hpp
@@ -24,7 +24,6 @@
 #include <boost/type_traits/is_empty.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/utility/swap.hpp>
 
 #include <cstddef> // for size_t
 #include <utility>
@@ -240,8 +239,9 @@ namespace hpx { namespace util
 
             void swap(tuple_impl& other)
             {
+                using std::swap;
                 int const _sequencer[] = {
-                    ((boost::swap(this->get<Is>(), other.template get<Is>())), 0)...
+                    ((swap(this->get<Is>(), other.template get<Is>())), 0)...
                 };
                 (void)_sequencer;
             }

From 27c5dcf3e420567751c0fd3e8ee9c87afca5ba26 Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Thu, 28 May 2015 12:58:11 -0300
Subject: [PATCH 6/9] Reduce tuple dependency on boost.type_traits

---
 hpx/util/tuple.hpp | 93 +++++++++++++++++++++++-----------------------
 1 file changed, 46 insertions(+), 47 deletions(-)

diff --git a/hpx/util/tuple.hpp b/hpx/util/tuple.hpp
index 2a2b89f5103a..bccb4b37d902 100644
--- a/hpx/util/tuple.hpp
+++ b/hpx/util/tuple.hpp
@@ -11,23 +11,16 @@
 #include <hpx/config.hpp>
 #include <hpx/traits/is_bitwise_serializable.hpp>
 #include <hpx/util/decay.hpp>
-#include <hpx/util/move.hpp>
 #include <hpx/util/detail/pack.hpp>
 
 #include <boost/array.hpp>
 #include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/size_t.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/add_cv.hpp>
-#include <boost/type_traits/add_volatile.hpp>
-#include <boost/type_traits/is_empty.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 
+#include <algorithm>
 #include <cstddef> // for size_t
+#include <type_traits>
 #include <utility>
-#include <algorithm>
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -93,7 +86,12 @@ namespace hpx { namespace util
 
         template <std::size_t I, typename T>
         struct tuple_member<I, T,
-            typename boost::enable_if_c<boost::is_empty<T>::value>::type
+            typename std::enable_if<
+                std::is_empty<T>::value
+#if defined(HPX_HAVE_CXX11_STD_IS_FINAL)
+             && !std::is_final<T>::value
+#endif
+            >::type
         > : T
         {
         public:
@@ -135,11 +133,10 @@ namespace hpx { namespace util
 
             static bool const value =
                 sizeof(
-                    call(util::get<Is>(boost::declval<UTuple>())...)
+                    call(util::get<Is>(std::declval<UTuple>())...)
                 ) == sizeof(yes_type);
 
             typedef boost::mpl::bool_<value> type;
-            type m_;
         };
 
         template <typename TTuple, typename UTuple, typename Enable = void>
@@ -150,9 +147,9 @@ namespace hpx { namespace util
         template <typename ...Ts, typename UTuple>
         struct are_tuples_compatible<
             tuple<Ts...>, UTuple
-          , typename boost::enable_if_c<
+          , typename std::enable_if<
                 tuple_size<
-                    typename boost::remove_reference<UTuple>::type
+                    typename std::remove_reference<UTuple>::type
                 >::value == detail::pack<Ts...>::size
             >::type
         > : are_tuples_compatible_impl<
@@ -163,9 +160,9 @@ namespace hpx { namespace util
 
         template <typename TTuple, typename UTuple>
         struct are_tuples_compatible_not_same
-          : boost::mpl::if_c<
-                boost::is_same<
-                    typename decay<TTuple>::type, typename decay<UTuple>::type
+          : std::conditional<
+                std::is_same<
+                    typename std::decay<TTuple>::type, typename std::decay<UTuple>::type
                 >::value
               , boost::mpl::false_
               , are_tuples_compatible<TTuple, UTuple>
@@ -186,7 +183,7 @@ namespace hpx { namespace util
             {}
 
             template <typename ...Us, typename Enable =
-                typename boost::enable_if_c<
+                typename std::enable_if<
                     detail::pack<Us...>::size == detail::pack<Ts...>::size
                 >::type>
             explicit BOOST_CONSTEXPR tuple_impl(Us&&... vs)
@@ -202,7 +199,7 @@ namespace hpx { namespace util
             {}
 
             template <typename UTuple, typename Enable =
-                typename boost::enable_if_c<
+                typename std::enable_if<
                     are_tuples_compatible_not_same<tuple<Ts...>, UTuple&&>::value
                 >::type>
             BOOST_CONSTEXPR tuple_impl(UTuple&& other)
@@ -364,16 +361,15 @@ namespace hpx { namespace util
         // unless each type in UTypes is implicitly convertible to its
         // corresponding type in Types.
         template <typename U, typename ...Us, typename Enable =
-            typename boost::enable_if_c<
+            typename std::enable_if<
                 detail::pack<U, Us...>::size == detail::pack<Ts...>::size
-             && boost::mpl::eval_if_c<
+             && std::conditional<
                     detail::pack<Us...>::size == 0
-                  , boost::mpl::eval_if_c<
-                        boost::is_same<tuple, typename decay<U>::type>::value
-                     || detail::are_tuples_compatible_not_same<tuple, U&&>::value
-                      , boost::mpl::false_
+                  , typename std::enable_if<
+                        !std::is_same<tuple, typename std::decay<U>::type>::value
+                     && !detail::are_tuples_compatible_not_same<tuple, U&&>::value
                       , detail::are_tuples_compatible<tuple, tuple<U>&&>
-                    >
+                    >::type
                   , detail::are_tuples_compatible<tuple, tuple<U, Us...>&&>
                 >::type::value
             >::type>
@@ -403,7 +399,7 @@ namespace hpx { namespace util
         // unless each type in UTypes is implicitly convertible to its
         // corresponding type in Types
         template <typename UTuple, typename Enable =
-            typename boost::enable_if_c<
+            typename std::enable_if<
                 detail::are_tuples_compatible_not_same<tuple, UTuple&&>::value
             >::type>
         BOOST_CONSTEXPR tuple(UTuple&& other)
@@ -432,8 +428,10 @@ namespace hpx { namespace util
         // template <class... UTypes> tuple& operator=(tuple<UTypes...>&& u);
         // For all i, assigns get<i>(std::forward<U>(u)) to get<i>(*this).
         template <typename UTuple>
-        typename boost::enable_if_c<
-            tuple_size<typename decay<UTuple>::type>::value == detail::pack<Ts...>::size
+        typename std::enable_if<
+            tuple_size<
+                typename std::decay<UTuple>::type
+            >::value == detail::pack<Ts...>::size
           , tuple&
         >::type operator=(UTuple&& other)
         {
@@ -477,17 +475,17 @@ namespace hpx { namespace util
 
     template <typename ...Ts>
     struct tuple_size<tuple<Ts...> >
-      : boost::mpl::size_t<sizeof...(Ts)>
+      : boost::integral_constant<std::size_t, sizeof...(Ts)>
     {};
 
     template <typename T0, typename T1>
     struct tuple_size<std::pair<T0, T1> >
-      : boost::mpl::size_t<2>
+      : boost::integral_constant<std::size_t, 2>
     {};
 
     template <typename Type, std::size_t Size>
     struct tuple_size<boost::array<Type, Size> >
-      : boost::mpl::size_t<Size>
+      : boost::integral_constant<std::size_t, Size>
     {};
 
     // template <size_t I, class Tuple>
@@ -498,17 +496,17 @@ namespace hpx { namespace util
 
     template <std::size_t I, typename T>
     struct tuple_element<I, const T>
-      : boost::add_const<typename tuple_element<I, T>::type>
+      : std::add_const<typename tuple_element<I, T>::type>
     {};
 
     template <std::size_t I, typename T>
     struct tuple_element<I, volatile T>
-      : boost::add_volatile<typename tuple_element<I, T>::type>
+      : std::add_volatile<typename tuple_element<I, T>::type>
     {};
 
     template <std::size_t I, typename T>
     struct tuple_element<I, const volatile T>
-      : boost::add_cv<typename tuple_element<I, T>::type>
+      : std::add_cv<typename tuple_element<I, T>::type>
     {};
 
     template <std::size_t I, typename ...Ts>
@@ -590,7 +588,7 @@ namespace hpx { namespace util
     template <typename ...Ts>
     struct tuple_decay<tuple<Ts...> >
     {
-        typedef tuple<typename decay<Ts>::type...> type;
+        typedef tuple<typename std::decay<Ts>::type...> type;
     };
 
     // 20.4.2.6, element access
@@ -676,8 +674,9 @@ namespace hpx { namespace util
 
         template <std::size_t Size>
         struct tuple_cat_size_impl<Size, detail::pack<> >
-          : boost::mpl::size_t<Size>
-        {};
+        {
+            static const std::size_t value = Size;
+        };
 
         template <std::size_t Size, typename Head, typename ...Tail>
         struct tuple_cat_size_impl<
@@ -699,7 +698,7 @@ namespace hpx { namespace util
         template <std::size_t I, typename Head, typename ...Tail>
         struct tuple_cat_element<
             I, detail::pack<Head, Tail...>
-          , typename boost::enable_if_c<
+          , typename std::enable_if<
                 (I < tuple_size<Head>::value)
             >::type
         > : tuple_element<I, Head>
@@ -724,7 +723,7 @@ namespace hpx { namespace util
         template <std::size_t I, typename Head, typename ...Tail>
         struct tuple_cat_element<
             I, detail::pack<Head, Tail...>
-          , typename boost::enable_if_c<
+          , typename std::enable_if<
                 (I >= tuple_size<Head>::value)
             >::type
         > : tuple_cat_element<
@@ -829,7 +828,7 @@ namespace hpx { namespace util
 
     template <typename ...Ts, typename ...Us>
     BOOST_CONSTEXPR BOOST_FORCEINLINE
-    typename boost::enable_if_c<sizeof...(Ts) == sizeof...(Us), bool>::type
+    typename std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type
     operator==(tuple<Ts...> const& t, tuple<Us...> const& u)
     {
         return detail::tuple_equal_to<0, sizeof...(Ts)>::call(t, u);
@@ -840,7 +839,7 @@ namespace hpx { namespace util
     //     (const tuple<TTypes...>& t, const tuple<UTypes...>& u);
     template <typename ...Ts, typename ...Us>
     BOOST_CONSTEXPR BOOST_FORCEINLINE
-    typename boost::enable_if_c<sizeof...(Ts) == sizeof...(Us), bool>::type
+    typename std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type
     operator!=(tuple<Ts...> const& t, tuple<Us...> const& u)
     {
         return !(t == u);
@@ -885,7 +884,7 @@ namespace hpx { namespace util
 
     template <typename ...Ts, typename ...Us>
     BOOST_CONSTEXPR BOOST_FORCEINLINE
-    typename boost::enable_if_c<sizeof...(Ts) == sizeof...(Us), bool>::type
+    typename std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type
     operator<(tuple<Ts...> const& t, tuple<Us...> const& u)
     {
         return detail::tuple_less_than<0, sizeof...(Ts)>::call(t, u);
@@ -896,7 +895,7 @@ namespace hpx { namespace util
     //     (const tuple<TTypes...>& t, const tuple<UTypes...>& u);
     template <typename ...Ts, typename ...Us>
     BOOST_CONSTEXPR BOOST_FORCEINLINE
-    typename boost::enable_if_c<sizeof...(Ts) == sizeof...(Us), bool>::type
+    typename std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type
     operator>(tuple<Ts...> const& t, tuple<Us...> const& u)
     {
         return u < t;
@@ -907,7 +906,7 @@ namespace hpx { namespace util
     //     (const tuple<TTypes...>& t, const tuple<UTypes...>& u);
     template <typename ...Ts, typename ...Us>
     BOOST_CONSTEXPR BOOST_FORCEINLINE
-    typename boost::enable_if_c<sizeof...(Ts) == sizeof...(Us), bool>::type
+    typename std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type
     operator<=(tuple<Ts...> const& t, tuple<Us...> const& u)
     {
         return !(u < t);
@@ -918,7 +917,7 @@ namespace hpx { namespace util
     //     (const tuple<TTypes...>& t, const tuple<UTypes...>& u);
     template <typename ...Ts, typename ...Us>
     BOOST_CONSTEXPR BOOST_FORCEINLINE
-    typename boost::enable_if_c<sizeof...(Ts) == sizeof...(Us), bool>::type
+    typename std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type
     operator>=(tuple<Ts...> const& t, tuple<Us...> const& u)
     {
         return !(t < u);

From 3ca717834084e9c48dc53dde6bb5ef3dea5f0547 Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Wed, 3 Jun 2015 21:18:49 -0300
Subject: [PATCH 7/9] Removed unused tuple_decay (introduced to aid with faux
 variadics)

---
 hpx/util/tuple.hpp | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/hpx/util/tuple.hpp b/hpx/util/tuple.hpp
index bccb4b37d902..6a81355d69f3 100644
--- a/hpx/util/tuple.hpp
+++ b/hpx/util/tuple.hpp
@@ -581,16 +581,6 @@ namespace hpx { namespace util
         }
     };
 
-    template <typename Tuple>
-    struct tuple_decay
-    {};
-
-    template <typename ...Ts>
-    struct tuple_decay<tuple<Ts...> >
-    {
-        typedef tuple<typename std::decay<Ts>::type...> type;
-    };
-
     // 20.4.2.6, element access
 
     // template <size_t I, class... Types>

From d17b5cda7e499b07b71081759ad438a1e2dae196 Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Fri, 21 Aug 2015 12:08:13 -0300
Subject: [PATCH 8/9] Remove tuple dependency on boost.mpl

---
 hpx/util/tuple.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/hpx/util/tuple.hpp b/hpx/util/tuple.hpp
index 6a81355d69f3..fca0d7c3a18b 100644
--- a/hpx/util/tuple.hpp
+++ b/hpx/util/tuple.hpp
@@ -14,7 +14,6 @@
 #include <hpx/util/detail/pack.hpp>
 
 #include <boost/array.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
 #include <algorithm>
@@ -136,12 +135,12 @@ namespace hpx { namespace util
                     call(util::get<Is>(std::declval<UTuple>())...)
                 ) == sizeof(yes_type);
 
-            typedef boost::mpl::bool_<value> type;
+            typedef std::integral_constant<bool, value> type;
         };
 
         template <typename TTuple, typename UTuple, typename Enable = void>
         struct are_tuples_compatible
-          : boost::mpl::false_
+          : std::false_type
         {};
 
         template <typename ...Ts, typename UTuple>
@@ -164,7 +163,7 @@ namespace hpx { namespace util
                 std::is_same<
                     typename std::decay<TTuple>::type, typename std::decay<UTuple>::type
                 >::value
-              , boost::mpl::false_
+              , std::false_type
               , are_tuples_compatible<TTuple, UTuple>
             >::type
         {};

From bf86884f35ab8b6a5527c0ec39484537be517fc1 Mon Sep 17 00:00:00 2001
From: K-ballo <k@fusionfenix.com>
Date: Sat, 29 Aug 2015 15:00:58 -0300
Subject: [PATCH 9/9] Add a few more missing serialization #includes

---
 .../serialization/detail/polymorphic_intrusive_factory.hpp       | 1 +
 hpx/util/detail/function_registration.hpp                        | 1 +
 2 files changed, 2 insertions(+)

diff --git a/hpx/runtime/serialization/detail/polymorphic_intrusive_factory.hpp b/hpx/runtime/serialization/detail/polymorphic_intrusive_factory.hpp
index 0fae7a52fb1d..665fffa9d3fb 100644
--- a/hpx/runtime/serialization/detail/polymorphic_intrusive_factory.hpp
+++ b/hpx/runtime/serialization/detail/polymorphic_intrusive_factory.hpp
@@ -8,6 +8,7 @@
 #ifndef HPX_SERIALIZATION_POLYMORPHIC_INTRUSIVE_FACTORY_HPP
 #define HPX_SERIALIZATION_POLYMORPHIC_INTRUSIVE_FACTORY_HPP
 
+#include <hpx/exception.hpp>
 #include <hpx/runtime/serialization/serialization_fwd.hpp>
 
 #include <hpx/util/jenkins_hash.hpp>
diff --git a/hpx/util/detail/function_registration.hpp b/hpx/util/detail/function_registration.hpp
index f6fcb46bd1c9..73528385b2c1 100644
--- a/hpx/util/detail/function_registration.hpp
+++ b/hpx/util/detail/function_registration.hpp
@@ -11,6 +11,7 @@
 #include <hpx/config.hpp>
 #include <hpx/util/detail/get_table.hpp>
 #include <hpx/runtime/serialization/detail/polymorphic_intrusive_factory.hpp>
+#include <hpx/traits/needs_automatic_registration.hpp>
 #include <hpx/util/demangle_helper.hpp>
 #include <hpx/util/tuple.hpp>