From ed7346ebc5f6a95daeadd99249bdcfb19de32b40 Mon Sep 17 00:00:00 2001
From: Damien L-G <dalg24@gmail.com>
Date: Tue, 9 Jan 2024 22:07:29 -0500
Subject: [PATCH] Cleanup symbols for adapted user-provided values and
 predicates

AccessValues<AccessValues<...>> -> AccessValues<...>
AccessValues<Kokkos::View<...>> -> Kokkos::View<...>
AccessValues<PermutedData<...>> -> PermutedData<...>
AccessValues<LegacyValues<...>> -> LegacyValues<...>
---
 src/details/ArborX_AccessTraits.hpp        | 27 +++++++++++---
 src/details/ArborX_DetailsLegacy.hpp       |  8 +++++
 src/details/ArborX_DetailsPermutedData.hpp | 42 ++++++++++++++--------
 3 files changed, 59 insertions(+), 18 deletions(-)

diff --git a/src/details/ArborX_AccessTraits.hpp b/src/details/ArborX_AccessTraits.hpp
index 931a5ec88..bd4126dbd 100644
--- a/src/details/ArborX_AccessTraits.hpp
+++ b/src/details/ArborX_AccessTraits.hpp
@@ -190,14 +190,14 @@ void check_valid_access_traits(PrimitivesTag, Primitives const &,
 }
 
 template <typename Values, typename Tag>
-class AccessValues
+class AccessValuesI
 {
 private:
   using Access = AccessTraits<Values, Tag>;
   Values _values;
 
 public:
-  explicit AccessValues(Values values)
+  explicit AccessValuesI(Values values)
       : _values(std::move(values))
   {}
   using memory_space = typename Access::memory_space;
@@ -209,14 +209,33 @@ class AccessValues
 
   KOKKOS_FUNCTION
   auto size() const { return Access::size(_values); }
+
+  using self_type = AccessValuesI<Values, Tag>;
+};
+
+template <typename D, typename... P, typename Tag>
+class AccessValuesI<Kokkos::View<D, P...>, Tag> : public Kokkos::View<D, P...>
+{
+public:
+  using self_type = Kokkos::View<D, P...>;
 };
 
+template <typename Values, typename Tag1, typename Tag2>
+class AccessValuesI<AccessValuesI<Values, Tag1>, Tag2>
+    : public AccessValuesI<Values, Tag1>
+{
+  static_assert(std::is_same_v<Tag1, Tag2>);
+};
+
+template <typename Values, typename Tag>
+using AccessValues = typename AccessValuesI<Values, Tag>::self_type;
+
 } // namespace Details
 
 template <typename Values, typename Tag>
-struct AccessTraits<Details::AccessValues<Values, Tag>, Tag>
+struct AccessTraits<Details::AccessValuesI<Values, Tag>, Tag>
 {
-  using AccessValues = Details::AccessValues<Values, Tag>;
+  using AccessValues = Details::AccessValuesI<Values, Tag>;
 
   using memory_space = typename AccessValues::memory_space;
 
diff --git a/src/details/ArborX_DetailsLegacy.hpp b/src/details/ArborX_DetailsLegacy.hpp
index 6ad795c77..390ffd156 100644
--- a/src/details/ArborX_DetailsLegacy.hpp
+++ b/src/details/ArborX_DetailsLegacy.hpp
@@ -56,6 +56,14 @@ class LegacyValues
   size_type size() const { return Access::size(_primitives); }
 };
 
+template <typename Primitives, typename BoundingVolume>
+class AccessValuesI<LegacyValues<Primitives, BoundingVolume>, PrimitivesTag>
+    : public LegacyValues<Primitives, BoundingVolume>
+{
+public:
+  using self_type = LegacyValues<Primitives, BoundingVolume>;
+};
+
 template <typename Callback>
 struct LegacyCallbackWrapper
 {
diff --git a/src/details/ArborX_DetailsPermutedData.hpp b/src/details/ArborX_DetailsPermutedData.hpp
index 69d777337..96dd04d5f 100644
--- a/src/details/ArborX_DetailsPermutedData.hpp
+++ b/src/details/ArborX_DetailsPermutedData.hpp
@@ -36,6 +36,31 @@ struct PermutedData
   KOKKOS_FUNCTION auto size() const { return _data.size(); }
 };
 
+template <typename Data, typename Permute>
+struct PermutedData<Data, Permute, /*AttachIndices=*/true>
+{
+  using memory_space = typename Data::memory_space;
+  using value_type =
+      std::decay_t<decltype(attach(std::declval<Data const &>()(0), 0))>;
+
+  Data _data;
+  Permute _permute;
+
+  KOKKOS_FUNCTION decltype(auto) operator()(int i) const
+  {
+    return attach(_data(_permute(i)), i);
+  }
+  KOKKOS_FUNCTION auto size() const { return _data.size(); }
+};
+
+template <typename Data, typename Permute, bool AttachIndices, typename Tag>
+class AccessValuesI<PermutedData<Data, Permute, AttachIndices>, Tag>
+    : public PermutedData<Data, Permute, AttachIndices>
+{
+public:
+  using self_type = PermutedData<Data, Permute, AttachIndices>;
+};
+
 } // namespace Details
 
 template <typename Predicates, typename Permute, bool AttachIndices>
@@ -50,24 +75,13 @@ struct AccessTraits<Details::PermutedData<Predicates, Permute, AttachIndices>,
   KOKKOS_FUNCTION static std::size_t
   size(PermutedPredicates const &permuted_predicates)
   {
-    return permuted_predicates._data.size();
-  }
-
-  template <bool _Attach = AttachIndices>
-  KOKKOS_FUNCTION static auto get(PermutedPredicates const &permuted_predicates,
-                                  std::enable_if_t<_Attach, std::size_t> index)
-  {
-    auto const permuted_index = permuted_predicates._permute(index);
-    return attach(permuted_predicates._data(permuted_index), (int)index);
+    return permuted_predicates.size();
   }
 
-  template <bool _Attach = AttachIndices>
   KOKKOS_FUNCTION static decltype(auto)
-  get(PermutedPredicates const &permuted_predicates,
-      std::enable_if_t<!_Attach, std::size_t> index)
+  get(PermutedPredicates const &permuted_predicates, std::size_t index)
   {
-    auto const permuted_index = permuted_predicates._permute(index);
-    return permuted_predicates._data(permuted_index);
+    return permuted_predicates(index);
   }
 };