Merge branch 'fixing_722'

cmake/templates/wave.cfg.in

@@ -61,6 +61,7 @@
 -NLBT_
 #
 -NHPX_UTIL_STRIP
+-NHPX_SPECIALIZE
 
 #
 # We inhibit expanding this because it otherwise generates some funky

docs/CMakeLists.txt

@@ -39,7 +39,7 @@ set(doxygen_dependencies
     ${hpx_SOURCE_DIR}/hpx/exception.hpp
     ${hpx_SOURCE_DIR}/hpx/runtime/actions/action_support.hpp
     ${hpx_SOURCE_DIR}/hpx/runtime/actions/plain_action.hpp
-    ${hpx_SOURCE_DIR}/hpx/runtime/actions/component_action.hpp
+    ${hpx_SOURCE_DIR}/hpx/runtime/actions/component_non_const_action.hpp
     ${hpx_SOURCE_DIR}/hpx/performance_counters/manage_counter_type.hpp)
 
 foreach(doxygen_input ${doxygen_dependencies})

hpx/components/binpacking_factory/server/binpacking_factory.hpp

@@ -8,7 +8,6 @@
 
 #include <hpx/hpx_fwd.hpp>
 #include <hpx/runtime/components/component_type.hpp>
-#include <hpx/runtime/components/server/managed_component_base.hpp>
 #include <hpx/runtime/components/server/simple_component_base.hpp>
 #include <hpx/runtime/actions/component_action.hpp>
 #include <hpx/util/locality_result.hpp>
@@ -50,17 +49,8 @@ namespace hpx { namespace components { namespace server
         // Each of the exposed functions needs to be encapsulated into a action
         // type, allowing to generate all require boilerplate code for threads,
         // serialization, etc.
-        typedef hpx::actions::result_action2<
-            binpacking_factory const, remote_result_type,
-            components::component_type, std::size_t,
-            &binpacking_factory::create_components
-        > create_components_action;
-
-        typedef hpx::actions::result_action3<
-            binpacking_factory const, remote_result_type,
-            components::component_type, std::size_t, std::string const&,
-            &binpacking_factory::create_components_counterbased
-        > create_components_counterbased_action;
+        HPX_DEFINE_COMPONENT_CONST_ACTION(binpacking_factory, create_components);
+        HPX_DEFINE_COMPONENT_CONST_ACTION(binpacking_factory, create_components_counterbased);
     };
 }}}
 

hpx/components/distributing_factory/server/distributing_factory.hpp

@@ -89,21 +89,8 @@ namespace hpx { namespace components { namespace server
             partition_info const& info) const;
 
         ///////////////////////////////////////////////////////////////////////
-        // Each of the exposed functions needs to be encapsulated into a action
-        // type, allowing to generate all require boilerplate code for threads,
-        // serialization, etc.
-        typedef hpx::actions::result_action2<
-            distributing_factory const, remote_result_type,
-            components::component_type, std::size_t,
-            &distributing_factory::create_components
-        > create_components_action;
-
-        typedef hpx::actions::result_action4<
-            distributing_factory const, remote_result_type,
-            components::component_type, std::size_t,
-            std::size_t, partition_info const&,
-            &distributing_factory::create_partitioned
-        > create_partitioned_action;
+        HPX_DEFINE_COMPONENT_CONST_ACTION(distributing_factory, create_components);
+        HPX_DEFINE_COMPONENT_CONST_ACTION(distributing_factory, create_partitioned);
     };
 }}}
 

hpx/components/remote_object/server/remote_object.hpp

@@ -64,9 +64,7 @@ namespace hpx { namespace components { namespace server
     template <typename F>
     struct remote_object_apply_action1
       : hpx::actions::result_action1<
-            remote_object
-          , typename F::result_type
-          , F const &
+            typename F::result_type (remote_object::*)(F const &)
           , &remote_object::apply1<F>
           , remote_object_apply_action1<F>
         >
@@ -76,10 +74,7 @@ namespace hpx { namespace components { namespace server
     template <typename F, typename A>
     struct remote_object_apply_action2
       : hpx::actions::result_action2<
-            remote_object
-          , typename F::result_type
-          , F const &
-          , A const &
+            typename F::result_type (remote_object::*)(F const &, A const &)
           , &remote_object::apply2<F, A>
           , remote_object_apply_action2<F, A>
         >

hpx/hpx_fwd.hpp

@@ -1060,7 +1060,7 @@ namespace hpx
     ///
     /// \note     The active counters are those which have been specified on
     ///           the command line while executing the application (see command
-    ///           line option --hpx:print-counter)
+    ///           line option \--hpx:print-counter)
     HPX_API_EXPORT void start_active_counters(error_code& ec = throws);
 
     /// \brief Resets all active performance counters.
@@ -1076,7 +1076,7 @@ namespace hpx
     ///
     /// \note     The active counters are those which have been specified on
     ///           the command line while executing the application (see command
-    ///           line option --hpx:print-counter)
+    ///           line option \--hpx:print-counter)
     HPX_API_EXPORT void reset_active_counters(error_code& ec = throws);
 
     /// \brief Stop all active performance counters.
@@ -1092,13 +1092,13 @@ namespace hpx
     ///
     /// \note     The active counters are those which have been specified on
     ///           the command line while executing the application (see command
-    ///           line option --hpx:print-counter)
+    ///           line option \--hpx:print-counter)
     HPX_API_EXPORT void stop_active_counters(error_code& ec = throws);
 
-    /// \brief Query all active performance counters, optionally naming the
-    ///        point in code marked by this function,
+    /// \brief Evaluate and utput all active performance counters, optionally 
+    ///        naming the point in code marked by this function.
     ///
-    /// \param reset       [in] this is an optional falg allowing to reset
+    /// \param reset       [in] this is an optional flag allowing to reset
     ///                    the counter value after it has been evaluated.
     /// \param description [in] this is an optional value naming the point in
     ///                    the code marked by the call to this function.
@@ -1113,11 +1113,11 @@ namespace hpx
     ///
     /// \note     The output generated by this function is redirected to the
     ///           destination specified by the corresponding command line
-    ///           options (see --hpx:print-counter-destination).
+    ///           options (see \--hpx:print-counter-destination).
     ///
     /// \note     The active counters are those which have been specified on
     ///           the command line while executing the application (see command
-    ///           line option --hpx:print-counter)
+    ///           line option \--hpx:print-counter)
     HPX_API_EXPORT void evaluate_active_counters(bool reset = false,
         char const* description = 0, error_code& ec = throws);
 }

hpx/lcos/base_lco.hpp

@@ -94,11 +94,8 @@ namespace hpx { namespace lcos
         ///
         /// The \a set_event_action may be used to unconditionally trigger any
         /// LCO instances, it carries no additional parameters.
-//         HPX_COMPONENT_DIRECT_ACTION(base_lco, set_event_nonvirt,
-//             set_event_action);
-        typedef hpx::actions::direct_action0<
-            base_lco, &base_lco::set_event_nonvirt
-        > set_event_action;
+        HPX_DEFINE_COMPONENT_DIRECT_ACTION(base_lco, set_event_nonvirt,
+            set_event_action);
 
         /// The \a set_exception_action may be used to transfer arbitrary error
         /// information from the remote site to the LCO instance specified as
@@ -107,31 +104,20 @@ namespace hpx { namespace lcos
         /// \param boost::exception_ptr
         ///               [in] The exception encapsulating the error to report
         ///               to this LCO instance.
-//         HPX_COMPONENT_DIRECT_ACTION(base_lco, set_exception_nonvirt,
-//             set_exception_action);
-        typedef hpx::actions::direct_action1<
-            base_lco, boost::exception_ptr const&,
-            &base_lco::set_exception_nonvirt
-        > set_exception_action;
+        HPX_DEFINE_COMPONENT_DIRECT_ACTION(base_lco, set_exception_nonvirt,
+            set_exception_action);
 
         /// The \a connect_action may be used to
-//         HPX_COMPONENT_DIRECT_ACTION(base_lco, connect_nonvirt, connect_action);
-        typedef hpx::actions::direct_action1<
-            base_lco, naming::id_type const&,
-            &base_lco::connect_nonvirt
-        > connect_action;
+        HPX_DEFINE_COMPONENT_DIRECT_ACTION(base_lco, connect_nonvirt,
+            connect_action);
 
         /// The \a set_exception_action may be used to
-//         HPX_COMPONENT_DIRECT_ACTION(base_lco, disconnect_nonvirt,
-//             disconnect_action);
-        typedef hpx::actions::direct_action1<
-            base_lco, naming::id_type const&,
-            &base_lco::disconnect_nonvirt
-        > disconnect_action;
-
-        /// This is the default hook implementation for decorate_action which 
+        HPX_DEFINE_COMPONENT_DIRECT_ACTION(base_lco, disconnect_nonvirt,
+            disconnect_action);
+
+        /// This is the default hook implementation for decorate_action which
         /// does no hooking at all.
-        static HPX_STD_FUNCTION<threads::thread_function_type> 
+        static HPX_STD_FUNCTION<threads::thread_function_type>
         wrap_action(HPX_STD_FUNCTION<threads::thread_function_type> f,
             naming::address::address_type)
         {

hpx/lcos/base_lco_with_value.hpp

@@ -99,24 +99,13 @@ namespace hpx { namespace lcos
         /// \param RemoteResult [in] The type of the result to be transferred
         ///               back to this LCO instance.
 
-        // FIXME: gcc complains when the macro is used
-//         HPX_COMPONENT_DIRECT_ACTION_TPL(base_lco_with_value, set_value_nonvirt,
-//             set_value_action);
-        typedef hpx::actions::direct_action1<
-            base_lco_with_value, BOOST_RV_REF(RemoteResult),
-            &base_lco_with_value::set_value_nonvirt
-        > set_value_action;
+        HPX_DEFINE_COMPONENT_DIRECT_ACTION_TPL(base_lco_with_value,
+            set_value_nonvirt, set_value_action);
 
         /// The \a get_value_action may be used to query the value this LCO
         /// instance exposes as its 'result' value.
-
-        // FIXME: gcc complains when the macro is used
-//         HPX_COMPONENT_DIRECT_ACTION_TPL(base_lco_with_value, get_value_nonvirt,
-//             get_value_action);
-        typedef hpx::actions::direct_result_action0<
-            base_lco_with_value, Result,
-            &base_lco_with_value::get_value_nonvirt
-        > get_value_action;
+        HPX_DEFINE_COMPONENT_DIRECT_ACTION_TPL(base_lco_with_value,
+            get_value_nonvirt, get_value_action);
     };
 
     /// The base_lco<void> specialization is used whenever the set_event action

hpx/performance_counters/server/base_performance_counter.hpp

@@ -113,42 +113,29 @@ namespace hpx { namespace performance_counters { namespace server
 
         /// The \a get_counter_info_action retrieves a performance counters
         /// information.
-        typedef hpx::actions::result_action0<
-            base_performance_counter const, counter_info,
-            &base_performance_counter::get_counter_info_nonvirt
-        > get_counter_info_action;
+        HPX_DEFINE_COMPONENT_CONST_ACTION(base_performance_counter,
+            get_counter_info_nonvirt, get_counter_info_action);
 
         /// The \a get_counter_value_action queries the value of a performance
         /// counter.
-        typedef hpx::actions::result_action1<
-            base_performance_counter, counter_value, bool,
-            &base_performance_counter::get_counter_value_nonvirt
-        > get_counter_value_action;
+        HPX_DEFINE_COMPONENT_ACTION(base_performance_counter,
+            get_counter_value_nonvirt, get_counter_value_action);
 
         /// The \a set_counter_value_action
-        typedef hpx::actions::action1<
-            base_performance_counter,
-            counter_value const&,
-            &base_performance_counter::set_counter_value_nonvirt
-        > set_counter_value_action;
+        HPX_DEFINE_COMPONENT_ACTION(base_performance_counter,
+            set_counter_value_nonvirt, set_counter_value_action);
 
         /// The \a reset_counter_value_action
-        typedef hpx::actions::action0<
-            base_performance_counter,
-            &base_performance_counter::reset_counter_value_nonvirt
-        > reset_counter_value_action;
+        HPX_DEFINE_COMPONENT_ACTION(base_performance_counter,
+            reset_counter_value_nonvirt, reset_counter_value_action);
 
         /// The \a start_action
-        typedef hpx::actions::result_action0<
-            base_performance_counter, bool,
-            &base_performance_counter::start_nonvirt
-        > start_action;
+        HPX_DEFINE_COMPONENT_ACTION(base_performance_counter,
+            start_nonvirt, start_action);
 
         /// The \a stop_action
-        typedef hpx::actions::result_action0<
-            base_performance_counter, bool,
-            &base_performance_counter::stop_nonvirt
-        > stop_action;
+        HPX_DEFINE_COMPONENT_ACTION(base_performance_counter,
+            stop_nonvirt, stop_action);
 
         /// This is the default hook implementation for decorate_action which
         /// does no hooking at all.