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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H
#define _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H
#include <__compare/ordering.h>
#include <__config>
#include <__functional/hash.h>
#include <__functional/unary_function.h>
#include <__system_error/errc.h>
#include <__system_error/error_category.h>
#include <__system_error/error_condition.h>
#include <cstddef>
#include <string>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum : public false_type {};
#if _LIBCPP_STD_VER >= 17
template <class _Tp>
inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
#endif
namespace __adl_only {
// Those cause ADL to trigger but they are not viable candidates,
// so they are never actually selected.
void make_error_code() = delete;
} // namespace __adl_only
class _LIBCPP_EXPORTED_FROM_ABI error_code {
int __val_;
const error_category* __cat_;
public:
_LIBCPP_HIDE_FROM_ABI error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
_LIBCPP_HIDE_FROM_ABI error_code(int __val, const error_category& __cat) _NOEXCEPT : __val_(__val), __cat_(&__cat) {}
template <class _Ep, __enable_if_t<is_error_code_enum<_Ep>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI error_code(_Ep __e) _NOEXCEPT {
using __adl_only::make_error_code;
*this = make_error_code(__e);
}
_LIBCPP_HIDE_FROM_ABI void assign(int __val, const error_category& __cat) _NOEXCEPT {
__val_ = __val;
__cat_ = &__cat;
}
template <class _Ep, __enable_if_t<is_error_code_enum<_Ep>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI error_code& operator=(_Ep __e) _NOEXCEPT {
using __adl_only::make_error_code;
*this = make_error_code(__e);
return *this;
}
_LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT {
__val_ = 0;
__cat_ = &system_category();
}
_LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }
_LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }
_LIBCPP_HIDE_FROM_ABI error_condition default_error_condition() const _NOEXCEPT {
return __cat_->default_error_condition(__val_);
}
string message() const;
_LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
};
inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(errc __e) _NOEXCEPT {
return error_code(static_cast<int>(__e), generic_category());
}
inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_code& __x, const error_code& __y) _NOEXCEPT {
return __x.category() == __y.category() && __x.value() == __y.value();
}
inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT {
return __x.category().equivalent(__x.value(), __y) || __y.category().equivalent(__x, __y.value());
}
#if _LIBCPP_STD_VER <= 17
inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT {
return __y == __x;
}
#endif
#if _LIBCPP_STD_VER <= 17
inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT {
return !(__x == __y);
}
inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT {
return !(__x == __y);
}
inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT {
return !(__x == __y);
}
inline _LIBCPP_HIDE_FROM_ABI bool operator<(const error_code& __x, const error_code& __y) _NOEXCEPT {
return __x.category() < __y.category() || (__x.category() == __y.category() && __x.value() < __y.value());
}
#else // _LIBCPP_STD_VER <= 17
inline _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const error_code& __x, const error_code& __y) noexcept {
if (auto __c = __x.category() <=> __y.category(); __c != 0)
return __c;
return __x.value() <=> __y.value();
}
#endif // _LIBCPP_STD_VER <= 17
template <>
struct _LIBCPP_TEMPLATE_VIS hash<error_code> : public __unary_function<error_code, size_t> {
_LIBCPP_HIDE_FROM_ABI size_t operator()(const error_code& __ec) const _NOEXCEPT {
return static_cast<size_t>(__ec.value());
}
};
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H
|
