TensorSyclTuple.h
00001 // This file is part of Eigen, a lightweight C++ template library
00002 // for linear algebra.
00003 //
00004 // Mehdi Goli    Codeplay Software Ltd.
00005 // Ralph Potter  Codeplay Software Ltd.
00006 // Luke Iwanski  Codeplay Software Ltd.
00007 // Contact: <eigen@codeplay.com>
00008 //
00009 // This Source Code Form is subject to the terms of the Mozilla
00010 // Public License v. 2.0. If a copy of the MPL was not distributed
00011 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
00012 
00013 /*****************************************************************
00014  * TensroSyclTuple.h
00015  *
00016  * \brief:
00017  *  Minimal implementation of std::tuple that can be used inside a SYCL kernel.
00018  *
00019 *****************************************************************/
00020 
00021 #ifndef UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_TUPLE_HPP
00022 #define UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_TUPLE_HPP
00023 namespace utility {
00024 namespace tuple {
00028 template <bool, typename T = void> struct StaticIf;
00030 template <typename T>
00031 struct StaticIf<true, T> {
00032   typedef T type;
00033 };
00034 
00039 template <class... Ts>
00040 struct Tuple {};
00041 
00046 template <class T, class... Ts>
00047 struct Tuple<T, Ts...> {
00048   Tuple(T t, Ts... ts) : head(t), tail(ts...) {}
00049   T head;
00050   Tuple<Ts...> tail;
00051 };
00052 
00058 template <size_t, class>
00059 struct ElemTypeHolder;
00060 
00063 template <class T, class... Ts>
00064 struct ElemTypeHolder<0, Tuple<T, Ts...> > {
00065   typedef T type;
00066 };
00067 
00074 template <size_t k, class T, class... Ts>
00075 struct ElemTypeHolder<k, Tuple<T, Ts...> > {
00076   typedef typename ElemTypeHolder<k - 1, Tuple<Ts...> >::type type;
00077 };
00078 
00085 
00086 #define TERMINATE_CONDS_TUPLE_GET(CVQual) \
00087 template <size_t k, class... Ts> \
00088 typename StaticIf<k == 0, CVQual typename ElemTypeHolder<0, Tuple<Ts...> >::type &>::type \
00089 get(CVQual Tuple<Ts...> &t) { \
00090   static_assert(sizeof...(Ts)!=0, "The requseted value is bigger than the size of the tuple"); \
00091   return t.head; \
00092 }
00093 
00094 TERMINATE_CONDS_TUPLE_GET(const)
00095 TERMINATE_CONDS_TUPLE_GET()
00096 #undef TERMINATE_CONDS_TUPLE_GET
00097 
00098 
00099 
00100 
00101 
00102 
00103 
00104 #define RECURSIVE_TUPLE_GET(CVQual) \
00105 template <size_t k, class T, class... Ts> \
00106 typename StaticIf<k != 0, CVQual typename ElemTypeHolder<k, Tuple<T, Ts...> >::type &>::type \
00107 get(CVQual Tuple<T, Ts...> &t) { \
00108   return utility::tuple::get<k - 1>(t.tail); \
00109 }
00110 RECURSIVE_TUPLE_GET(const)
00111 RECURSIVE_TUPLE_GET()
00112 #undef RECURSIVE_TUPLE_GET
00113 
00120 template <typename... Args>
00121 Tuple<Args...> make_tuple(Args... args) {
00122   return Tuple<Args...>(args...);
00123 }
00124 
00130 template <typename... Args>
00131 static constexpr size_t size(Tuple<Args...> &) {
00132   return sizeof...(Args);
00133 }
00134 
00138 template <size_t... Is>
00139 struct IndexList {};
00140 
00147 template <size_t MIN, size_t N, size_t... Is>
00148 struct RangeBuilder;
00149 
00154 template <size_t MIN, size_t... Is>
00155 struct RangeBuilder<MIN, MIN, Is...> {
00156   typedef IndexList<Is...> type;
00157 };
00158 
00165 template <size_t MIN, size_t N, size_t... Is>
00166 struct RangeBuilder : public RangeBuilder<MIN, N - 1, N - 1, Is...> {};
00167 
00171 template <size_t MIN, size_t MAX>
00172 struct IndexRange: RangeBuilder<MIN, MAX>::type {};
00173 
00183 template <typename... Args, typename T, size_t... I>
00184 Tuple<Args..., T> append_base(Tuple<Args...> t, T a,IndexList<I...>) {
00185   return utility::tuple::make_tuple(get<I>(t)..., a);
00186 }
00187 
00196 template <typename... Args, typename T>
00197 Tuple<Args..., T> append(Tuple<Args...> t, T a) {
00198   return utility::tuple::append_base(t, a,  IndexRange<0, sizeof...(Args)>());
00199 }
00200 
00214 template <typename... Args1, typename... Args2, size_t... I1, size_t... I2>
00215 Tuple<Args1..., Args2...> append_base(Tuple<Args1...> t1, Tuple<Args2...> t2, IndexList<I1...>, IndexList<I2...>) {
00216   return utility::tuple::make_tuple(get<I1>(t1)...,get<I2>(t2)...);
00217 }
00218 
00228 template <typename... Args1, typename... Args2>
00229 Tuple<Args1..., Args2...> append(Tuple<Args1...> t1,Tuple<Args2...> t2) {
00230   return utility::tuple::append_base(t1, t2, IndexRange<0, sizeof...(Args1)>(), IndexRange<0, sizeof...(Args2)>());
00231 }
00232 }  // tuple
00233 }  // utility
00234 #endif  // UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_TUPLE_HPP
 All Classes Functions Variables Typedefs Enumerator