forked from 1261385937/nlohmann_json_reflect
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathjson_reflect_meta.hpp
171 lines (123 loc) · 6 KB
/
json_reflect_meta.hpp
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#include <vector>
#include <deque>
#include <list>
#include <forward_list>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <optional>
#include "reflection.hpp"
namespace jreflect {
template<template<typename...> class Container, typename T>
struct is_specialization_of :std::false_type {};
template<template<typename...> class Container, typename ...Args>
struct is_specialization_of<Container, Container<Args...>> :std::true_type {};
template<template<typename...> typename Container, typename T>
struct is_sequence_specialization_of :std::false_type {};
template<template<typename...> typename Container, typename ...Args>
struct is_sequence_specialization_of <Container, Container<Args...>> :std::true_type {
using element_type = typename Container<Args...>::value_type;
};
template<template<typename...> typename Container, typename T>
struct is_associative_specialization_of :std::false_type {};
template<template<typename...> typename Container, typename ...Args>
struct is_associative_specialization_of <Container, Container<Args...>> :std::true_type {
using element_type = typename Container<Args...>::mapped_type;
};
//sequence container for json
template<typename T>
struct is_std_vector :is_sequence_specialization_of<std::vector, std::decay_t<T>> {};
template<typename T>
struct is_std_deque :is_sequence_specialization_of<std::deque, std::decay_t<T>> {};
template<typename T>
struct is_std_list : is_sequence_specialization_of<std::list, std::decay_t<T>> {};
template<typename T>
struct is_std_forward_list : is_sequence_specialization_of<std::forward_list, std::decay_t<T>> {};
template<typename T>
struct is_std_set : is_sequence_specialization_of<std::set, std::decay_t<T>> {};
template<typename T>
struct is_std_unordered_set : is_sequence_specialization_of<std::unordered_set, std::decay_t<T>> {};
template<typename T>
struct is_std_multiset : is_sequence_specialization_of<std::multiset, std::decay_t<T>> {};
template<typename T>
struct is_std_unordered_multiset : is_sequence_specialization_of<std::unordered_multiset, std::decay_t<T>> {};
template<typename Type>
struct is_std_array :std::false_type {};
template<typename Item, std::size_t N>
struct is_std_array<std::array<Item, N>> :std::true_type {
using element_type = Item;
};
//associative container for json
template<typename T>
struct is_std_map :is_associative_specialization_of<std::map, std::decay_t<T>> {};
template<typename T>
struct is_std_unordered_map :is_associative_specialization_of<std::unordered_map, std::decay_t<T>> {};
template<typename T>
struct is_std_multimap :is_associative_specialization_of<std::multimap, std::decay_t<T>> {};
template<typename T>
struct is_std_unordered_multimap :is_associative_specialization_of<std::unordered_multimap, std::decay_t<T>> {};
//other container
template<typename T>
struct is_std_tuple :is_specialization_of<std::tuple, std::decay_t<T>> {};
template<typename T>
struct is_std_optional : is_specialization_of<std::optional, std::decay_t<T>> {};
//compile time true/false
template <typename T>
inline constexpr bool is_std_vector_v = is_std_vector<T>::value;
template <typename T>
inline constexpr bool is_std_deque_v = is_std_deque<T>::value;
template <typename T>
inline constexpr bool is_std_list_v = is_std_list<T>::value;
template <typename T>
inline constexpr bool is_std_forward_list_v = is_std_forward_list<T>::value;
template <typename T>
inline constexpr bool is_std_set_v = is_std_set<T>::value;
template <typename T>
inline constexpr bool is_std_unordered_set_v = is_std_unordered_set<T>::value;
template <typename T>
inline constexpr bool is_std_multiset_v = is_std_multiset<T>::value;
template <typename T>
inline constexpr bool is_std_unordered_multiset_v = is_std_unordered_multiset<T>::value;
template <typename T>
inline constexpr bool is_std_map_v = is_std_map<T>::value;
template <typename T>
inline constexpr bool is_std_unordered_map_v = is_std_unordered_map<T>::value;
template <typename T>
inline constexpr bool is_std_multimap_v = is_std_multimap<T>::value;
template <typename T>
inline constexpr bool is_std_unordered_multimap_v = is_std_unordered_multimap<T>::value;
template <typename T>
inline constexpr bool is_std_array_v = is_std_array<T>::value;
template <typename T>
inline constexpr bool is_std_tuple_v = is_std_tuple<T>::value;
template <typename T>
inline constexpr bool is_std_optional_v = is_std_optional<T>::value;
template<typename T>
inline constexpr bool is_sequence_std_container_v =
is_std_vector_v<T> || is_std_deque_v<T> || is_std_list_v<T> ||
is_std_forward_list_v<T> || is_std_set_v<T> || is_std_unordered_set_v<T> ||
is_std_multiset_v<T> || is_std_unordered_multiset_v<T> || is_std_array_v<T>;
template<typename T>
inline constexpr bool is_associative_std_container_v =
is_std_map_v<T> || is_std_unordered_map_v<T> || is_std_multimap_v<T> || is_std_unordered_multimap_v<T>;
template<typename T>
inline constexpr bool is_std_container_v = is_sequence_std_container_v<T> || is_associative_std_container_v<T>;
template <typename>
inline constexpr bool always_false_v = false;
//detect std container has reflect type
template<typename T, typename U = void>
struct is_has_reflect_type :std::false_type {};
template<typename T>
struct is_has_reflect_type<T, std::enable_if_t<std::is_same_v<typename T::reflect_type, reflection::reflect>>> :std::true_type {};
template<typename T>
struct is_has_reflect_type<T, std::enable_if_t<std::is_same_v<typename decltype(reflection_reflect_member(std::declval<T>()))::reflect_type, reflection::reflect>>> :std::true_type {};
template<typename T>
struct is_has_reflect_type<T, std::enable_if_t<is_sequence_std_container_v<T>/*, std::void_t<typename T::value_type>*/>>
: is_has_reflect_type<typename T::value_type> {};
template<typename T>
struct is_has_reflect_type<T, std::enable_if_t<is_associative_std_container_v<T>/*, std::void_t<typename T::mapped_type>*/>>
: is_has_reflect_type<typename T::mapped_type> {};
template<typename T>
inline constexpr bool is_has_reflect_type_v = is_has_reflect_type<T>::value;
}