318
+ − 1 // Copyright Toru Niina 2017.
+ − 2 // Distributed under the MIT License.
+ − 3 #ifndef TOML11_TRAITS_HPP
+ − 4 #define TOML11_TRAITS_HPP
+ − 5
+ − 6 #include "from.hpp"
+ − 7 #include "into.hpp"
+ − 8 #include "version.hpp"
+ − 9
+ − 10 #include <chrono>
+ − 11 #include <forward_list>
+ − 12 #include <string>
+ − 13 #include <tuple>
+ − 14 #include <type_traits>
+ − 15 #include <utility>
+ − 16
+ − 17 #if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
+ − 18 #if __has_include(<string_view>)
+ − 19 #include <string_view>
+ − 20 #endif // has_include(<string_view>)
+ − 21 #endif // cplusplus >= C++17
+ − 22
+ − 23 namespace toml
+ − 24 {
+ − 25 template<typename C, template<typename ...> class T, template<typename ...> class A>
+ − 26 class basic_value;
+ − 27
+ − 28 namespace detail
+ − 29 {
+ − 30 // ---------------------------------------------------------------------------
+ − 31 // check whether type T is a kind of container/map class
+ − 32
+ − 33 struct has_iterator_impl
+ − 34 {
+ − 35 template<typename T> static std::true_type check(typename T::iterator*);
+ − 36 template<typename T> static std::false_type check(...);
+ − 37 };
+ − 38 struct has_value_type_impl
+ − 39 {
+ − 40 template<typename T> static std::true_type check(typename T::value_type*);
+ − 41 template<typename T> static std::false_type check(...);
+ − 42 };
+ − 43 struct has_key_type_impl
+ − 44 {
+ − 45 template<typename T> static std::true_type check(typename T::key_type*);
+ − 46 template<typename T> static std::false_type check(...);
+ − 47 };
+ − 48 struct has_mapped_type_impl
+ − 49 {
+ − 50 template<typename T> static std::true_type check(typename T::mapped_type*);
+ − 51 template<typename T> static std::false_type check(...);
+ − 52 };
+ − 53 struct has_reserve_method_impl
+ − 54 {
+ − 55 template<typename T> static std::false_type check(...);
+ − 56 template<typename T> static std::true_type check(
+ − 57 decltype(std::declval<T>().reserve(std::declval<std::size_t>()))*);
+ − 58 };
+ − 59 struct has_push_back_method_impl
+ − 60 {
+ − 61 template<typename T> static std::false_type check(...);
+ − 62 template<typename T> static std::true_type check(
+ − 63 decltype(std::declval<T>().push_back(std::declval<typename T::value_type>()))*);
+ − 64 };
+ − 65 struct is_comparable_impl
+ − 66 {
+ − 67 template<typename T> static std::false_type check(...);
+ − 68 template<typename T> static std::true_type check(
+ − 69 decltype(std::declval<T>() < std::declval<T>())*);
+ − 70 };
+ − 71
+ − 72 struct has_from_toml_method_impl
+ − 73 {
+ − 74 template<typename T, typename C,
+ − 75 template<typename ...> class Tb, template<typename ...> class A>
+ − 76 static std::true_type check(
+ − 77 decltype(std::declval<T>().from_toml(
+ − 78 std::declval<::toml::basic_value<C, Tb, A>>()))*);
+ − 79
+ − 80 template<typename T, typename C,
+ − 81 template<typename ...> class Tb, template<typename ...> class A>
+ − 82 static std::false_type check(...);
+ − 83 };
+ − 84 struct has_into_toml_method_impl
+ − 85 {
+ − 86 template<typename T>
+ − 87 static std::true_type check(decltype(std::declval<T>().into_toml())*);
+ − 88 template<typename T>
+ − 89 static std::false_type check(...);
+ − 90 };
+ − 91
+ − 92 struct has_specialized_from_impl
+ − 93 {
+ − 94 template<typename T>
+ − 95 static std::false_type check(...);
+ − 96 template<typename T, std::size_t S = sizeof(::toml::from<T>)>
+ − 97 static std::true_type check(::toml::from<T>*);
+ − 98 };
+ − 99 struct has_specialized_into_impl
+ − 100 {
+ − 101 template<typename T>
+ − 102 static std::false_type check(...);
+ − 103 template<typename T, std::size_t S = sizeof(::toml::into<T>)>
+ − 104 static std::true_type check(::toml::from<T>*);
+ − 105 };
+ − 106
+ − 107
+ − 108 /// Intel C++ compiler can not use decltype in parent class declaration, here
+ − 109 /// is a hack to work around it. https://stackoverflow.com/a/23953090/4692076
+ − 110 #ifdef __INTEL_COMPILER
+ − 111 #define decltype(...) std::enable_if<true, decltype(__VA_ARGS__)>::type
+ − 112 #endif
+ − 113
+ − 114 template<typename T>
+ − 115 struct has_iterator : decltype(has_iterator_impl::check<T>(nullptr)){};
+ − 116 template<typename T>
+ − 117 struct has_value_type : decltype(has_value_type_impl::check<T>(nullptr)){};
+ − 118 template<typename T>
+ − 119 struct has_key_type : decltype(has_key_type_impl::check<T>(nullptr)){};
+ − 120 template<typename T>
+ − 121 struct has_mapped_type : decltype(has_mapped_type_impl::check<T>(nullptr)){};
+ − 122 template<typename T>
+ − 123 struct has_reserve_method : decltype(has_reserve_method_impl::check<T>(nullptr)){};
+ − 124 template<typename T>
+ − 125 struct has_push_back_method : decltype(has_push_back_method_impl::check<T>(nullptr)){};
+ − 126 template<typename T>
+ − 127 struct is_comparable : decltype(is_comparable_impl::check<T>(nullptr)){};
+ − 128
+ − 129 template<typename T, typename C,
+ − 130 template<typename ...> class Tb, template<typename ...> class A>
+ − 131 struct has_from_toml_method
+ − 132 : decltype(has_from_toml_method_impl::check<T, C, Tb, A>(nullptr)){};
+ − 133
+ − 134 template<typename T>
+ − 135 struct has_into_toml_method
+ − 136 : decltype(has_into_toml_method_impl::check<T>(nullptr)){};
+ − 137
+ − 138 template<typename T>
+ − 139 struct has_specialized_from : decltype(has_specialized_from_impl::check<T>(nullptr)){};
+ − 140 template<typename T>
+ − 141 struct has_specialized_into : decltype(has_specialized_into_impl::check<T>(nullptr)){};
+ − 142
+ − 143 #ifdef __INTEL_COMPILER
+ − 144 #undef decltype
+ − 145 #endif
+ − 146
+ − 147 // ---------------------------------------------------------------------------
+ − 148 // C++17 and/or/not
+ − 149
+ − 150 #if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
+ − 151
+ − 152 using std::conjunction;
+ − 153 using std::disjunction;
+ − 154 using std::negation;
+ − 155
+ − 156 #else
+ − 157
+ − 158 template<typename ...> struct conjunction : std::true_type{};
+ − 159 template<typename T> struct conjunction<T> : T{};
+ − 160 template<typename T, typename ... Ts>
+ − 161 struct conjunction<T, Ts...> :
+ − 162 std::conditional<static_cast<bool>(T::value), conjunction<Ts...>, T>::type
+ − 163 {};
+ − 164
+ − 165 template<typename ...> struct disjunction : std::false_type{};
+ − 166 template<typename T> struct disjunction<T> : T {};
+ − 167 template<typename T, typename ... Ts>
+ − 168 struct disjunction<T, Ts...> :
+ − 169 std::conditional<static_cast<bool>(T::value), T, disjunction<Ts...>>::type
+ − 170 {};
+ − 171
+ − 172 template<typename T>
+ − 173 struct negation : std::integral_constant<bool, !static_cast<bool>(T::value)>{};
+ − 174
+ − 175 #endif
+ − 176
+ − 177 // ---------------------------------------------------------------------------
+ − 178 // type checkers
+ − 179
+ − 180 template<typename T> struct is_std_pair : std::false_type{};
+ − 181 template<typename T1, typename T2>
+ − 182 struct is_std_pair<std::pair<T1, T2>> : std::true_type{};
+ − 183
+ − 184 template<typename T> struct is_std_tuple : std::false_type{};
+ − 185 template<typename ... Ts>
+ − 186 struct is_std_tuple<std::tuple<Ts...>> : std::true_type{};
+ − 187
+ − 188 template<typename T> struct is_std_forward_list : std::false_type{};
+ − 189 template<typename T>
+ − 190 struct is_std_forward_list<std::forward_list<T>> : std::true_type{};
+ − 191
+ − 192 template<typename T> struct is_chrono_duration: std::false_type{};
+ − 193 template<typename Rep, typename Period>
+ − 194 struct is_chrono_duration<std::chrono::duration<Rep, Period>>: std::true_type{};
+ − 195
+ − 196 template<typename T>
+ − 197 struct is_map : conjunction< // map satisfies all the following conditions
+ − 198 has_iterator<T>, // has T::iterator
+ − 199 has_value_type<T>, // has T::value_type
+ − 200 has_key_type<T>, // has T::key_type
+ − 201 has_mapped_type<T> // has T::mapped_type
+ − 202 >{};
+ − 203 template<typename T> struct is_map<T&> : is_map<T>{};
+ − 204 template<typename T> struct is_map<T const&> : is_map<T>{};
+ − 205 template<typename T> struct is_map<T volatile&> : is_map<T>{};
+ − 206 template<typename T> struct is_map<T const volatile&> : is_map<T>{};
+ − 207
+ − 208 template<typename T>
+ − 209 struct is_container : conjunction<
+ − 210 negation<is_map<T>>, // not a map
+ − 211 negation<std::is_same<T, std::string>>, // not a std::string
+ − 212 #if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L
+ − 213 #if __has_include(<string_view>)
+ − 214 negation<std::is_same<T, std::string_view>>, // not a std::string_view
+ − 215 #endif // has_include(<string_view>)
+ − 216 #endif
+ − 217 has_iterator<T>, // has T::iterator
+ − 218 has_value_type<T> // has T::value_type
+ − 219 >{};
+ − 220 template<typename T> struct is_container<T&> : is_container<T>{};
+ − 221 template<typename T> struct is_container<T const&> : is_container<T>{};
+ − 222 template<typename T> struct is_container<T volatile&> : is_container<T>{};
+ − 223 template<typename T> struct is_container<T const volatile&> : is_container<T>{};
+ − 224
+ − 225 template<typename T>
+ − 226 struct is_basic_value: std::false_type{};
+ − 227 template<typename T> struct is_basic_value<T&> : is_basic_value<T>{};
+ − 228 template<typename T> struct is_basic_value<T const&> : is_basic_value<T>{};
+ − 229 template<typename T> struct is_basic_value<T volatile&> : is_basic_value<T>{};
+ − 230 template<typename T> struct is_basic_value<T const volatile&> : is_basic_value<T>{};
+ − 231 template<typename C, template<typename ...> class M, template<typename ...> class V>
+ − 232 struct is_basic_value<::toml::basic_value<C, M, V>>: std::true_type{};
+ − 233
+ − 234 // ---------------------------------------------------------------------------
+ − 235 // C++14 index_sequence
+ − 236
+ − 237 #if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201402L
+ − 238
+ − 239 using std::index_sequence;
+ − 240 using std::make_index_sequence;
+ − 241
+ − 242 #else
+ − 243
+ − 244 template<std::size_t ... Ns> struct index_sequence{};
+ − 245
+ − 246 template<typename IS, std::size_t N> struct push_back_index_sequence{};
+ − 247 template<std::size_t N, std::size_t ... Ns>
+ − 248 struct push_back_index_sequence<index_sequence<Ns...>, N>
+ − 249 {
+ − 250 typedef index_sequence<Ns..., N> type;
+ − 251 };
+ − 252
+ − 253 template<std::size_t N>
+ − 254 struct index_sequence_maker
+ − 255 {
+ − 256 typedef typename push_back_index_sequence<
+ − 257 typename index_sequence_maker<N-1>::type, N>::type type;
+ − 258 };
+ − 259 template<>
+ − 260 struct index_sequence_maker<0>
+ − 261 {
+ − 262 typedef index_sequence<0> type;
+ − 263 };
+ − 264 template<std::size_t N>
+ − 265 using make_index_sequence = typename index_sequence_maker<N-1>::type;
+ − 266
+ − 267 #endif // cplusplus >= 2014
+ − 268
+ − 269 // ---------------------------------------------------------------------------
+ − 270 // C++14 enable_if_t
+ − 271
+ − 272 #if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201402L
+ − 273
+ − 274 using std::enable_if_t;
+ − 275
+ − 276 #else
+ − 277
+ − 278 template<bool B, typename T>
+ − 279 using enable_if_t = typename std::enable_if<B, T>::type;
+ − 280
+ − 281 #endif // cplusplus >= 2014
+ − 282
+ − 283 // ---------------------------------------------------------------------------
+ − 284 // return_type_of_t
+ − 285
+ − 286 #if TOML11_CPLUSPLUS_STANDARD_VERSION >= 201703L && defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable>=201703
+ − 287
+ − 288 template<typename F, typename ... Args>
+ − 289 using return_type_of_t = std::invoke_result_t<F, Args...>;
+ − 290
+ − 291 #else
+ − 292 // result_of is deprecated after C++17
+ − 293 template<typename F, typename ... Args>
+ − 294 using return_type_of_t = typename std::result_of<F(Args...)>::type;
+ − 295
+ − 296 #endif
+ − 297
+ − 298 // ---------------------------------------------------------------------------
+ − 299 // is_string_literal
+ − 300 //
+ − 301 // to use this, pass `typename remove_reference<T>::type` to T.
+ − 302
+ − 303 template<typename T>
+ − 304 struct is_string_literal:
+ − 305 disjunction<
+ − 306 std::is_same<const char*, T>,
+ − 307 conjunction<
+ − 308 std::is_array<T>,
+ − 309 std::is_same<const char, typename std::remove_extent<T>::type>
+ − 310 >
+ − 311 >{};
+ − 312
+ − 313 // ---------------------------------------------------------------------------
+ − 314 // C++20 remove_cvref_t
+ − 315
+ − 316 template<typename T>
+ − 317 struct remove_cvref
+ − 318 {
+ − 319 using type = typename std::remove_cv<
+ − 320 typename std::remove_reference<T>::type>::type;
+ − 321 };
+ − 322
+ − 323 template<typename T>
+ − 324 using remove_cvref_t = typename remove_cvref<T>::type;
+ − 325
+ − 326 }// detail
+ − 327 }//toml
+ − 328 #endif // TOML_TRAITS
