mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-07-31 19:04:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

type_list refactored

Browse Source
This commit is contained in:
Mateusz Pusz
2019-05-28 14:35:25 +02:00
parent 9d5e46cd53
commit c43871578e
3 changed files with 93 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -22,7 +22,7 @@
#pragma once #pragma once
#include <type_traits> #include <units/bits/type_traits.h>
namespace units { namespace units {
@@ -41,29 +41,37 @@ namespace units {
// push_front // push_front
template<TypeList List, typename... Types> namespace detail {
struct type_list_push_front;
template<typename List, typename... Types>
struct type_list_push_front_impl;
template<template<typename...> typename List, typename... OldTypes, typename... NewTypes> template<template<typename...> typename List, typename... OldTypes, typename... NewTypes>
struct type_list_push_front<List<OldTypes...>, NewTypes...> { struct type_list_push_front_impl<List<OldTypes...>, NewTypes...> {
using type = List<NewTypes..., OldTypes...>; using type = List<NewTypes..., OldTypes...>;
}; };
}
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
using type_list_push_front_t = type_list_push_front<List, Types...>::type; using type_list_push_front = detail::type_list_push_front_impl<List, Types...>::type;
// push_back // push_back
template<TypeList List, typename... Types> namespace detail {
struct type_list_push_back;
template<typename List, typename... Types>
struct type_list_push_back_impl;
template<template<typename...> typename List, typename... OldTypes, typename... NewTypes> template<template<typename...> typename List, typename... OldTypes, typename... NewTypes>
struct type_list_push_back<List<OldTypes...>, NewTypes...> { struct type_list_push_back_impl<List<OldTypes...>, NewTypes...> {
using type = List<OldTypes..., NewTypes...>; using type = List<OldTypes..., NewTypes...>;
}; };
}
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
using type_list_push_back_t = type_list_push_back<List, Types...>::type; using type_list_push_back = detail::type_list_push_back_impl<List, Types...>::type;
// split // split
@@ -81,10 +89,12 @@ namespace units {
template<template<typename...> typename List, 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<List, Idx, N, T, Rest...> : split_impl<List, Idx + 1, N, Rest...> { struct split_impl<List, Idx, N, T, Rest...> : split_impl<List, Idx + 1, N, Rest...> {
using base = split_impl<List, Idx + 1, N, Rest...>; using base = split_impl<List, Idx + 1, N, Rest...>;
using base_first = base::first_list; using first_list = conditional<Idx < N,
using base_second = base::second_list; typename type_list_push_front_impl<typename base::first_list, T>::type,
using first_list = std::conditional_t<Idx < N, type_list_push_front_t<base_first, T>, base_first>; typename base::first_list>;
using second_list = std::conditional_t<Idx < N, base_second, type_list_push_front_t<base_second, T>>; using second_list = conditional<Idx < N,
typename base::second_list,
typename type_list_push_front_impl<typename base::second_list, T>::type>;
}; };
} // namespace detail } // namespace detail
@@ -111,56 +121,65 @@ namespace units {
// merge_sorted // merge_sorted
template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred> namespace detail {
struct type_list_merge_sorted;
template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred> template<typename SortedList1, typename SortedList2, template<typename, typename> typename Pred>
using type_list_merge_sorted_t = type_list_merge_sorted<SortedList1, SortedList2, Pred>::type; struct type_list_merge_sorted_impl;
template<template<typename...> typename List, typename... Lhs, template<typename, typename> typename Pred> template<template<typename...> typename List, typename... Lhs, template<typename, typename> typename Pred>
struct type_list_merge_sorted<List<Lhs...>, List<>, Pred> { struct type_list_merge_sorted_impl<List<Lhs...>, List<>, Pred> {
using type = List<Lhs...>; using type = List<Lhs...>;
}; };
template<template<typename...> typename List, typename... Rhs, template<typename, typename> typename Pred> template<template<typename...> typename List, typename... Rhs, template<typename, typename> typename Pred>
struct type_list_merge_sorted<List<>, List<Rhs...>, Pred> { struct type_list_merge_sorted_impl<List<>, List<Rhs...>, Pred> {
using type = List<Rhs...>; using type = List<Rhs...>;
}; };
template<template<typename...> typename List, 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<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> { struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
using type = std::conditional_t< using type = conditional<
Pred<Lhs1, Rhs1>::value, Pred<Lhs1, Rhs1>::value,
type_list_push_front_t<type_list_merge_sorted_t<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>, Lhs1>, typename type_list_push_front_impl<typename type_list_merge_sorted_impl<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>::type, Lhs1>::type,
type_list_push_front_t<type_list_merge_sorted_t<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>, Rhs1>>; typename type_list_push_front_impl<typename type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>::type, Rhs1>::type>;
}; };
}
template<TypeList SortedList1, typename SortedList2, template<typename, typename> typename Pred>
using type_list_merge_sorted = detail::type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
// sort // sort
template<TypeList List, template<typename, typename> typename Pred> namespace detail {
struct type_list_sort;
template<typename List, template<typename, typename> typename Pred>
struct type_list_sort_impl;
template<template<typename...> typename List, template<typename, typename> typename Pred> template<template<typename...> typename List, template<typename, typename> typename Pred>
struct type_list_sort<List<>, Pred> { struct type_list_sort_impl<List<>, Pred> {
using type = List<>; using type = List<>;
}; };
template<template<typename...> typename List, typename T, template<typename, typename> typename Pred> template<template<typename...> typename List, typename T, template<typename, typename> typename Pred>
struct type_list_sort<List<T>, Pred> { struct type_list_sort_impl<List<T>, Pred> {
using type = List<T>; using type = List<T>;
}; };
template<template<typename...> typename List, typename... Types, template<typename, typename> typename Pred> template<template<typename...> typename List, typename... Types, template<typename, typename> typename Pred>
struct type_list_sort<List<Types...>, Pred> { struct type_list_sort_impl<List<Types...>, Pred> {
using types = List<Types...>; using types = List<Types...>;
using split = type_list_split_half<List<Types...>>; using split = type_list_split_half<List<Types...>>;
using left = type_list_sort<typename split::first_list, Pred>::type; using left = type_list_sort_impl<typename split::first_list, Pred>::type;
using right = type_list_sort<typename split::second_list, Pred>::type; using right = type_list_sort_impl<typename split::second_list, Pred>::type;
using type = type_list_merge_sorted_t<left, right, Pred>; using type = type_list_merge_sorted_impl<left, right, Pred>::type;
}; };
}
template<TypeList List, template<typename, typename> typename Pred> template<TypeList List, template<typename, typename> typename Pred>
using type_list_sort_t = type_list_sort<List, Pred>::type; using type_list_sort = detail::type_list_sort_impl<List, Pred>::type;
} // namespace units } // namespace units

6
src/include/units/dimension.h
View File

@@ -142,7 +142,7 @@ namespace units {
struct dim_consolidate<dimension<E1, ERest...>> { struct dim_consolidate<dimension<E1, ERest...>> {
using rest = dim_consolidate_t<dimension<ERest...>>; using rest = dim_consolidate_t<dimension<ERest...>>;
using type = using type =
std::conditional_t<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front_t<rest, E1>>; std::conditional_t<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
}; };
template<typename D, int V1, int V2, Exponent... ERest> template<typename D, int V1, int V2, Exponent... ERest>
@@ -155,7 +155,7 @@ namespace units {
template<Exponent... Es> template<Exponent... Es>
struct make_dimension { struct make_dimension {
using type = type_list_sort_t<detail::dim_consolidate_t<type_list_sort_t<dimension<Es...>, exp_dim_id_less>>, exp_greater_equal>; using type = type_list_sort<detail::dim_consolidate_t<type_list_sort<dimension<Es...>, exp_dim_id_less>>, exp_greater_equal>;
}; };
template<Exponent... Es> template<Exponent... Es>
@@ -163,7 +163,7 @@ namespace units {
template<Dimension D1, Dimension D2> template<Dimension D1, Dimension D2>
struct merge_dimension { struct merge_dimension {
using type = type_list_sort_t<detail::dim_consolidate_t<type_list_merge_sorted_t<D1, D2, exp_dim_id_less>>, exp_greater_equal>; using type = type_list_sort<detail::dim_consolidate_t<type_list_merge_sorted<D1, D2, exp_dim_id_less>>, exp_greater_equal>;
}; };
template<Dimension D1, Dimension D2> template<Dimension D1, Dimension D2>

24
test/unit_test/test_type_list.cpp
View File

@@ -32,15 +32,15 @@ namespace {
// 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<type_list<>, int>, type_list<int>>);
static_assert(std::is_same_v<type_list_push_front_t<type_list<>, int, long, double>, type_list<int, long, double>>); static_assert(std::is_same_v<type_list_push_front<type_list<>, int, long, double>, type_list<int, long, double>>);
static_assert(std::is_same_v<type_list_push_front_t<type_list<double>, int, long>, type_list<int, long, double>>); static_assert(std::is_same_v<type_list_push_front<type_list<double>, int, long>, type_list<int, long, double>>);
// type_list_push_back // type_list_push_back
static_assert(std::is_same_v<type_list_push_back_t<type_list<>, int>, type_list<int>>); static_assert(std::is_same_v<type_list_push_back<type_list<>, int>, type_list<int>>);
static_assert(std::is_same_v<type_list_push_back_t<type_list<>, int, long, double>, type_list<int, long, double>>); static_assert(std::is_same_v<type_list_push_back<type_list<>, int, long, double>, type_list<int, long, double>>);
static_assert(std::is_same_v<type_list_push_back_t<type_list<double>, int, long>, type_list<double, int, long>>); static_assert(std::is_same_v<type_list_push_back<type_list<double>, int, long>, type_list<double, int, long>>);
// type_list_split // type_list_split
@@ -83,22 +83,22 @@ namespace {
// type_list_merge_sorted // type_list_merge_sorted
static_assert(std::is_same_v<type_list_merge_sorted_t<type_list<dim_id<0>>, type_list<dim_id<1>>, dim_id_less>, static_assert(std::is_same_v<type_list_merge_sorted<type_list<dim_id<0>>, type_list<dim_id<1>>, dim_id_less>,
type_list<dim_id<0>, dim_id<1>>>); type_list<dim_id<0>, dim_id<1>>>);
static_assert(std::is_same_v<type_list_merge_sorted_t<type_list<dim_id<1>>, type_list<dim_id<0>>, dim_id_less>, static_assert(std::is_same_v<type_list_merge_sorted<type_list<dim_id<1>>, type_list<dim_id<0>>, dim_id_less>,
type_list<dim_id<0>, dim_id<1>>>); type_list<dim_id<0>, dim_id<1>>>);
static_assert(std::is_same_v<type_list_merge_sorted_t<type_list<dim_id<27>, dim_id<38>>, static_assert(std::is_same_v<type_list_merge_sorted<type_list<dim_id<27>, dim_id<38>>,
type_list<dim_id<3>, dim_id<43>>, dim_id_less>, type_list<dim_id<3>, dim_id<43>>, dim_id_less>,
type_list<dim_id<3>, dim_id<27>, dim_id<38>, dim_id<43>>>); type_list<dim_id<3>, dim_id<27>, dim_id<38>, dim_id<43>>>);
static_assert( static_assert(
std::is_same_v<type_list_merge_sorted_t<type_list<dim_id<9>, dim_id<82>>, type_list<dim_id<10>>, dim_id_less>, std::is_same_v<type_list_merge_sorted<type_list<dim_id<9>, dim_id<82>>, type_list<dim_id<10>>, dim_id_less>,
type_list<dim_id<9>, dim_id<10>, dim_id<82>>>); type_list<dim_id<9>, dim_id<10>, dim_id<82>>>);
// type_list_sort // type_list_sort
template<TypeList List> template<TypeList List>
using dim_sort_t = type_list_sort_t<List, dim_id_less>; using dim_sort_t = type_list_sort<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>>>);
@@ -113,7 +113,7 @@ namespace {
using e = exp<dim_id<Id>, Value>; using e = exp<dim_id<Id>, Value>;
template<TypeList List> template<TypeList List>
using exp_sort_t = type_list_sort_t<List, exp_dim_id_less>; using exp_sort_t = type_list_sort<List, exp_dim_id_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>>>);