libzypp 17.35.13
type_traits.h
Go to the documentation of this file.
1#ifndef ZYPPNG_META_TYPE_TRAITS_INCLUDED
2#define ZYPPNG_META_TYPE_TRAITS_INCLUDED
3
4#include <type_traits>
5#include <memory>
6
7#if !defined ( __cpp_lib_void_t )
8
9namespace std {
10 //define void_t since it is only available starting with C++17 in some compilers
11 template<typename... Ts> struct make_void { typedef void type;};
12 template<typename... Ts> using void_t = typename make_void<Ts...>::type;
13}
14
15#endif
16
17namespace std {
18
19#if __cplusplus < 202002L
20
21//implementation of the detector idiom, used to help with SFINAE
22//from https://en.cppreference.com/w/cpp/experimental/is_detected
23
24namespace detail {
25template <class Default, class AlwaysVoid,
26 template<class...> class Op, class... Args>
27struct detector {
28 using value_t = std::false_type;
29 using type = Default;
30};
31
32template <class Default, template<class...> class Op, class... Args>
33struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
34 using value_t = std::true_type;
35 using type = Op<Args...>;
36};
37
38struct nonesuch{
39 ~nonesuch( ) = delete;
40 nonesuch( nonesuch const& ) = delete;
41 void operator = ( nonesuch const& ) = delete;
42};
43
44} // namespace detail
45
46template <bool B> using bool_constant = integral_constant<bool, B>;
47
48template <template<class...> class Op, class... Args>
49using is_detected = typename detail::detector<detail::nonesuch, void, Op, Args...>::value_t;
50
51template <template<class...> class Op, class... Args>
52using detected_t = typename detail::detector<detail::nonesuch, void, Op, Args...>::type;
53
54template <class Default, template<class...> class Op, class... Args>
55using detected_or = detail::detector<Default, void, Op, Args...>;
56
57template< template<class...> class Op, class... Args >
58constexpr bool is_detected_v = is_detected<Op, Args...>::value;
59
60template< class Default, template<class...> class Op, class... Args >
61using detected_or_t = typename detected_or<Default, Op, Args...>::type;
62
63template <class Expected, template<class...> class Op, class... Args>
64using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
65
66template <class Expected, template<class...> class Op, class... Args>
67constexpr bool is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value;
68
69template <class To, template<class...> class Op, class... Args>
70using is_detected_convertible = std::is_convertible<detected_t<Op, Args...>, To>;
71
72template <class To, template<class...> class Op, class... Args>
73constexpr bool is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value_t::value;
74
75template< class T >
77 using type = std::remove_cv_t<std::remove_reference_t<T>>;
78};
79
80template< class T >
82
83#endif
84
85#if __cplusplus < 201703L
86
87//https://en.cppreference.com/w/cpp/types/conjunction)
88template<class...> struct conjunction : std::true_type { };
89template<class B1> struct conjunction<B1> : B1 { };
90template<class B1, class... Bn>
91struct conjunction<B1, Bn...>
92 : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
93
94//https://en.cppreference.com/w/cpp/types/disjunction
95template<class...> struct disjunction : std::false_type { };
96template<class B1> struct disjunction<B1> : B1 { };
97template<class B1, class... Bn>
98struct disjunction<B1, Bn...>
99 : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> { };
100
101//https://en.cppreference.com/w/cpp/types/negation
102template<class B>
103struct negation : std::bool_constant< !bool(B::value)> { };
104
105#endif
106}
107
108
109namespace zyppng {
110 //check wether something is a instance of a template type
111 template < template< class ... > class Templ, class Type >
112 struct is_instance_of : std::false_type{};
113
114 template < template< typename ... > class Templ, typename... Args >
115 struct is_instance_of<Templ, Templ<Args...>> : std::true_type{};
116
117 //Provides the member typedef type which is the type pointed to by T, or, if T is not a pointer, then type is the same as T.
118 template< typename T>
119 struct remove_smart_ptr{ using type = std::remove_cv_t<T>; };
120
121 template< typename T>
122 struct remove_smart_ptr<std::shared_ptr<T>>{ using type = std::remove_cv_t<T>; };
123
124 template< typename T>
125 struct remove_smart_ptr<std::unique_ptr<T>>{ using type = std::remove_cv_t<T>; };
126
127 template< typename T>
129
130 //helper template to print type parameters
131 template <typename ...T>
133}
134
135#endif
Definition Arch.h:364
typename detail::detector< detail::nonesuch, void, Op, Args... >::value_t is_detected
Definition type_traits.h:49
std::is_same< Expected, detected_t< Op, Args... > > is_detected_exact
Definition type_traits.h:64
typename detail::detector< detail::nonesuch, void, Op, Args... >::type detected_t
Definition type_traits.h:52
constexpr bool is_detected_exact_v
Definition type_traits.h:67
std::is_convertible< detected_t< Op, Args... >, To > is_detected_convertible
Definition type_traits.h:70
constexpr bool is_detected_convertible_v
Definition type_traits.h:73
integral_constant< bool, B > bool_constant
Definition type_traits.h:46
typename make_void< Ts... >::type void_t
Definition type_traits.h:12
typename conditional< B, T, F >::type conditional_t
Definition TypeTraits.h:39
constexpr bool is_detected_v
Definition type_traits.h:58
typename remove_cvref< T >::type remove_cvref_t
Definition type_traits.h:81
typename detected_or< Default, Op, Args... >::type detected_or_t
Definition type_traits.h:61
typename remove_smart_ptr< T >::type remove_smart_ptr_t
std::false_type value_t
Definition type_traits.h:28
nonesuch(nonesuch const &)=delete
void operator=(nonesuch const &)=delete
std::remove_cv_t< std::remove_reference_t< T > > type
Definition type_traits.h:77
std::remove_cv_t< T > type