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
|
// -*-c++-*-
// vim: set ft=cpp:
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file LICENSE.rst or https://cmake.org/licensing for details. */
#pragma once
#include <memory>
#include <cm/type_traits>
namespace cm {
#if defined(__SUNPRO_CC)
// Oracle DeveloperStudio C++ compiler do not support overloaded templates with
// same signature but different constraints over template arguments
// (i.e. meta-programming).
// As a work-around, use a structure to avoid templates with same signature.
namespace detail {
template <int N>
struct overload_selector : overload_selector<N - 1>
{
};
template <>
struct overload_selector<0>
{
};
}
#endif
// type traits for managed pointer types
template <typename>
struct is_unique_ptr : std::false_type
{
};
template <typename T>
struct is_unique_ptr<std::unique_ptr<T>> : std::true_type
{
};
// type traits for containers
template <typename, typename = void_t<>>
struct is_container : std::false_type
{
};
template <typename T>
struct is_container<
T,
cm::void_t<typename T::value_type, typename T::size_type,
typename T::difference_type, typename T::iterator>>
: std::true_type
{
};
template <typename, typename = void_t<>>
struct is_associative_container : std::false_type
{
};
template <typename T>
struct is_associative_container<
T, cm::void_t<typename T::key_type, typename T::key_compare>>
: cm::is_container<T>
{
};
template <typename, typename = void_t<>>
struct is_unordered_associative_container : std::false_type
{
};
template <typename T>
struct is_unordered_associative_container<
T,
cm::void_t<typename T::key_type, typename T::hasher, typename T::key_equal,
typename T::local_iterator>> : cm::is_container<T>
{
};
template <typename T>
using is_sequence_container =
cm::bool_constant<cm::is_container<T>::value &&
!cm::is_associative_container<T>::value &&
!cm::is_unordered_associative_container<T>::value>;
template <typename T>
struct remove_member_pointer
{
typedef T type;
};
template <typename T, typename U>
struct remove_member_pointer<T U::*>
{
typedef T type;
};
template <typename T>
using remove_member_pointer_t = typename remove_member_pointer<T>::type;
template <typename T>
struct member_pointer_class
{
typedef T type;
};
template <typename T, typename U>
struct member_pointer_class<U T::*>
{
typedef T type;
};
template <typename T>
using member_pointer_class_t = typename member_pointer_class<T>::type;
} // namespace cm
|
