16 #include <type_traits>
22 template <
typename... T>
struct tuple;
24 template <
typename T,
typename... Ts, std::size_t... Is>
26 const std::index_sequence<Is...> &) {
27 return std::tuple<Ts...>(std::get<Is + 1>(Tuple)...);
30 template <
typename T,
typename... Ts>
33 Tuple, std::make_index_sequence<
sizeof...(Ts)>());
37 return sycl::detail::tuple<Ts...>{Args...};
40 template <
typename... Ts>
auto tie(Ts &...Args) {
41 return sycl::detail::tuple<Ts &...>(Args...);
46 template <std::size_t N,
typename T,
typename... Rest>
50 template <
typename T,
typename... Rest>
55 template <std::
size_t I,
class T>
59 template <
size_t N>
struct get {
60 template <
typename... Ts>
63 return get<N - 1>()(Tuple.next);
66 template <
typename... Ts>
69 return get<N - 1>()(Tuple.next);
75 template <>
struct get<0> {
76 template <
typename... Ts>
79 template <
typename... Ts>
81 return Tuple.holder.value;
84 template <
typename... Ts>
85 constexpr ret_type<Ts...>
const &
87 return Tuple.holder.value;
99 bool = std::is_trivially_copy_assignable_v<TupleValueHolder<T>>>
104 template <
typename T>
110 this->value = RHS.
value;
115 template <
typename T,
typename... Ts>
struct tuple<T, Ts...> {
123 template <
typename UT,
typename... UTs>
125 : holder(RHS.holder.value), next(RHS.next) {}
127 tuple(
const T &Value,
const Ts &...Next) : holder(Value), next(Next...) {}
130 tuple(
const std::tuple<T, Ts...> &RHS)
134 operator std::tuple<T, Ts...>()
const {
135 return to_std_tuple(*
this, std::make_index_sequence<
sizeof...(Ts) + 1>());
139 template <
typename UT,
typename... UTs>
140 operator std::tuple<UT, UTs...>()
const {
141 return to_std_tuple(
static_cast<tuple<UT, UTs...
>>(*
this),
142 std::make_index_sequence<
sizeof...(Ts) + 1>());
145 template <
typename UT,
typename... UTs>
147 holder.
value = RHS.holder.value;
158 template <
typename UT,
typename... UTs>
160 holder.
value = std::get<0>(RHS);
166 return LHS.holder.value == RHS.holder.value && LHS.next == RHS.next;
169 return !(LHS == RHS);
172 template <
typename UT,
typename... UTs, std::size_t... Is>
174 std::index_sequence<Is...>) {
175 return std::tuple<UT, UTs...>(
get<Is>()(Tuple)...);
197 template <
size_t I,
typename... Types>
198 constexpr
typename tuple_element<I, tuple<Types...>>::type &
199 get(sycl::detail::tuple<Types...> &Arg) noexcept {
200 return sycl::detail::get<I>()(Arg);
203 template <
size_t I,
typename... Types>
204 constexpr
typename tuple_element<I, tuple<Types...>>::type
const &
205 get(
const sycl::detail::tuple<Types...> &Arg) noexcept {
206 return sycl::detail::get<I>()(Arg);