mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-07-30 02:17:16 +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

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

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

24
test/unit_test/test_type_list.cpp
View File

@ -32,15 +32,15 @@ namespace {
// 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, 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<>, int>, type_list<int>>);
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<type_list<double>, int, long>, type_list<int, long, double>>);
// 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_t<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<>, int>, type_list<int>>);
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<type_list<double>, int, long>, type_list<double, int, long>>);
// type_list_split
@ -83,22 +83,22 @@ namespace {
// 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>>>);
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>>>);
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<27>, dim_id<38>, dim_id<43>>>);
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_sort
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>, dim_id<1>>>, type_list<dim_id<0>, dim_id<1>>>);
@ -113,7 +113,7 @@ namespace {
using e = exp<dim_id<Id>, Value>;
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>, e<1, -1>>>, dimension<e<0, 1>, e<1, -1>>>);