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
|
#pragma clang system_header
namespace std {
template<class T, T v>
struct integral_constant {
static constexpr T value = v;
typedef T value_type;
typedef integral_constant type;
constexpr operator value_type() const noexcept { return value; }
};
template <bool B>
using bool_constant = integral_constant<bool, B>;
using true_type = bool_constant<true>;
using false_type = bool_constant<false>;
template<class T>
struct is_error_code_enum : false_type {};
template <class T>
void swap(T &a, T &b);
enum class io_errc {
stream = 1,
};
template <class... Types>
class tuple;
template <typename T = void>
class less;
template <>
class less<void> {
public:
template <typename T, typename U>
bool operator()(T &&Lhs, U &&Rhs) const {
return static_cast<T &&>(Lhs) < static_cast<U &&>(Rhs);
}
template <typename A, typename B = int>
struct X {};
};
template <class Key>
struct hash;
template <class T>
class numeric_limits;
struct Outer {
struct Inner {};
};
namespace detail {
struct X {};
} // namespace detail
} // namespace std
// Template specializations that are in a system-header file.
// The purpose is to test cert-dcl58-cpp (no warnings here).
namespace std {
template <>
void swap<short>(short &, short &){};
template <>
struct is_error_code_enum<short> : true_type {};
template <>
bool less<void>::operator()<short &&, short &&>(short &&, short &&) const {
return false;
}
template <>
struct less<void>::X<short> {};
} // namespace std
|
