sdbus-c++ 2.1.0
High-level C++ D-Bus library based on systemd D-Bus implementation
Loading...
Searching...
No Matches
TypeTraits.h
Go to the documentation of this file.
1
26
27#ifndef SDBUS_CXX_TYPETRAITS_H_
28#define SDBUS_CXX_TYPETRAITS_H_
29
30#include <sdbus-c++/Error.h>
31
32#include <array>
33#include <cstdint>
34#include <functional>
35#include <map>
36#include <memory>
37#include <optional>
38#ifdef __has_include
39# if __has_include(<span>)
40# include <span>
41# endif
42#endif
43#include <string>
44#include <string_view>
45#include <tuple>
46#include <type_traits>
47#include <unordered_map>
48#include <utility>
49#include <variant>
50#include <vector>
51
52// Forward declarations
53namespace sdbus {
54 class Variant;
55 template <typename... _ValueTypes> class Struct;
56 class ObjectPath;
57 class Signature;
58 class UnixFd;
59 template<typename _T1, typename _T2> using DictEntry = std::pair<_T1, _T2>;
60 class BusName;
61 class InterfaceName;
62 class MemberName;
63 class MethodCall;
64 class MethodReply;
65 class Signal;
66 class Message;
67 class PropertySetCall;
68 class PropertyGetReply;
69 template <typename... _Results> class Result;
70 class Error;
71 template <typename _T, typename _Enable = void> struct signature_of;
72}
73
74namespace sdbus {
75
76 // Callbacks from sdbus-c++
77 using method_callback = std::function<void(MethodCall msg)>;
78 using async_reply_handler = std::function<void(MethodReply reply, std::optional<Error> error)>;
79 using signal_handler = std::function<void(Signal signal)>;
80 using message_handler = std::function<void(Message msg)>;
81 using property_set_callback = std::function<void(PropertySetCall msg)>;
82 using property_get_callback = std::function<void(PropertyGetReply& reply)>;
83
84 // Type-erased RAII-style handle to callbacks/subscriptions registered to sdbus-c++
85 using Slot = std::unique_ptr<void, std::function<void(void*)>>;
86
87 // Tag specifying that an owning handle (so-called slot) of the logical resource shall be provided to the client
88 struct return_slot_t { explicit return_slot_t() = default; };
89 inline constexpr return_slot_t return_slot{};
90 // Tag specifying that the library shall own the slot resulting from the call of the function (so-called floating slot)
91 struct floating_slot_t { explicit floating_slot_t() = default; };
92 inline constexpr floating_slot_t floating_slot{};
93 // Tag denoting the assumption that the caller has already obtained message ownership
94 struct adopt_message_t { explicit adopt_message_t() = default; };
95 inline constexpr adopt_message_t adopt_message{};
96 // Tag denoting the assumption that the caller has already obtained fd ownership
97 struct adopt_fd_t { explicit adopt_fd_t() = default; };
98 inline constexpr adopt_fd_t adopt_fd{};
99 // Tag specifying that the proxy shall not run an event loop thread on its D-Bus connection.
100 // Such proxies are typically created to carry out a simple synchronous D-Bus call(s) and then are destroyed.
101 struct dont_run_event_loop_thread_t { explicit dont_run_event_loop_thread_t() = default; };
102 inline constexpr dont_run_event_loop_thread_t dont_run_event_loop_thread{};
103 // Tag denoting an asynchronous call that returns std::future as a handle
104 struct with_future_t { explicit with_future_t() = default; };
105 inline constexpr with_future_t with_future{};
106 // Tag denoting a call where the reply shouldn't be waited for
107 struct dont_expect_reply_t { explicit dont_expect_reply_t() = default; };
108 inline constexpr dont_expect_reply_t dont_expect_reply{};
109 // Tag denoting that the variant shall embed the other variant as its value, instead of creating a copy
110 struct embed_variant_t { explicit embed_variant_t() = default; };
111 inline constexpr embed_variant_t embed_variant{};
112
113 // Helper for static assert
114 template <class... _T> constexpr bool always_false = false;
115
116 // Helper operator+ for concatenation of `std::array`s
117 template <typename _T, std::size_t _N1, std::size_t _N2>
118 constexpr std::array<_T, _N1 + _N2> operator+(std::array<_T, _N1> lhs, std::array<_T, _N2> rhs);
119
120 // Template specializations for getting D-Bus signatures from C++ types
121 template <typename _T>
122 constexpr auto signature_of_v = signature_of<_T>::value;
123
124 template <typename _T, typename _Enable>
126 {
127 static constexpr bool is_valid = false;
128 static constexpr bool is_trivial_dbus_type = false;
129
130 static constexpr void* value = []
131 {
132 // See using-sdbus-c++.md, section "Extending sdbus-c++ type system",
133 // on how to teach sdbus-c++ about your custom types
134 static_assert(always_false<_T>, "Unsupported D-Bus type (specialize `signature_of` for your custom types)");
135 };
136 };
137
138 template <typename _T>
139 struct signature_of<const _T> : signature_of<_T>
140 {};
141
142 template <typename _T>
143 struct signature_of<volatile _T> : signature_of<_T>
144 {};
145
146 template <typename _T>
147 struct signature_of<const volatile _T> : signature_of<_T>
148 {};
149
150 template <typename _T>
152 {};
153
154 template <>
155 struct signature_of<void>
156 {
157 static constexpr std::array<char, 0> value{};
158 static constexpr bool is_valid = true;
159 static constexpr bool is_trivial_dbus_type = false;
160 };
161
162 template <>
163 struct signature_of<bool>
164 {
165 static constexpr std::array value{'b'};
166 static constexpr bool is_valid = true;
167 static constexpr bool is_trivial_dbus_type = true;
168 };
169
170 template <>
171 struct signature_of<uint8_t>
172 {
173 static constexpr std::array value{'y'};
174 static constexpr bool is_valid = true;
175 static constexpr bool is_trivial_dbus_type = true;
176 };
177
178 template <>
179 struct signature_of<int16_t>
180 {
181 static constexpr std::array value{'n'};
182 static constexpr bool is_valid = true;
183 static constexpr bool is_trivial_dbus_type = true;
184 };
185
186 template <>
187 struct signature_of<uint16_t>
188 {
189 static constexpr std::array value{'q'};
190 static constexpr bool is_valid = true;
191 static constexpr bool is_trivial_dbus_type = true;
192 };
193
194 template <>
195 struct signature_of<int32_t>
196 {
197 static constexpr std::array value{'i'};
198 static constexpr bool is_valid = true;
199 static constexpr bool is_trivial_dbus_type = true;
200 };
201
202 template <>
203 struct signature_of<uint32_t>
204 {
205 static constexpr std::array value{'u'};
206 static constexpr bool is_valid = true;
207 static constexpr bool is_trivial_dbus_type = true;
208 };
209
210 template <>
211 struct signature_of<int64_t>
212 {
213 static constexpr std::array value{'x'};
214 static constexpr bool is_valid = true;
215 static constexpr bool is_trivial_dbus_type = true;
216 };
217
218 template <>
219 struct signature_of<uint64_t>
220 {
221 static constexpr std::array value{'t'};
222 static constexpr bool is_valid = true;
223 static constexpr bool is_trivial_dbus_type = true;
224 };
225
226 template <>
227 struct signature_of<double>
228 {
229 static constexpr std::array value{'d'};
230 static constexpr bool is_valid = true;
231 static constexpr bool is_trivial_dbus_type = true;
232 };
233
234 template <>
235 struct signature_of<std::string>
236 {
237 static constexpr std::array value{'s'};
238 static constexpr bool is_valid = true;
239 static constexpr bool is_trivial_dbus_type = false;
240 };
241
242 template <>
243 struct signature_of<std::string_view> : signature_of<std::string>
244 {};
245
246 template <>
249
250 template <>
252 {};
253
254 template <std::size_t _N>
255 struct signature_of<char[_N]> : signature_of<std::string>
256 {};
257
258 template <std::size_t _N>
259 struct signature_of<const char[_N]> : signature_of<std::string>
260 {};
261
262 template <>
263 struct signature_of<BusName> : signature_of<std::string>
264 {};
265
266 template <>
268 {};
269
270 template <>
271 struct signature_of<MemberName> : signature_of<std::string>
272 {};
273
274 template <typename... _ValueTypes>
275 struct signature_of<Struct<_ValueTypes...>>
276 {
277 static constexpr std::array contents = (signature_of_v<_ValueTypes> + ...);
278 static constexpr std::array value = std::array{'('} + contents + std::array{')'};
279 static constexpr char type_value{'r'}; /* Not actually used in signatures on D-Bus, see specs */
280 static constexpr bool is_valid = true;
281 static constexpr bool is_trivial_dbus_type = false;
282 };
283
284 template <>
286 {
287 static constexpr std::array value{'v'};
288 static constexpr bool is_valid = true;
289 static constexpr bool is_trivial_dbus_type = false;
290 };
291
292 template <typename... Elements>
293 struct signature_of<std::variant<Elements...>> : signature_of<Variant>
294 {};
295
296 template <>
298 {
299 static constexpr std::array value{'o'};
300 static constexpr bool is_valid = true;
301 static constexpr bool is_trivial_dbus_type = false;
302 };
303
304 template <>
306 {
307 static constexpr std::array value{'g'};
308 static constexpr bool is_valid = true;
309 static constexpr bool is_trivial_dbus_type = false;
310 };
311
312 template <>
314 {
315 static constexpr std::array value{'h'};
316 static constexpr bool is_valid = true;
317 static constexpr bool is_trivial_dbus_type = false;
318 };
319
320 template <typename _T1, typename _T2>
321 struct signature_of<DictEntry<_T1, _T2>>
322 {
323 static constexpr std::array value = std::array{'{'} + signature_of_v<std::tuple<_T1, _T2>> + std::array{'}'};
324 static constexpr char type_value{'e'}; /* Not actually used in signatures on D-Bus, see specs */
325 static constexpr bool is_valid = true;
326 static constexpr bool is_trivial_dbus_type = false;
327 };
328
329 template <typename _Element, typename _Allocator>
330 struct signature_of<std::vector<_Element, _Allocator>>
331 {
332 static constexpr std::array value = std::array{'a'} + signature_of_v<_Element>;
333 static constexpr bool is_valid = true;
334 static constexpr bool is_trivial_dbus_type = false;
335 };
336
337 template <typename _Element, std::size_t _Size>
338 struct signature_of<std::array<_Element, _Size>> : signature_of<std::vector<_Element>>
339 {
340 };
341
342#ifdef __cpp_lib_span
343 template <typename _Element, std::size_t _Extent>
344 struct signature_of<std::span<_Element, _Extent>> : signature_of<std::vector<_Element>>
345 {
346 };
347#endif
348
349 template <typename _Enum> // is_const_v and is_volatile_v to avoid ambiguity conflicts with const and volatile specializations of signature_of
350 struct signature_of<_Enum, typename std::enable_if_t<std::is_enum_v<_Enum> && !std::is_const_v<_Enum> && !std::is_volatile_v<_Enum>>>
351 : signature_of<std::underlying_type_t<_Enum>>
352 {};
353
354 template <typename _Key, typename _Value, typename _Compare, typename _Allocator>
355 struct signature_of<std::map<_Key, _Value, _Compare, _Allocator>>
356 {
357 static constexpr std::array value = std::array{'a'} + signature_of_v<DictEntry<_Key, _Value>>;
358 static constexpr bool is_valid = true;
359 static constexpr bool is_trivial_dbus_type = false;
360 };
361
362 template <typename _Key, typename _Value, typename _Hash, typename _KeyEqual, typename _Allocator>
363 struct signature_of<std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>>
364 : signature_of<std::map<_Key, _Value>>
365 {
366 };
367
368 template <typename... _Types>
369 struct signature_of<std::tuple<_Types...>> // A simple concatenation of signatures of _Types
370 {
371 static constexpr std::array value = (std::array<char, 0>{} + ... + signature_of_v<_Types>);
372 static constexpr bool is_valid = false;
373 static constexpr bool is_trivial_dbus_type = false;
374 };
375
376 // To simplify conversions of arrays to C strings
377 template <typename _T, std::size_t _N>
378 constexpr auto as_null_terminated(std::array<_T, _N> arr)
379 {
380 return arr + std::array<_T, 1>{0};
381 }
382
383 // Function traits implementation inspired by (c) kennytm,
384 // https://github.com/kennytm/utils/blob/master/traits.hpp
385 template <typename _Type>
386 struct function_traits : function_traits<decltype(&_Type::operator())>
387 {};
388
389 template <typename _Type>
390 struct function_traits<const _Type> : function_traits<_Type>
391 {};
392
393 template <typename _Type>
395 {};
396
397 template <typename _ReturnType, typename... _Args>
399 {
400 typedef _ReturnType result_type;
401 typedef std::tuple<_Args...> arguments_type;
402 typedef std::tuple<std::decay_t<_Args>...> decayed_arguments_type;
403
404 typedef _ReturnType function_type(_Args...);
405
406 static constexpr std::size_t arity = sizeof...(_Args);
407
408// template <size_t _Idx, typename _Enabled = void>
409// struct arg;
410//
411// template <size_t _Idx>
412// struct arg<_Idx, std::enable_if_t<(_Idx < arity)>>
413// {
414// typedef std::tuple_element_t<_Idx, arguments_type> type;
415// };
416//
417// template <size_t _Idx>
418// struct arg<_Idx, std::enable_if_t<!(_Idx < arity)>>
419// {
420// typedef void type;
421// };
422
423 template <size_t _Idx>
424 struct arg
425 {
426 typedef std::tuple_element_t<_Idx, std::tuple<_Args...>> type;
427 };
428
429 template <size_t _Idx>
430 using arg_t = typename arg<_Idx>::type;
431 };
432
433 template <typename _ReturnType, typename... _Args>
434 struct function_traits<_ReturnType(_Args...)> : function_traits_base<_ReturnType, _Args...>
435 {
436 static constexpr bool is_async = false;
437 static constexpr bool has_error_param = false;
438 };
439
440 template <typename... _Args>
441 struct function_traits<void(std::optional<Error>, _Args...)> : function_traits_base<void, _Args...>
442 {
443 static constexpr bool has_error_param = true;
444 };
445
446 template <typename... _Args, typename... _Results>
447 struct function_traits<void(Result<_Results...>, _Args...)> : function_traits_base<std::tuple<_Results...>, _Args...>
448 {
449 static constexpr bool is_async = true;
450 using async_result_t = Result<_Results...>;
451 };
452
453 template <typename... _Args, typename... _Results>
454 struct function_traits<void(Result<_Results...>&&, _Args...)> : function_traits_base<std::tuple<_Results...>, _Args...>
455 {
456 static constexpr bool is_async = true;
457 using async_result_t = Result<_Results...>;
458 };
459
460 template <typename _ReturnType, typename... _Args>
461 struct function_traits<_ReturnType(*)(_Args...)> : function_traits<_ReturnType(_Args...)>
462 {};
463
464 template <typename _ClassType, typename _ReturnType, typename... _Args>
465 struct function_traits<_ReturnType(_ClassType::*)(_Args...)> : function_traits<_ReturnType(_Args...)>
466 {
467 typedef _ClassType& owner_type;
468 };
469
470 template <typename _ClassType, typename _ReturnType, typename... _Args>
471 struct function_traits<_ReturnType(_ClassType::*)(_Args...) const> : function_traits<_ReturnType(_Args...)>
472 {
473 typedef const _ClassType& owner_type;
474 };
475
476 template <typename _ClassType, typename _ReturnType, typename... _Args>
477 struct function_traits<_ReturnType(_ClassType::*)(_Args...) volatile> : function_traits<_ReturnType(_Args...)>
478 {
479 typedef volatile _ClassType& owner_type;
480 };
481
482 template <typename _ClassType, typename _ReturnType, typename... _Args>
483 struct function_traits<_ReturnType(_ClassType::*)(_Args...) const volatile> : function_traits<_ReturnType(_Args...)>
484 {
485 typedef const volatile _ClassType& owner_type;
486 };
487
488 template <typename FunctionType>
489 struct function_traits<std::function<FunctionType>> : function_traits<FunctionType>
490 {};
491
492 template <class _Function>
493 constexpr auto is_async_method_v = function_traits<_Function>::is_async;
494
495 template <class _Function>
496 constexpr auto has_error_param_v = function_traits<_Function>::has_error_param;
497
498 template <typename _FunctionType>
499 using function_arguments_t = typename function_traits<_FunctionType>::arguments_type;
500
501 template <typename _FunctionType, size_t _Idx>
502 using function_argument_t = typename function_traits<_FunctionType>::template arg_t<_Idx>;
503
504 template <typename _FunctionType>
505 constexpr auto function_argument_count_v = function_traits<_FunctionType>::arity;
506
507 template <typename _FunctionType>
508 using function_result_t = typename function_traits<_FunctionType>::result_type;
509
510 template <typename _Function>
515
516 template <typename _Function>
517 using tuple_of_function_input_arg_types_t = typename tuple_of_function_input_arg_types<_Function>::type;
518
519 template <typename _Function>
524
525 template <typename _Function>
526 using tuple_of_function_output_arg_types_t = typename tuple_of_function_output_arg_types<_Function>::type;
527
528 template <typename _Function>
529 struct signature_of_function_input_arguments : signature_of<tuple_of_function_input_arg_types_t<_Function>>
530 {
531 static std::string value_as_string()
532 {
533 constexpr auto signature = as_null_terminated(signature_of_v<tuple_of_function_input_arg_types_t<_Function>>);
534 return signature.data();
535 }
536 };
537
538 template <typename _Function>
539 inline auto signature_of_function_input_arguments_v = signature_of_function_input_arguments<_Function>::value_as_string();
540
541 template <typename _Function>
542 struct signature_of_function_output_arguments : signature_of<tuple_of_function_output_arg_types_t<_Function>>
543 {
544 static std::string value_as_string()
545 {
546 constexpr auto signature = as_null_terminated(signature_of_v<tuple_of_function_output_arg_types_t<_Function>>);
547 return signature.data();
548 }
549 };
550
551 template <typename _Function>
552 inline auto signature_of_function_output_arguments_v = signature_of_function_output_arguments<_Function>::value_as_string();
553
554 // std::future stuff for return values of async calls
555 template <typename... _Args> struct future_return
556 {
557 typedef std::tuple<_Args...> type;
558 };
559
560 template <> struct future_return<>
561 {
562 typedef void type;
563 };
564
565 template <typename _Type> struct future_return<_Type>
566 {
567 typedef _Type type;
568 };
569
570 template <typename... _Args>
571 using future_return_t = typename future_return<_Args...>::type;
572
573 // Credit: Piotr Skotnicki (https://stackoverflow.com/a/57639506)
574 template <typename, typename>
575 constexpr bool is_one_of_variants_types = false;
576
577 template <typename... _VariantTypes, typename _QueriedType>
578 constexpr bool is_one_of_variants_types<std::variant<_VariantTypes...>, _QueriedType>
579 = (std::is_same_v<_QueriedType, _VariantTypes> || ...);
580
581 // Wrapper (tag) denoting we want to serialize user-defined struct
582 // into a D-Bus message as a dictionary of strings to variants.
583 template <typename _Struct>
584 struct as_dictionary
585 {
586 explicit as_dictionary(const _Struct& s) : m_struct(s) {}
587 const _Struct& m_struct;
588 };
589
590 template <typename _Type>
591 const _Type& as_dictionary_if_struct(const _Type& object)
592 {
593 return object; // identity in case _Type is not struct (user-defined structs shall provide an overload)
594 }
595
596 // By default, the dict-as-struct deserialization strategy is strict.
597 // Strict means that every key of the deserialized dictionary must have its counterpart member in the struct, otherwise an exception is thrown.
598 // Relaxed means that a key that does not have a matching struct member is silently ignored.
599 // The behavior can be overridden for user-defined struct by specializing this variable template.
600 template <typename _Struct>
601 constexpr auto strict_dict_as_struct_deserialization_v = true;
602
603 // By default, the struct-as-dict serialization strategy is single-level only (as opposed to nested).
604 // Single-level means that only the specific struct is serialized as a dictionary, serializing members that are structs always as structs.
605 // Nested means that the struct *and* its members that are structs are all serialized as a dictionary. If nested strategy is also
606 // defined for the nested struct, then the same behavior applies for that struct, recursively.
607 // The behavior can be overridden for user-defined struct by specializing this variable template.
608 template <typename _Struct>
609 constexpr auto nested_struct_as_dict_serialization_v = false;
610
611 namespace detail
612 {
613 template <class _Function, class _Tuple, typename... _Args, std::size_t... _I>
614 constexpr decltype(auto) apply_impl( _Function&& f
615 , Result<_Args...>&& r
616 , _Tuple&& t
617 , std::index_sequence<_I...> )
618 {
619 return std::forward<_Function>(f)(std::move(r), std::get<_I>(std::forward<_Tuple>(t))...);
620 }
621
622 template <class _Function, class _Tuple, std::size_t... _I>
623 decltype(auto) apply_impl( _Function&& f
624 , std::optional<Error> e
625 , _Tuple&& t
626 , std::index_sequence<_I...> )
627 {
628 return std::forward<_Function>(f)(std::move(e), std::get<_I>(std::forward<_Tuple>(t))...);
629 }
630
631 // For non-void returning functions, apply_impl simply returns function return value (a tuple of values).
632 // For void-returning functions, apply_impl returns an empty tuple.
633 template <class _Function, class _Tuple, std::size_t... _I>
634 constexpr decltype(auto) apply_impl( _Function&& f
635 , _Tuple&& t
636 , std::index_sequence<_I...> )
637 {
638 if constexpr (!std::is_void_v<function_result_t<_Function>>)
639 return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...);
640 else
641 return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...), std::tuple<>{};
642 }
643 }
644
645 // Convert tuple `t' of values into a list of arguments
646 // and invoke function `f' with those arguments.
647 template <class _Function, class _Tuple>
648 constexpr decltype(auto) apply(_Function&& f, _Tuple&& t)
649 {
650 return detail::apply_impl( std::forward<_Function>(f)
651 , std::forward<_Tuple>(t)
652 , std::make_index_sequence<std::tuple_size<std::decay_t<_Tuple>>::value>{} );
653 }
654
655 // Convert tuple `t' of values into a list of arguments
656 // and invoke function `f' with those arguments.
657 template <class _Function, class _Tuple, typename... _Args>
658 constexpr decltype(auto) apply(_Function&& f, Result<_Args...>&& r, _Tuple&& t)
659 {
660 return detail::apply_impl( std::forward<_Function>(f)
661 , std::move(r)
662 , std::forward<_Tuple>(t)
663 , std::make_index_sequence<std::tuple_size<std::decay_t<_Tuple>>::value>{} );
664 }
665
666 // Convert tuple `t' of values into a list of arguments
667 // and invoke function `f' with those arguments.
668 template <class _Function, class _Tuple>
669 decltype(auto) apply(_Function&& f, std::optional<Error> e, _Tuple&& t)
670 {
671 return detail::apply_impl( std::forward<_Function>(f)
672 , std::move(e)
673 , std::forward<_Tuple>(t)
674 , std::make_index_sequence<std::tuple_size<std::decay_t<_Tuple>>::value>{} );
675 }
676
677 // Convenient concatenation of arrays
678 template <typename _T, std::size_t _N1, std::size_t _N2>
679 constexpr std::array<_T, _N1 + _N2> operator+(std::array<_T, _N1> lhs, std::array<_T, _N2> rhs)
680 {
681 std::array<_T, _N1 + _N2> result{};
682 std::size_t index = 0;
683
684 for (auto& el : lhs) {
685 result[index] = std::move(el);
686 ++index;
687 }
688 for (auto& el : rhs) {
689 result[index] = std::move(el);
690 ++index;
691 }
692
693 return result;
694 }
695
696}
697
698#endif /* SDBUS_CXX_TYPETRAITS_H_ */
std::pair< _T1, _T2 > DictEntry
Definition Types.h:402
Definition Types.h:215
Definition Error.h:44
Definition Types.h:238
Definition Types.h:258
Definition Message.h:81
Definition Message.h:267
Definition Message.h:292
Definition Types.h:195
Definition Message.h:323
Definition Message.h:314
Definition MethodResult.h:51
Definition Message.h:302
Definition Types.h:282
Definition Types.h:153
Definition Types.h:307
Definition Types.h:57
Definition TypeTraits.h:97
Definition TypeTraits.h:94
Definition TypeTraits.h:107
Definition TypeTraits.h:101
Definition TypeTraits.h:110
Definition TypeTraits.h:91
Definition TypeTraits.h:425
Definition TypeTraits.h:399
Definition TypeTraits.h:387
Definition TypeTraits.h:556
Definition TypeTraits.h:88
Definition TypeTraits.h:126
Definition TypeTraits.h:512
Definition TypeTraits.h:104