Enable binary comparison operations for internal tuple

include/oneapi/dpl/pstl/tuple_impl.h

@@ -49,6 +49,23 @@ struct tuple_element<0, oneapi::dpl::__internal::tuple<T, Rest...>>
     using type = T;
 };
 
+//forward declare new std::get<I>() functions so they can be used in impl
+template <size_t _Idx, typename... _Tp>
+constexpr std::tuple_element_t<_Idx, oneapi::dpl::__internal::tuple<_Tp...>>&
+get(oneapi::dpl::__internal::tuple<_Tp...>&);
+
+template <size_t _Idx, typename... _Tp>
+constexpr std::tuple_element_t<_Idx, oneapi::dpl::__internal::tuple<_Tp...>> const&
+get(const oneapi::dpl::__internal::tuple<_Tp...>&);
+
+template <size_t _Idx, typename... _Tp>
+constexpr std::tuple_element_t<_Idx, oneapi::dpl::__internal::tuple<_Tp...>>&&
+get(oneapi::dpl::__internal::tuple<_Tp...>&&);
+
+template <size_t _Idx, typename... _Tp>
+constexpr std::tuple_element_t<_Idx, oneapi::dpl::__internal::tuple<_Tp...>> const&&
+get(const oneapi::dpl::__internal::tuple<_Tp...>&&);
+
 template <typename... Args>
 struct tuple_size<oneapi::dpl::__internal::tuple<Args...>> : ::std::integral_constant<::std::size_t, sizeof...(Args)>
 {
@@ -289,6 +306,82 @@ struct __copy_assignable_holder<_Tp, false> : oneapi::dpl::__internal::__value_h
     operator=(__copy_assignable_holder&& other) = default;
 };
 
+template <typename _Tuple1, typename _Tuple2, int I = 0>
+constexpr bool
+__equal(_Tuple1&& __lhs, _Tuple2&& __rhs)
+{
+    static_assert(std::tuple_size_v<std::decay_t<_Tuple1>> == std::tuple_size_v<std::decay_t<_Tuple2>>,
+                  "Tuples must have the same size to be equality compared");
+    if constexpr (I < std::tuple_size_v<std::decay_t<_Tuple1>>)
+    {
+        return std::get<I>(__lhs) == std::get<I>(__rhs) &&
+               oneapi::dpl::__internal::__equal<_Tuple1, _Tuple2, I + 1>(std::forward<_Tuple1>(__lhs),
+                                                                         std::forward<_Tuple2>(__rhs));
+    }
+    else
+    {
+        return true;
+    }
+}
+template <typename _Tuple1, typename _Tuple2, int I = 0>
+constexpr bool
+__less(_Tuple1&& __lhs, _Tuple2&& __rhs)
+{
+    static_assert(std::tuple_size_v<std::decay_t<_Tuple1>> == std::tuple_size_v<std::decay_t<_Tuple2>>,
+                  "Tuples must have the same size to be compared");
+    if constexpr (I < std::tuple_size_v<std::decay_t<_Tuple1>>)
+    {
+        return std::get<I>(__lhs) < std::get<I>(__rhs) ||
+               (!(std::get<I>(__rhs) < std::get<I>(__lhs)) &&
+                oneapi::dpl::__internal::__less<_Tuple1, _Tuple2, I + 1>(std::forward<_Tuple1>(__lhs),
+                                                                         std::forward<_Tuple2>(__rhs)));
+    }
+    else
+    {
+        return false;
+    }
+}
+
+template <typename T>
+struct __is_internal_tuple : std::false_type
+{
+};
+
+template <typename... Ts>
+struct __is_internal_tuple<oneapi::dpl::__internal::tuple<Ts...>> : std::true_type
+{
+};
+
+template <typename T>
+inline constexpr bool __is_internal_tuple_v = __is_internal_tuple<T>::value;
+
+template <typename T>
+struct __is_std_tuple : std::false_type
+{
+};
+
+template <typename... Ts>
+struct __is_std_tuple<std::tuple<Ts...>> : std::true_type
+{
+};
+
+template <typename T>
+inline constexpr bool __is_std_tuple_v = __is_std_tuple<T>::value;
+
+// Either LHS = this internal tuple type + RHS = any compatible tuple type
+// or     LHS = std::tuple               + RHS = this internal tuple type
+// Note: We do not allow LHS to be "any compatible type" with a RHS as this internal tuple type because then we would
+//       have ambiguity comparing two different compatible internal tuple types, because both instantiations would
+//       create the necessary comparison. As written, the type instantiation of the type in the LHS is always
+//       responsible for creating this comparison operator.
+template <typename _ThisTuple, typename _U, typename _V>
+inline constexpr bool __enable_comparison_op_v =
+    (std::is_same_v<std::decay_t<_ThisTuple>, std::decay_t<_U>> &&                         //LHS +
+                    (oneapi::dpl::__internal::__is_std_tuple_v<std::decay_t<_V>> ||        //RHS option 1
+                     oneapi::dpl::__internal::__is_internal_tuple_v<std::decay_t<_V>>)) || //RHS option 2  - OR -
+    (oneapi::dpl::__internal::__is_std_tuple_v<std::decay_t<_U>> &&                        //LHS +
+                    std::is_same_v<std::decay_t<_ThisTuple>, std::decay_t<_V>>);           //RHS
+
 template <typename T1, typename... T>
 struct tuple<T1, T...>
 {
@@ -424,15 +517,52 @@ struct tuple<T1, T...>
         return *this;
     }
 
-    friend bool
-    operator==(const tuple& __lhs, const tuple& __rhs)
+    template <typename _U, typename _V,
+              std::enable_if_t<oneapi::dpl::__internal::__enable_comparison_op_v<tuple, _U, _V>, int> = 0>
+    friend constexpr bool
+    operator==(_U&& __lhs, _V&& __rhs)
+    {
+        return oneapi::dpl::__internal::__equal(std::forward<_U>(__lhs), std::forward<_V>(__rhs));
+    }
+
+    template <typename _U, typename _V,
+              std::enable_if_t<oneapi::dpl::__internal::__enable_comparison_op_v<tuple, _U, _V>, int> = 0>
+    friend constexpr bool
+    operator!=(_U&& __lhs, _V&& __rhs)
+    {
+        return !oneapi::dpl::__internal::__equal(std::forward<_U>(__lhs), std::forward<_V>(__rhs));
+    }
+
+    template <typename _U, typename _V,
+              std::enable_if_t<oneapi::dpl::__internal::__enable_comparison_op_v<tuple, _U, _V>, int> = 0>
+    friend constexpr bool
+    operator<(_U&& __lhs, _V&& __rhs)
+    {
+        return oneapi::dpl::__internal::__less(std::forward<_U>(__lhs), std::forward<_V>(__rhs));
+    }
+
+    template <typename _U, typename _V,
+              std::enable_if_t<oneapi::dpl::__internal::__enable_comparison_op_v<tuple, _U, _V>, int> = 0>
+    friend constexpr bool
+    operator<=(_U&& __lhs, _V&& __rhs)
     {
-        return __lhs.holder.value == __rhs.holder.value && __lhs.next == __rhs.next;
+        return !oneapi::dpl::__internal::__less(std::forward<_V>(__rhs), std::forward<_U>(__lhs));
     }
-    friend bool
-    operator!=(const tuple& __lhs, const tuple& __rhs)
+
+    template <typename _U, typename _V,
+              std::enable_if_t<oneapi::dpl::__internal::__enable_comparison_op_v<tuple, _U, _V>, int> = 0>
+    friend constexpr bool
+    operator>(_U&& __lhs, _V&& __rhs)
+    {
+        return oneapi::dpl::__internal::__less(std::forward<_V>(__rhs), std::forward<_U>(__lhs));
+    }
+
+    template <typename _U, typename _V,
+              std::enable_if_t<oneapi::dpl::__internal::__enable_comparison_op_v<tuple, _U, _V>, int> = 0>
+    friend constexpr bool
+    operator>=(_U&& __lhs, _V&& __rhs)
     {
-        return !(__lhs == __rhs);
+        return !oneapi::dpl::__internal::__less(std::forward<_U>(__lhs), std::forward<_V>(__rhs));
     }
 
     template <typename U1, typename... U, ::std::size_t... _Ip>
@@ -456,15 +586,41 @@ struct tuple<>
 
     tuple operator[](tuple) { return {}; }
     tuple operator[](const tuple&) const { return {}; }
+    operator tuple_type() const { return tuple_type{}; }
     tuple&
     operator=(const tuple&) = default;
     tuple&
     operator=(const ::std::tuple<>& /*other*/)
     {
         return *this;
     }
-    friend bool
-    operator==(const tuple& /*__lhs*/, const tuple& /*__rhs*/)
+    friend constexpr bool
+    operator==(const tuple&, const tuple&)
+    {
+        return true;
+    }
+    friend constexpr bool
+    operator!=(const tuple&, const tuple&)
+    {
+        return false;
+    }
+    friend constexpr bool
+    operator<(const tuple&, const tuple&)
+    {
+        return false;
+    }
+    friend constexpr bool
+    operator<=(const tuple&, const tuple&)
+    {
+        return true;
+    }
+    friend constexpr bool
+    operator>(const tuple&, const tuple&)
+    {
+        return false;
+    }
+    friend constexpr bool
+    operator>=(const tuple&, const tuple&)
     {
         return true;
     }

test/general/implementation_details/internal_tuple.pass.cpp

@@ -0,0 +1,98 @@
+// -*- C++ -*-
+//===-- tuple_unit.pass.cpp -----------------------------------------------===//
+//
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// This file incorporates work covered by the following copyright and permission
+// notice:
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+//
+//===----------------------------------------------------------------------===//
+#include <cstdint>
+#include "support/test_config.h"
+
+#include _PSTL_TEST_HEADER(tuple)
+
+#include "support/utils.h"
+
+template <typename... _T>
+static oneapi::dpl::__internal::tuple<_T...>
+to_onedpl_tuple(const std::tuple<_T...>& __t)
+{
+    return oneapi::dpl::__internal::tuple<_T...>(__t);
+}
+
+template <typename Tuple1, typename Tuple2>
+void
+test_tuple(Tuple1 t1, Tuple2 t2)
+{
+
+    auto onedpl_t1 = to_onedpl_tuple(t1);
+    auto onedpl_t2 = to_onedpl_tuple(t2);
+
+    static_assert(std::is_trivially_copyable_v<decltype(onedpl_t1)>, "oneDPL tuple is not trivially copyable");
+
+    // Test binary comparison operators for std::tuple and oneAPI::dpl::__internal::tuple
+    EXPECT_EQ((t1 == t2), (onedpl_t1 == onedpl_t2), "equality comparison does not match std::tuple");
+    EXPECT_EQ((t1 != t2), (onedpl_t1 != onedpl_t2), "inquality comparison does not match std::tuple");
+    EXPECT_EQ((t1 < t2), (onedpl_t1 < onedpl_t2), "less than comparison does not match std::tuple");
+    EXPECT_EQ((t1 <= t2), (onedpl_t1 <= onedpl_t2), "less than or equal to comparison does not match std::tuple");
+    EXPECT_EQ((t1 > t2), (onedpl_t1 > onedpl_t2), "greater than comparison does not match std::tuple");
+    EXPECT_EQ((t1 >= t2), (onedpl_t1 >= onedpl_t2), "greater than or equal to comparison does not match std::tuple");
+
+    EXPECT_EQ((t1 == t2), (t1 == onedpl_t2), "equality comparison does not match std::tuple");
+    EXPECT_EQ((t1 != t2), (t1 != onedpl_t2), "inquality comparison does not match std::tuple");
+    EXPECT_EQ((t1 < t2), (t1 < onedpl_t2), "less than comparison does not match std::tuple");
+    EXPECT_EQ((t1 <= t2), (t1 <= onedpl_t2), "less than or equal to comparison does not match std::tuple");
+    EXPECT_EQ((t1 > t2), (t1 > onedpl_t2), "greater than comparison does not match std::tuple");
+    EXPECT_EQ((t1 >= t2), (t1 >= onedpl_t2), "greater than or equal to comparison does not match std::tuple");
+
+    EXPECT_EQ((t1 == t2), (onedpl_t1 == t2), "equality comparison does not match std::tuple");
+    EXPECT_EQ((t1 != t2), (onedpl_t1 != t2), "inquality comparison does not match std::tuple");
+    EXPECT_EQ((t1 < t2), (onedpl_t1 < t2), "less than comparison does not match std::tuple");
+    EXPECT_EQ((t1 <= t2), (onedpl_t1 <= t2), "less than or equal to comparison does not match std::tuple");
+    EXPECT_EQ((t1 > t2), (onedpl_t1 > t2), "greater than comparison does not match std::tuple");
+    EXPECT_EQ((t1 >= t2), (onedpl_t1 >= t2), "greater than or equal to comparison does not match std::tuple");
+
+    //checking default construction (assumes elements are default constructible)
+    decltype(onedpl_t1) onedpl_t3{};
+    decltype(onedpl_t2) onedpl_t4{};
+    decltype(t1) t3{};
+    decltype(t2) t4{};
+
+    t4 = onedpl_t1;
+    EXPECT_TRUE(t1 == t4, "assignment of oneDPL tuple to std::tuple provides incorrect results");
+
+    t3 = onedpl_t2;
+    EXPECT_TRUE(t2 == t3, "assignment of oneDPL tuple to std::tuple provides incorrect results");
+
+    onedpl_t3 = t2;
+    EXPECT_TRUE(onedpl_t2 == onedpl_t3, "assignment of oneDPL tuple from std::tuple provides incorrect results");
+
+    onedpl_t4 = t1;
+    EXPECT_TRUE(onedpl_t1 == onedpl_t4, "assignment of oneDPL tuple from std::tuple provides incorrect results");
+
+    decltype(onedpl_t1) onedpl_t5 = onedpl_t2;
+    decltype(onedpl_t1) onedpl_t6 = onedpl_t1;
+
+    swap(onedpl_t5, onedpl_t6);
+    EXPECT_TRUE(((onedpl_t1 == onedpl_t5) && (onedpl_t6 == onedpl_t2)),
+                "swap of oneDPL tuple provides incorrect results");
+}
+
+int
+main()
+{
+    test_tuple(std::tuple<int, int, int>{1, 2, 3}, std::tuple<int, int, int>{1, 2, 3});
+    test_tuple(std::tuple<int, int, int>{1, 2, 3}, std::tuple<int, int, int>{1, 2, 4});
+    test_tuple(std::tuple<int, int, int>{1, 2, 3}, std::tuple<int, int, int>{0, 2, 4});
+    test_tuple(std::tuple<int, int, std::uint64_t>{1, 2, 3}, std::tuple<std::uint32_t, int, int>{1, 2, 3});
+    test_tuple(std::tuple<int, int, std::uint64_t>{1, 2, 3}, std::tuple<std::uint32_t, int, int>{0, 2, 4});
+    test_tuple(std::tuple<>{}, std::tuple<>{});
+
+    return TestUtils::done();
+}