rmq as params

Author: dimak24

pysdsl/types/rmq.hpp

@@ -53,6 +53,9 @@ namespace RAC_names {
     const char INT_VECTOR_NAME[] = "IntVector";
 }
 
+template <typename t_rac, typename t_min_ic>
+using general_rmq_sparse_table = py::class_<sdsl::rmq_support_sparse_table<t_rac, t_min_ic::value>>;
+
 
 inline auto add_rmq_classes(py::module& m) {
     m.attr("rmq_sparse_table") = py::dict();
@@ -69,6 +72,16 @@ inline auto add_rmq_classes(py::module& m) {
 
     auto rmq_sparse_tables = for_each_in_tuple(rmq_support_sparse_table_params(), 
                                 add_rmq_sparse_table_functor(m, doc_rmq_sparse_table));
+
+    ////////////// as params //////////////////////
+    using rmq_support_sparse_table_as_params = std::tuple<
+        std::tuple<sdsl::int_vector<>, std::integral_constant<bool, true>>,
+        std::tuple<sdsl::int_vector<>, std::integral_constant<bool, false>>
+    >;
+
+    auto rmq_sparse_tables_as_params = for_each_in_tuple(rmq_support_sparse_table_as_params(), 
+                                make_general_sybset_functor<general_rmq_sparse_table>(rmq_sparse_tables));
+    ///////////////////////////////////////////////
 
     return std::tuple_cat(rmq_sparse_tables);
 }

pysdsl/util/tupletricks.hpp

@@ -14,7 +14,7 @@ decltype(auto) for_each_impl(P&& t, Function&& f, std::index_sequence<Is...>) {
 
 template<typename P, typename Function, std::size_t... Is>
 constexpr
-decltype(auto) for_each_impl(P& t, Function&& f, std::index_sequence<Is...>) {
+decltype(auto) for_each_impl(const P& t, Function&& f, std::index_sequence<Is...>) {
     return std::make_tuple(f(std::get<Is>(t))...); }
 
 template<typename... T, typename Function>
@@ -27,6 +27,26 @@ constexpr
 decltype(auto) for_each(std::tuple<T...>& t, Function&& f) {
     return for_each_impl(t, f, std::index_sequence_for<T...>{}); }
 
+template<typename P, typename Function, std::size_t... Is>
+constexpr
+decltype(auto) forward_each_impl(P&& t, Function&& f, std::index_sequence<Is...>) {
+    return std::forward_as_tuple(f(std::get<Is>(t))...); }
+
+template<typename P, typename Function, std::size_t... Is>
+constexpr
+decltype(auto) forward_each_impl(const P& t, Function&& f, std::index_sequence<Is...>) {
+    return std::forward_as_tuple(f(std::get<Is>(t))...); }
+
+template<typename... T, typename Function>
+constexpr
+decltype(auto) forward_each(const std::tuple<T...>& t, Function&& f) {
+    return forward_each_impl(t, f, std::index_sequence_for<T...>{}); }
+
+template<typename... T, typename Function>
+constexpr
+decltype(auto) forward_each(std::tuple<T...>& t, Function&& f) {
+    return forward_each_impl(t, f, std::index_sequence_for<T...>{}); }
+
 }  // namespace detail
 
 
@@ -40,3 +60,45 @@ template <typename... Ts, typename F>
 constexpr
 decltype(auto) for_each_in_tuple(std::tuple<Ts...> &t, F f) {
     return detail::for_each(t, f); }
+
+template <typename... Ts, typename F>
+constexpr
+decltype(auto) forward_each_in_tuple(const std::tuple<Ts...> &t, F f) {
+    return detail::forward_each(t, f); }
+
+
+template <typename... Ts, typename F>
+constexpr
+decltype(auto) forward_each_in_tuple(std::tuple<Ts...> &t, F f) {
+    return detail::forward_each(t, f); }
+
+
+// subset functor
+template <typename T>
+struct get_template_arg {
+    using arg = T;
+};
+
+template <typename T, T N>
+struct get_template_arg<std::integral_constant<T, N>> {
+    const static T arg = N;
+};
+
+
+template <template <typename...> typename general_template, typename... Ts>
+struct GeneralSubsetFunctor {
+    std::tuple<Ts...>& tpl;
+
+    constexpr GeneralSubsetFunctor(std::tuple<Ts...>& tpl) noexcept
+        : tpl(tpl) {}
+
+    template <typename... Args>
+    auto& operator()(std::tuple<Args...>) const {
+        return std::get<general_template<Args...>>(tpl);
+    }
+};
+
+template <template <typename...> typename general_template, typename... Ts>
+auto make_general_sybset_functor(std::tuple<Ts...>& tpl) {
+    return GeneralSubsetFunctor<general_template, Ts...>(tpl);
+}