mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-03 12:24:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Type List interface made generic

Browse Source
This commit is contained in:
Mateusz Pusz
2018-09-28 14:20:23 -07:00
parent 39bc536332
commit 8d42ed7eec
2 changed files with 62 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/include/units/bits/type_list.h
View File

@@ -27,32 +27,30 @@
namespace mp { namespace mp {
// type_list // namespace detail {
//
// template<typename T>
// struct is_type_list : std::false_type {};
//
// template<template<typename...> typename T, typename... Types>
// struct is_type_list<T<Types...>> : std::true_type {};
//
// }
template<typename... Types> // template<template<typename...> typename T, typename... Types>
struct type_list; // concept bool TypeList = requires(T<Types...>) {
// std::is_empty_v<T<Types...>>;
namespace detail { // };
#define TypeList typename
template<typename T>
struct is_type_list : std::false_type {};
template<typename... Types>
struct is_type_list<type_list<Types...>> : std::true_type {};
}
template<typename T>
bool concept TypeList = detail::is_type_list<T>::value;
// push_front // push_front
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
struct type_list_push_front; struct type_list_push_front;
template<typename... OldTypes, typename... NewTypes> template<template<typename...> typename List, typename... OldTypes, typename... NewTypes>
struct type_list_push_front<type_list<OldTypes...>, NewTypes...> { struct type_list_push_front<List<OldTypes...>, NewTypes...> {
using type = type_list<NewTypes..., OldTypes...>; using type = List<NewTypes..., OldTypes...>;
}; };
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
@@ -63,9 +61,9 @@ namespace mp {
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
struct type_list_push_back; struct type_list_push_back;
template<typename... OldTypes, typename... NewTypes> template<template<typename...> typename List, typename... OldTypes, typename... NewTypes>
struct type_list_push_back<type_list<OldTypes...>, NewTypes...> { struct type_list_push_back<List<OldTypes...>, NewTypes...> {
using type = type_list<OldTypes..., NewTypes...>; using type = List<OldTypes..., NewTypes...>;
}; };
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
@@ -75,18 +73,18 @@ namespace mp {
namespace detail { namespace detail {
template<std::size_t Idx, std::size_t N, typename... Types> template<template<typename...> typename List, std::size_t Idx, std::size_t N, typename... Types>
struct split_impl; struct split_impl;
template<std::size_t Idx, std::size_t N> template<template<typename...> typename List, std::size_t Idx, std::size_t N>
struct split_impl<Idx, N> { struct split_impl<List, Idx, N> {
using first_list = type_list<>; using first_list = List<>;
using second_list = type_list<>; using second_list = List<>;
}; };
template<std::size_t Idx, std::size_t N, typename T, typename... Rest> template<template<typename...> typename List, std::size_t Idx, std::size_t N, typename T, typename... Rest>
struct split_impl<Idx, N, T, Rest...> : split_impl<Idx + 1, N, Rest...> { struct split_impl<List, Idx, N, T, Rest...> : split_impl<List, Idx + 1, N, Rest...> {
using base = split_impl<Idx + 1, N, Rest...>; using base = split_impl<List, Idx + 1, N, Rest...>;
using base_first = typename base::first_list; using base_first = typename base::first_list;
using base_second = typename base::second_list; using base_second = typename base::second_list;
using first_list = std::conditional_t<Idx<N, type_list_push_front_t<base_first, T>, base_first>; using first_list = std::conditional_t<Idx<N, type_list_push_front_t<base_first, T>, base_first>;
@@ -98,10 +96,10 @@ namespace mp {
template<TypeList List, std::size_t N> template<TypeList List, std::size_t N>
struct type_list_split; struct type_list_split;
template<std::size_t N, typename... Types> template<template<typename...> typename List, std::size_t N, typename... Types>
struct type_list_split<type_list<Types...>, N> { struct type_list_split<List<Types...>, N> {
static_assert(N <= sizeof...(Types), "Invalid index provided"); static_assert(N <= sizeof...(Types), "Invalid index provided");
using split = detail::split_impl<0, N, Types...>; using split = detail::split_impl<List, 0, N, Types...>;
using first_list = typename split::first_list; using first_list = typename split::first_list;
using second_list = typename split::second_list; using second_list = typename split::second_list;
}; };
@@ -111,8 +109,8 @@ namespace mp {
template<TypeList List> template<TypeList List>
struct type_list_split_half; struct type_list_split_half;
template<typename... Types> template<template<typename...> typename List, typename... Types>
struct type_list_split_half<type_list<Types...>> : type_list_split<type_list<Types...>, (sizeof...(Types) + 1) / 2> { struct type_list_split_half<List<Types...>> : type_list_split<List<Types...>, (sizeof...(Types) + 1) / 2> {
}; };
// merge_sorted // merge_sorted
@@ -123,24 +121,24 @@ namespace mp {
template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred> template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred>
using type_list_merge_sorted_t = typename type_list_merge_sorted<SortedList1, SortedList2, Pred>::type; using type_list_merge_sorted_t = typename type_list_merge_sorted<SortedList1, SortedList2, Pred>::type;
template<typename... Lhs, template<typename, typename> typename Pred> template<template<typename...> typename List, typename... Lhs, template<typename, typename> typename Pred>
struct type_list_merge_sorted<type_list<Lhs...>, type_list<>, Pred> { struct type_list_merge_sorted<List<Lhs...>, List<>, Pred> {
using type = type_list<Lhs...>; using type = List<Lhs...>;
}; };
template<typename... Rhs, template<typename, typename> typename Pred> template<template<typename...> typename List, typename... Rhs, template<typename, typename> typename Pred>
struct type_list_merge_sorted<type_list<>, type_list<Rhs...>, Pred> { struct type_list_merge_sorted<List<>, List<Rhs...>, Pred> {
using type = type_list<Rhs...>; using type = List<Rhs...>;
}; };
template<typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest, template<template<typename...> typename List, typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest,
template<typename, typename> typename Pred> template<typename, typename> typename Pred>
struct type_list_merge_sorted<type_list<Lhs1, LhsRest...>, type_list<Rhs1, RhsRest...>, Pred> { struct type_list_merge_sorted<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
using type = std::conditional_t< using type = std::conditional_t<
Pred<Lhs1, Rhs1>::value, Pred<Lhs1, Rhs1>::value,
type_list_push_front_t<type_list_merge_sorted_t<type_list<LhsRest...>, type_list<Rhs1, RhsRest...>, Pred>, type_list_push_front_t<type_list_merge_sorted_t<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>,
Lhs1>, Lhs1>,
type_list_push_front_t<type_list_merge_sorted_t<type_list<Lhs1, LhsRest...>, type_list<RhsRest...>, Pred>, type_list_push_front_t<type_list_merge_sorted_t<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>,
Rhs1>>; Rhs1>>;
}; };
@@ -149,26 +147,26 @@ namespace mp {
template<TypeList List, template<typename, typename> typename Pred> template<TypeList List, template<typename, typename> typename Pred>
struct type_list_sort; struct type_list_sort;
template<template<typename, typename> typename Pred> template<template<typename...> typename List, template<typename, typename> typename Pred>
struct type_list_sort<type_list<>, Pred> { struct type_list_sort<List<>, Pred> {
using type = type_list<>; using type = List<>;
}; };
template<typename T, template<typename, typename> typename Pred> template<template<typename...> typename List, typename T, template<typename, typename> typename Pred>
struct type_list_sort<type_list<T>, Pred> { struct type_list_sort<List<T>, Pred> {
using type = type_list<T>; using type = List<T>;
}; };
template<typename... Types, template<typename, typename> typename Pred> template<template<typename...> typename List, typename... Types, template<typename, typename> typename Pred>
struct type_list_sort<type_list<Types...>, Pred> { struct type_list_sort<List<Types...>, Pred> {
using types = type_list<Types...>; using types = List<Types...>;
using split = type_list_split_half<type_list<Types...>>; using split = type_list_split_half<List<Types...>>;
using left = typename type_list_sort<typename split::first_list, Pred>::type; using left = typename type_list_sort<typename split::first_list, Pred>::type;
using right = typename type_list_sort<typename split::second_list, Pred>::type; using right = typename type_list_sort<typename split::second_list, Pred>::type;
using type = type_list_merge_sorted_t<left, right, Pred>; using type = type_list_merge_sorted_t<left, right, Pred>;
}; };
template<TypeList TypeList, template<typename, typename> typename Pred> template<TypeList List, template<typename, typename> typename Pred>
using type_list_sort_t = typename type_list_sort<TypeList, Pred>::type; using type_list_sort_t = typename type_list_sort<List, Pred>::type;
} // namespace mp } // namespace mp

11
test/test_type_list.cpp
View File

@@ -28,6 +28,9 @@ namespace {
using namespace mp; using namespace mp;
using namespace units; using namespace units;
template<typename... Types>
struct type_list;
// type_list_push_front // type_list_push_front
static_assert(std::is_same_v<type_list_push_front_t<type_list<>, int>, type_list<int>>); static_assert(std::is_same_v<type_list_push_front_t<type_list<>, int>, type_list<int>>);
@@ -95,8 +98,8 @@ namespace {
// type_list_sort // type_list_sort
template<typename TypeList> template<TypeList List>
using dim_sort_t = type_list_sort_t<TypeList, dim_id_less>; using dim_sort_t = type_list_sort_t<List, dim_id_less>;
static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>>>, type_list<dim_id<0>>>); static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>>>, type_list<dim_id<0>>>);
static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>, dim_id<1>>>, type_list<dim_id<0>, dim_id<1>>>); static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>, dim_id<1>>>, type_list<dim_id<0>, dim_id<1>>>);
@@ -110,8 +113,8 @@ namespace {
template<int Id, int Value> template<int Id, int Value>
using e = exp<dim_id<Id>, Value>; using e = exp<dim_id<Id>, Value>;
template<typename TypeList> template<TypeList List>
using exp_sort_t = type_list_sort_t<TypeList, exp_less>; using exp_sort_t = type_list_sort_t<List, exp_less>;
static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>>>, dimension<e<0, 1>>>); static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>>>, dimension<e<0, 1>>>);
static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>, e<1, -1>>>, dimension<e<0, 1>, e<1, -1>>>); static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>, e<1, -1>>>, dimension<e<0, 1>, e<1, -1>>>);