type_list.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_DETAIL_TYPE_LIST_MANIPULATION_HPP_
#define PLSSVM_DETAIL_TYPE_LIST_MANIPULATION_HPP_
#pragma once
 
#include <string>       // std::string
#include <tuple>        // std::tuple
#include <type_traits>  // std::disjunction, std::is_same_v
 
namespace plssvm::detail {
 
template <typename T, typename U>
struct real_type_label_type_combination {
    using real_type = T;
    using label_type = U;
};
 
// concatenate the types of two tuples in a new tuple
template <typename S, typename T>
struct concat_tuple_types;
template <typename... FirstTupleTypes, typename... SecondTupleTypes>
struct concat_tuple_types<std::tuple<FirstTupleTypes...>, std::tuple<SecondTupleTypes...>> {
    using type = std::tuple<FirstTupleTypes..., SecondTupleTypes...>;
};
template <typename... T>
using concat_tuple_types_t = typename concat_tuple_types<T...>::type;
 
// calculate the cartesian product of the types in two tuples and return a new tuple with the corresponding real_type_label_type_combination types.
template <typename S, typename T>
struct cartesian_type_product;
template <typename FirstTupleType, typename... FirstTupleRemainingTypes, typename... SecondTupleTypes>
struct cartesian_type_product<std::tuple<FirstTupleType, FirstTupleRemainingTypes...>, std::tuple<SecondTupleTypes...>> {
    // the cartesian product of {FirstTupleType} and {SecondTupleTypes...} is a list of real_type_label_type_combination
    using FirstTupleType_cross_SecondTupleTypes = std::tuple<real_type_label_type_combination<FirstTupleType, SecondTupleTypes>...>;
 
    // the cartesian product of {FirstTupleRemainingTypes...} and {Ts...} (computed recursively)
    using FirstTupleRemainingTypes_cross_SecondTupleTypes = typename cartesian_type_product<std::tuple<FirstTupleRemainingTypes...>, std::tuple<SecondTupleTypes...>>::type;
 
    // concatenate both products
    using type = concat_tuple_types_t<FirstTupleType_cross_SecondTupleTypes, FirstTupleRemainingTypes_cross_SecondTupleTypes>;
};
// end the recursion if the first tuple does not have any types left
template <typename... SecondTupleTypes>
struct cartesian_type_product<std::tuple<>, std::tuple<SecondTupleTypes...>> {
    using type = std::tuple<>;  // the cartesian product of {}x{...} is {}
};
template <typename... T>
using cartesian_type_product_t = typename cartesian_type_product<T...>::type;
 
using real_type_list = std::tuple<float, double>;
 
using label_type_list = std::tuple<bool, char, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, float, double, long double, std::string>;
 
using real_type_label_type_combination_list = detail::cartesian_type_product_t<real_type_list, label_type_list>;
 
template <typename T, typename Tuple>
struct type_list_contains;
 
template <typename T, typename... Types>
struct type_list_contains<T, std::tuple<Types...>> : std::disjunction<std::is_same<T, Types>...> {};
 
template <typename T, typename Tuple>
constexpr inline bool type_list_contains_v = type_list_contains<T, Tuple>::value;
 
}  // namespace plssvm::detail
 
#endif  // PLSSVM_DETAIL_TYPE_LIST_MANIPULATION_HPP_