primitives/src/primitive/traits.cppm at 11beedecd3d35923bd4b2d5a709cb4336a9c6616 · mcpplibs/primitives · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
module;
#include <tuple>
#include <type_traits>

export module mcpplibs.primitives.primitive.traits;

import mcpplibs.primitives.primitive.impl;
import mcpplibs.primitives.policy.traits;
import mcpplibs.primitives.policy.utility;
import mcpplibs.primitives.underlying.traits;

namespace mcpplibs::primitives::meta::details {

template <typename T> struct primitive_traits_impl;

template <typename T, typename PoliciesTuple> struct make_primitive;

template <underlying_type T, policy::policy_type... Policies>
struct primitive_traits_impl<primitive<T, Policies...>> {
  using value_type = T;
  using policies = std::tuple<Policies...>;
  using value_policy =
      policy::resolve_policy_t<policy::category::value, Policies...>;
  using type_policy =
      policy::resolve_policy_t<policy::category::type, Policies...>;
  using error_policy =
      policy::resolve_policy_t<policy::category::error, Policies...>;
  using concurrency_policy =
      policy::resolve_policy_t<policy::category::concurrency, Policies...>;
};

template <underlying_type T, policy::policy_type... Policies>
struct make_primitive<T, std::tuple<Policies...>> {
  using type = primitive<T, Policies...>;
};

} // namespace mcpplibs::primitives::meta::details

// Public API exported from this module.
export namespace mcpplibs::primitives::meta {
using policy_category = policy::category;

template <underlying_type T, typename PoliciesTuple>
using make_primitive_t = details::make_primitive<T, PoliciesTuple>::type;

using default_policies =
    std::tuple<policy::resolve_policy_t<policy::category::value>,
               policy::resolve_policy_t<policy::category::type>,
               policy::resolve_policy_t<policy::category::error>,
               policy::resolve_policy_t<policy::category::concurrency>>;

template <typename T>
using traits = details::primitive_traits_impl<std::remove_cvref_t<T>>;

template <typename T>
concept primitive_type = requires {
  typename traits<T>::value_type;
  typename traits<T>::policies;
  typename traits<T>::value_policy;
  typename traits<T>::type_policy;
  typename traits<T>::error_policy;
  typename traits<T>::concurrency_policy;
};

template <typename T>
concept primitive_operand = primitive_type<std::remove_cvref_t<T>>;

template <typename T>
concept boolean =
    primitive_type<T> &&
    (underlying::traits<typename traits<T>::value_type>::kind ==
     underlying::category::boolean);

template <typename T>
concept character =
    primitive_type<T> &&
    (underlying::traits<typename traits<T>::value_type>::kind ==
     underlying::category::character);

template <typename T>
concept integer =
    primitive_type<T> &&
    (underlying::traits<typename traits<T>::value_type>::kind ==
     underlying::category::integer);

template <typename T>
concept floating =
    primitive_type<T> &&
    (underlying::traits<typename traits<T>::value_type>::kind ==
     underlying::category::floating);

template <typename T>
concept numeric = integer<T> || floating<T>;

template <typename T>
concept primitive_like =
    primitive_type<T> || underlying_type<std::remove_cvref_t<T>>;

template <typename T>
concept boolean_like =
    boolean<T> || boolean_underlying_type<std::remove_cvref_t<T>>;

template <typename T>
concept character_like =
    character<T> || character_underlying_type<std::remove_cvref_t<T>>;

template <typename T>
concept integer_like =
    integer<T> || integer_underlying_type<std::remove_cvref_t<T>>;

template <typename T>
concept floating_like =
    floating<T> || floating_underlying_type<std::remove_cvref_t<T>>;

template <typename T>
concept numeric_like =
    numeric<T> || numeric_underlying_type<std::remove_cvref_t<T>>;

} // namespace mcpplibs::primitives::meta