Add documentation to invoke_fused and invoke

STEllAR-GROUP · May 21, 2017 · 272dba4 · 272dba4
1 parent 88a829c
commit 272dba4
Show file tree

Hide file tree

Showing 4 changed files with 58 additions and 0 deletions.
diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
@@ -171,6 +171,8 @@ set(doxygen_dependencies
     "${PROJECT_SOURCE_DIR}/hpx/lcos/when_some.hpp"
     "${PROJECT_SOURCE_DIR}/hpx/lcos/wait_each.hpp"
     "${PROJECT_SOURCE_DIR}/hpx/lcos/when_each.hpp"
+    "${PROJECT_SOURCE_DIR}/hpx/util/invoke.hpp"
+    "${PROJECT_SOURCE_DIR}/hpx/util/invoke_fused.hpp"
     "${PROJECT_SOURCE_DIR}/hpx/performance_counters/manage_counter_type.hpp")
 
 

diff --git a/docs/hpx.idx b/docs/hpx.idx
@@ -511,6 +511,14 @@ when_each_n                           "" "header\.hpx\.lcos\.when_each.*"
 wait_each                             "" "header\.hpx\.lcos\.wait_each.*"
 wait_each_n                           "" "header\.hpx\.lcos\.wait_each.*"
 
+# hpx/util/invoke.hpp
+invoke                                "" "header\.hpx\.util\.invoke.*"
+invoke_r                              "" "header\.hpx\.util\.invoke_r.*"
+
+# hpx/util/invoke_fused.hpp
+invoke_fused                          "" "header\.hpx\.util\.invoke_fused.*"
+invoke_fused_r                        "" "header\.hpx\.util\.invoke_fused_r.*"
+
 # hpx/hpx_finalize.hpp
 finalize                              "" "hpx\.finalize.*"
 terminate                             "" "hpx\.terminate.*"

diff --git a/hpx/util/invoke.hpp b/hpx/util/invoke.hpp
@@ -127,6 +127,23 @@ namespace hpx { namespace util
         };
     }
 
+    /// Invokes the given functional type f with the content of
+    /// the argument pack vs
+    ///
+    /// \param f A functional type providing an `operator()`
+    ///          or function pointer. If f is a member function pointer,
+    ///          the first argument in the pack will be treated as
+    ///          the callee (this object).
+    ///
+    /// \param vs An arbitrary pack of arguments
+    ///
+    /// \returns The result of the function when it's called with
+    ///          the given argument types.
+    ///
+    /// \throws std::exception thrown from a function
+    ///         invocation of f with the argument types vs.
+    ///
+    /// \note This is function is similar to `std::invoke` (C++17)
     template <typename F, typename ...Ts>
     HPX_HOST_DEVICE HPX_FORCEINLINE
     typename util::result_of<F&&(Ts&&...)>::type
@@ -138,6 +155,10 @@ namespace hpx { namespace util
             std::forward<F>(f), std::forward<Ts>(vs)...);
     }
 
+    /// \copydoc invoke
+    ///
+    /// \tparam R The result type of the function when it's called
+    ///           with the content of the given argument types vs.
     template <typename R, typename F, typename ...Ts>
     HPX_HOST_DEVICE HPX_FORCEINLINE
     R invoke_r(F&& f, Ts&&... vs)
@@ -147,6 +168,7 @@ namespace hpx { namespace util
     }
 
     ///////////////////////////////////////////////////////////////////////////
+    /// \cond NOINTERNAL
     namespace functional
     {
         struct invoke
@@ -175,6 +197,7 @@ namespace hpx { namespace util
             }
         };
     }
+    /// \endcond
 }}
 
 #endif
diff --git a/hpx/util/invoke_fused.hpp b/hpx/util/invoke_fused.hpp
@@ -68,6 +68,25 @@ namespace hpx { namespace util
         }
     }
 
+    /// Invokes the given functional type f with the content of
+    /// the sequenced type t (tuples, pairs)
+    ///
+    /// \param f A functional type providing an `operator()`
+    ///          or function pointer. If f is a member function pointer,
+    ///          the first argument in the sequenced type will be treated as
+    ///          the callee (this object).
+    ///
+    /// \param t A type which is content accessible through a call
+    ///          to hpx#util#get.
+    ///
+    /// \returns The result of the function when it's called with
+    ///          the content of the given sequenced type.
+    ///
+    /// \throws std::exception thrown from a function
+    ///         invocation of f with the arguments contained
+    ///         in the sequenceable type t.
+    ///
+    /// \note This is function is similar to `std::apply` (C++17)
     template <typename F, typename Tuple>
     HPX_HOST_DEVICE HPX_FORCEINLINE
     typename detail::fused_result_of<F&&(Tuple&&)>::type
@@ -80,6 +99,10 @@ namespace hpx { namespace util
             typename detail::fused_index_pack<Tuple>::type());
     }
 
+    /// \copydoc invoke_fused
+    ///
+    /// \tparam R The result type of the function when it's called
+    ///           with the content of the given sequenced type.
     template <typename R, typename F, typename Tuple>
     HPX_HOST_DEVICE HPX_FORCEINLINE
     R invoke_fused_r(F&& f, Tuple&& t)
@@ -89,6 +112,7 @@ namespace hpx { namespace util
             typename detail::fused_index_pack<Tuple>::type());
     }
     ///////////////////////////////////////////////////////////////////////////
+    /// \cond NOINTERNAL
     namespace functional
     {
         struct invoke_fused
@@ -119,6 +143,7 @@ namespace hpx { namespace util
             }
         };
     }
+    /// \endcond
 }}
 
 #endif