feat: Ranges pipe operator (#937)

Implement a simple version of the pipe operator for ranges composition. Also extended the ranges integrations tests and moved them to the other integration tests

Author: niermann999

core/include/detray/utils/concepts.hpp

@@ -34,6 +34,10 @@ concept same_as_cvref =
 template <typename T, typename U>
 concept same_as_no_const = std::same_as<std::remove_cv_t<T>, U>;
 
+/// Index concept to access vector/matrix elements
+template <typename T>
+concept index = std::is_integral_v<T> && !std::same_as<T, bool>;
+
 /// Concept that checks if a type models an interval of some value that can
 /// be obtained with 'get'.
 template <typename I>

core/include/detray/utils/ranges/cartesian_product.hpp

@@ -101,12 +101,13 @@ struct cartesian_product : public ranges::cartesian_product_view<range_ts...> {
 
     constexpr cartesian_product() = default;
 
-    DETRAY_HOST_DEVICE constexpr explicit cartesian_product(range_ts... ranges)
-        : base_type(ranges...) {}
+    template <detray::ranges::range... deduced_range_ts>
+    DETRAY_HOST_DEVICE constexpr explicit cartesian_product(
+        deduced_range_ts &&... ranges)
+        : base_type(std::forward<deduced_range_ts>(ranges)...) {}
 };
 
 // deduction guides
-
 template <detray::ranges::range... ranges_ts>
 DETRAY_HOST_DEVICE cartesian_product(ranges_ts &&... ranges)
     ->cartesian_product<ranges_ts...>;

core/include/detray/utils/ranges/enumerate.hpp

@@ -10,6 +10,7 @@
 // Project include(s)
 #include "detray/definitions/detail/qualifiers.hpp"
 #include "detray/definitions/indexing.hpp"
+#include "detray/utils/ranges/empty.hpp"
 #include "detray/utils/ranges/ranges.hpp"
 #include "detray/utils/ranges/subrange.hpp"
 
@@ -203,16 +204,15 @@ class enumerate_view : public detray::ranges::view_interface<
     /// Construct from a @param range that will be enumerated beginning at 0
     template <detray::ranges::range range_t>
     DETRAY_HOST_DEVICE constexpr explicit enumerate_view(range_t &&rng)
-        : m_begin{detray::ranges::begin(std::forward<range_t>(rng))},
-          m_end{detray::ranges::end(std::forward<range_t>(rng)),
-                static_cast<incr_t>(rng.size())} {}
+        : m_begin{detray::ranges::begin(rng)},
+          m_end{detray::ranges::end(rng), static_cast<incr_t>(rng.size())} {}
 
     /// Construct from a @param range that will be enumerated beginning at
     /// @param start.
     template <detray::ranges::range range_t>
     DETRAY_HOST_DEVICE constexpr enumerate_view(range_t &&rng, incr_t start)
-        : m_begin{detray::ranges::begin(std::forward<range_t>(rng)), start},
-          m_end{detray::ranges::end(std::forward<range_t>(rng)),
+        : m_begin{detray::ranges::begin(rng), start},
+          m_end{detray::ranges::end(rng),
                 start + static_cast<incr_t>(rng.size())} {}
 
     /// @return start position of range on container.
@@ -237,8 +237,16 @@ requires std::convertible_to<std::iter_difference_t<range_itr_t>,
 
     using base_type = enumerate_view<range_itr_t, incr_t>;
 
+    /// Partial construction for range composition
+    /// @{
     constexpr enumerate() = default;
 
+    DETRAY_HOST_DEVICE constexpr explicit enumerate(incr_t start)
+        : m_incr{start} {}
+    /// @}
+
+    /// Direct view construction
+    /// @{
     template <detray::ranges::range range_t>
     DETRAY_HOST_DEVICE constexpr explicit enumerate(range_t &&rng)
         : base_type(std::forward<range_t>(rng)) {}
@@ -253,22 +261,46 @@ requires std::convertible_to<std::iter_difference_t<range_itr_t>,
         : enumerate(detray::ranges::subrange(
                         std::forward<deduced_range_t>(range), vol),
                     detray::detail::get<0>(vol.full_range())) {}
+    /// @}
+
+    /// Call operator for range composition
+    template <detray::ranges::range range_t>
+    DETRAY_HOST_DEVICE constexpr auto operator()(range_t &&rng) {
+        using itr_t = detray::ranges::const_iterator_t<std::decay_t<range_t>>;
+        return detray::ranges::enumerate_view<itr_t, incr_t>(
+            std::forward<range_t>(rng), m_incr);
+    }
+
+    private:
+    incr_t m_incr{0};
 };
 
 // deduction guides
+DETRAY_HOST_DEVICE enumerate()
+    ->enumerate<
+        detray::ranges::const_iterator_t<detray::ranges::views::empty<int>>,
+        dindex>;
+
+DETRAY_HOST_DEVICE enumerate(dindex start)
+    ->enumerate<
+        detray::ranges::const_iterator_t<detray::ranges::views::empty<int>>,
+        dindex>;
 
 template <detray::ranges::range range_t>
 DETRAY_HOST_DEVICE enumerate(range_t &&rng)
-    ->enumerate<detray::ranges::const_iterator_t<range_t>, dindex>;
+    ->enumerate<detray::ranges::const_iterator_t<std::decay_t<range_t>>,
+                dindex>;
 
 template <detray::ranges::range range_t, typename volume_t,
           typename = typename std::remove_reference_t<volume_t>::volume_def>
 DETRAY_HOST_DEVICE enumerate(range_t &&range, const volume_t &vol)
-    ->enumerate<detray::ranges::const_iterator_t<range_t>, dindex>;
+    ->enumerate<detray::ranges::const_iterator_t<std::decay_t<range_t>>,
+                dindex>;
 
 template <detray::ranges::range range_t>
 DETRAY_HOST_DEVICE enumerate(range_t &&rng, dindex start)
-    ->enumerate<detray::ranges::const_iterator_t<range_t>, dindex>;
+    ->enumerate<detray::ranges::const_iterator_t<std::decay_t<range_t>>,
+                dindex>;
 
 }  // namespace views
 

core/include/detray/utils/ranges/iota.hpp

@@ -104,8 +104,8 @@ class iota_view : public detray::ranges::view_interface<iota_view<incr_t>> {
     /// Construct from an @param interval that defines start and end values.
     template <concepts::interval interval_t>
     DETRAY_HOST_DEVICE constexpr explicit iota_view(interval_t &&interval)
-        : m_start{detray::detail::get<0>(std::forward<interval_t>(interval))},
-          m_end{detray::detail::get<1>(std::forward<interval_t>(interval))} {}
+        : m_start{detray::detail::get<0>(interval)},
+          m_end{detray::detail::get<1>(interval)} {}
 
     /// Construct from a @param start start and @param end value.
     DETRAY_HOST_DEVICE constexpr iota_view(incr_t start, incr_t end)

core/include/detray/utils/ranges/join.hpp

@@ -10,6 +10,7 @@
 // Project include(s)
 #include "detray/definitions/containers.hpp"
 #include "detray/definitions/detail/qualifiers.hpp"
+#include "detray/utils/ranges/empty.hpp"
 #include "detray/utils/ranges/ranges.hpp"
 #include "detray/utils/type_traits.hpp"
 
@@ -58,8 +59,8 @@ struct join_view : public detray::ranges::view_interface<join_view<range_t>> {
     /// Construct from a range of @param ranges.
     template <detray::ranges::range R>
     DETRAY_HOST_DEVICE constexpr explicit join_view(R &&ranges)
-        : m_begin{detray::ranges::begin(std::forward<R>(ranges))},
-          m_end{detray::ranges::end(std::forward<R>(ranges))} {}
+        : m_begin{detray::ranges::begin(ranges)},
+          m_end{detray::ranges::end(ranges)} {}
 
     /// @return start position of range - const
     DETRAY_HOST_DEVICE
@@ -104,14 +105,21 @@ namespace views {
 template <detray::ranges::range range_t>
 struct join : public ranges::join_view<range_t> {
 
-    using base_type = ranges::join_view<range_t>;
+    using base_type = detray::ranges::join_view<range_t>;
 
     constexpr join() = default;
 
     template <detray::ranges::range deduced_range_t>
     DETRAY_HOST_DEVICE constexpr explicit join(deduced_range_t &&ranges)
         : base_type(std::forward<deduced_range_t>(ranges)) {}
 
+    /// Call operator for range composition
+    template <detray::ranges::range deduced_range_t>
+    DETRAY_HOST_DEVICE constexpr auto operator()(deduced_range_t &&ranges) {
+        return detray::ranges::join_view<deduced_range_t>(
+            std::forward<deduced_range_t>(ranges));
+    }
+
     /// Copy assignment operator
     DETRAY_HOST_DEVICE
     join &operator=(const join &other) {
@@ -121,6 +129,8 @@ struct join : public ranges::join_view<range_t> {
 };
 
 // deduction guides
+DETRAY_HOST_DEVICE join()->join<detray::ranges::views::empty<dvector<int>>>;
+
 template <detray::ranges::range R>
 DETRAY_HOST_DEVICE join(R &&ranges)->join<std::remove_reference_t<R>>;
 

core/include/detray/utils/ranges/pick.hpp

@@ -10,6 +10,7 @@
 // Project include(s)
 #include "detray/definitions/detail/qualifiers.hpp"
 #include "detray/definitions/indexing.hpp"
+#include "detray/utils/ranges/empty.hpp"
 #include "detray/utils/ranges/ranges.hpp"
 
 // System include(s)
@@ -298,25 +299,75 @@ class pick_view : public detray::ranges::view_interface<
 
 namespace views {
 
-template <std::input_iterator range_itr_t, std::input_iterator sequence_itr_t>
-struct pick : public pick_view<range_itr_t, sequence_itr_t> {
+template <std::input_iterator range_itr_t,
+          detray::ranges::input_range sequence_t>
+struct pick : public pick_view<range_itr_t, detray::ranges::const_iterator_t<
+                                                std::decay_t<sequence_t>>> {
 
+    using sequence_itr_t =
+        detray::ranges::const_iterator_t<std::decay_t<sequence_t>>;
     using base_type = pick_view<range_itr_t, sequence_itr_t>;
 
-    pick() = default;
+    constexpr pick() = default;
+
+    template <detray::ranges::input_range deduced_sequence_t>
+    DETRAY_HOST_DEVICE constexpr explicit pick(deduced_sequence_t &&seq)
+        : m_seq(std::forward<deduced_sequence_t>(seq)) {}
+
+    template <detray::ranges::range range_t,
+              detray::ranges::input_range deduced_sequence_t>
+    DETRAY_HOST_DEVICE constexpr pick(range_t &&range, deduced_sequence_t &&seq)
+        : base_type(std::forward<range_t>(range), seq),
+          m_seq{std::forward<deduced_sequence_t>(seq)} {}
+
+    /// Call operator for range composition - move semantics
+    template <detray::ranges::range range_t>
+    requires(std::same_as<sequence_t, std::remove_cvref_t<sequence_t>> &&
+             !std::is_pointer_v<sequence_t>) DETRAY_HOST_DEVICE constexpr auto
+    operator()(range_t &&rng) && {
+        using itr_t =
+            detray::ranges::iterator_t<std::remove_reference_t<range_t>>;
+        return detray::ranges::pick_view<itr_t, sequence_itr_t>(
+            std::forward<range_t>(rng), std::move(m_seq));
+    }
 
-    template <detray::ranges::range range_t, detray::ranges::range sequence_t>
-    DETRAY_HOST_DEVICE constexpr pick(range_t &&range, sequence_t &&seq)
-        : base_type(std::forward<range_t>(range),
-                    std::forward<sequence_t>(seq)) {}
+    /// Call operator for range composition
+    template <detray::ranges::range range_t>
+    requires(!std::same_as<sequence_t, std::remove_cvref_t<sequence_t>> ||
+             std::is_pointer_v<sequence_t>) DETRAY_HOST_DEVICE constexpr auto
+    operator()(range_t &&rng) {
+        using itr_t =
+            detray::ranges::iterator_t<std::remove_reference_t<range_t>>;
+        return detray::ranges::pick_view<itr_t, sequence_itr_t>(
+            std::forward<range_t>(rng), m_seq);
+    }
+
+    /// Copy assignment operator
+    DETRAY_HOST_DEVICE
+    pick &operator=(const pick &other) {
+        base_type::operator=(other);
+        m_seq = other.m_seq;
+        return *this;
+    }
+
+    private:
+    sequence_t m_seq{};
 };
 
-// deduction guides
+// deduction guides>
+DETRAY_HOST_DEVICE pick()
+    ->pick<detray::ranges::iterator_t<detray::ranges::views::empty<int>>,
+           dvector<int>>;
+
+template <detray::ranges::range sequence_t>
+DETRAY_HOST_DEVICE pick(sequence_t &&seq)
+    ->pick<detray::ranges::iterator_t<detray::ranges::views::empty<int>>,
+           sequence_t>;
 
 template <detray::ranges::range range_t, detray::ranges::range sequence_t>
-pick(range_t &&range, sequence_t &&seq)
-    -> pick<detray::ranges::iterator_t<range_t>,
-            detray::ranges::const_iterator_t<sequence_t>>;
+DETRAY_HOST_DEVICE pick(range_t &&range, sequence_t &&seq)
+    ->pick<detray::ranges::iterator_t<std::remove_reference_t<range_t>>,
+           sequence_t>;
 
 }  // namespace views
 

core/include/detray/utils/ranges/pointer.hpp

@@ -109,7 +109,7 @@ struct pointer : public detray::ranges::pointer_view<const value_t> {
 // deduction guides
 
 template <typename deduced_value_t>
-pointer(deduced_value_t&) -> pointer<deduced_value_t>;
+DETRAY_HOST_DEVICE pointer(deduced_value_t&)->pointer<deduced_value_t>;
 
 }  // namespace views
 

core/include/detray/utils/ranges/ranges.hpp

@@ -22,7 +22,7 @@
 
 namespace detray::ranges {
 
-/// @brief Provides c++17 detray iterators in a simplified std::ranges style,
+/// @brief Provides detray iterators in a simplified std::ranges style,
 ///        meant to be used in device code.
 ///
 /// @note Does make use of concepts and des not implement full ranges standard
@@ -66,8 +66,7 @@ template <class R>
 using sentinel_t = decltype(detray::ranges::end(std::declval<R&>()));
 
 template <class R>
-using const_iterator_t = decltype(
-    detray::ranges::begin(std::declval<const std::remove_reference_t<R>&>()));
+using const_iterator_t = decltype(detray::ranges::cbegin(std::declval<R&>()));
 
 template <class R>
 using range_size_t = decltype(detray::ranges::size(std::declval<R&>()));
@@ -292,4 +291,16 @@ inline constexpr bool viewable_range = detray::ranges::range<R> &&
                                         view<std::remove_cvref_t<R>>);
 /// @}
 
+/// Pipe operator for range composition
+///
+/// @param r range adaptor
+/// @param c closure
+///
+/// @returns composed range c(r)
+/// @TODO: Add concept for range adaptors, closures etc.
+template <detray::ranges::range R, detray::ranges::range C>
+auto operator|(R&& r, C&& c) {
+    return std::forward<C>(c)(std::forward<R>(r));
+}
+
 }  // namespace detray::ranges

core/include/detray/utils/ranges/single.hpp

@@ -130,7 +130,7 @@ struct single : public detray::ranges::single_view<value_t> {
 // deduction guides
 
 template <typename deduced_value_t>
-single(deduced_value_t) -> single<deduced_value_t>;
+DETRAY_HOST_DEVICE single(deduced_value_t)->single<deduced_value_t>;
 
 }  // namespace views
 

core/include/detray/utils/ranges/static_join.hpp

@@ -119,29 +119,17 @@ struct static_join : public ranges::static_join_view<I, range_itr_t> {
 
     constexpr static_join() = default;
 
-    template <detray::ranges::range... ranges_t>
-    DETRAY_HOST_DEVICE constexpr explicit static_join(
-        const ranges_t &... ranges)
-        : base_type(ranges...) {}
-
     template <detray::ranges::range... ranges_t>
     DETRAY_HOST_DEVICE constexpr explicit static_join(ranges_t &&... ranges)
         : base_type(std::forward<ranges_t>(ranges)...) {}
 };
 
 // deduction guides
-
-template <detray::ranges::range... ranges_t>
-DETRAY_HOST_DEVICE static_join(const ranges_t &... ranges)
-    ->static_join<sizeof...(ranges_t),
-                  typename detray::ranges::const_iterator_t<
-                      detray::detail::first_t<ranges_t...>>>;
-
 template <detray::ranges::range... ranges_t>
 DETRAY_HOST_DEVICE static_join(ranges_t &&... ranges)
     ->static_join<sizeof...(ranges_t),
-                  typename detray::ranges::iterator_t<
-                      detray::detail::first_t<ranges_t...>>>;
+                  typename detray::ranges::iterator_t<detray::detail::first_t<
+                      std::remove_reference_t<ranges_t>...>>>;
 
 }  // namespace views