Refactored tuple functionality

Author: mmoelle1

include/splines/functionspace.hpp

@@ -19,7 +19,7 @@
 #include <splines/bspline.hpp>
 #include <splines/boundary.hpp>
 #include <utils/container.hpp>
-#include <utils/type_traits.hpp>
+#include <utils/tuple.hpp>
 #include <utils/zip.hpp>
 
 namespace iganet {

include/utils.h

@@ -26,7 +26,6 @@
 #include <utils/solver.hpp>
 #include <utils/tensorarray.hpp>
 #include <utils/tuple.hpp>
-#include <utils/type_traits.hpp>
 #include <utils/uuid.hpp>
 #include <utils/vslice.hpp>
 #include <utils/zip.hpp>

include/utils/tuple.hpp

@@ -15,10 +15,65 @@
 #pragma once
 
 #include <tuple>
+#include <type_traits>
 #include <vector>
 
 namespace iganet::utils {
 
+/// @brief Type trait for std::tuple type
+/// @{
+template <class T> struct is_tuple : std::false_type {};
+
+template <class... Ts> struct is_tuple<std::tuple<Ts...>> : std::true_type {};
+/// @}
+
+template <class T> inline constexpr bool is_tuple_v = is_tuple<T>::value;
+
+/// @brief Type trait for std::tuple<std::tuple> type
+/// @{
+template <class T> struct is_tuple_of_tuples : std::false_type {};
+
+template <class... Ts>
+struct is_tuple_of_tuples<std::tuple<Ts...>>
+    : std::common_type_t<is_tuple<Ts>...> {};
+/// @}
+
+/// @brief Alias for is_tuple_of_tuples::type
+template <class T> using is_tuple_of_tuples_t = is_tuple_of_tuples<T>::type;
+
+/// @brief Alias for is_tuple_of_tuples::value
+template <class T>
+inline constexpr auto is_tuple_of_tuples_v = is_tuple_of_tuples<T>::value;
+
+/// @brief Type trait for concatenating std::tuples
+/// @{
+template <typename... Tuples> struct tuple_cat;
+
+template <> struct tuple_cat<> {
+  using type = std::tuple<>;
+};
+
+template <typename... Ts, typename... Tuples>
+struct tuple_cat<std::tuple<Ts...>, Tuples...> {
+  using type = decltype(std::tuple_cat(
+      std::declval<std::tuple<Ts...>>(),
+      std::declval<typename tuple_cat<Tuples...>::type>()));
+};
+
+template <typename T, typename... Tuples> struct tuple_cat<T, Tuples...> {
+  using type = decltype(std::tuple_cat(
+      std::declval<std::tuple<T>>(),
+      std::declval<typename tuple_cat<Tuples...>::type>()));
+};
+/// @}
+
+/// @brief Alias for tuple_cat::type
+template <typename... Tuples> using tuple_cat_t = tuple_cat<Tuples...>::type;
+
+/// @brief Alias for tuple_cat::value
+template <typename... Tuples>
+inline constexpr auto tuple_cat_v = tuple_cat<Tuples...>::value;
+  
 /// @brief Concatenates the entries of a std::tuple object into a
 /// single Torch tensor along the given dimension
 template <typename... Tensors>