/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/include/system_error
Line | Count | Source (jump to first uncovered line) |
1 | | // -*- C++ -*- |
2 | | //===---------------------------- system_error ----------------------------===// |
3 | | // |
4 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | | // See https://llvm.org/LICENSE.txt for license information. |
6 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | |
10 | | #ifndef _LIBCPP_SYSTEM_ERROR |
11 | | #define _LIBCPP_SYSTEM_ERROR |
12 | | |
13 | | /* |
14 | | system_error synopsis |
15 | | |
16 | | namespace std |
17 | | { |
18 | | |
19 | | class error_category |
20 | | { |
21 | | public: |
22 | | virtual ~error_category() noexcept; |
23 | | |
24 | | constexpr error_category(); |
25 | | error_category(const error_category&) = delete; |
26 | | error_category& operator=(const error_category&) = delete; |
27 | | |
28 | | virtual const char* name() const noexcept = 0; |
29 | | virtual error_condition default_error_condition(int ev) const noexcept; |
30 | | virtual bool equivalent(int code, const error_condition& condition) const noexcept; |
31 | | virtual bool equivalent(const error_code& code, int condition) const noexcept; |
32 | | virtual string message(int ev) const = 0; |
33 | | |
34 | | bool operator==(const error_category& rhs) const noexcept; |
35 | | bool operator!=(const error_category& rhs) const noexcept; |
36 | | bool operator<(const error_category& rhs) const noexcept; |
37 | | }; |
38 | | |
39 | | const error_category& generic_category() noexcept; |
40 | | const error_category& system_category() noexcept; |
41 | | |
42 | | template <class T> struct is_error_code_enum |
43 | | : public false_type {}; |
44 | | |
45 | | template <class T> struct is_error_condition_enum |
46 | | : public false_type {}; |
47 | | |
48 | | template <class _Tp> |
49 | | inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17 |
50 | | |
51 | | template <class _Tp> |
52 | | inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17 |
53 | | |
54 | | class error_code |
55 | | { |
56 | | public: |
57 | | // constructors: |
58 | | error_code() noexcept; |
59 | | error_code(int val, const error_category& cat) noexcept; |
60 | | template <class ErrorCodeEnum> |
61 | | error_code(ErrorCodeEnum e) noexcept; |
62 | | |
63 | | // modifiers: |
64 | | void assign(int val, const error_category& cat) noexcept; |
65 | | template <class ErrorCodeEnum> |
66 | | error_code& operator=(ErrorCodeEnum e) noexcept; |
67 | | void clear() noexcept; |
68 | | |
69 | | // observers: |
70 | | int value() const noexcept; |
71 | | const error_category& category() const noexcept; |
72 | | error_condition default_error_condition() const noexcept; |
73 | | string message() const; |
74 | | explicit operator bool() const noexcept; |
75 | | }; |
76 | | |
77 | | // non-member functions: |
78 | | bool operator<(const error_code& lhs, const error_code& rhs) noexcept; |
79 | | template <class charT, class traits> |
80 | | basic_ostream<charT,traits>& |
81 | | operator<<(basic_ostream<charT,traits>& os, const error_code& ec); |
82 | | |
83 | | class error_condition |
84 | | { |
85 | | public: |
86 | | // constructors: |
87 | | error_condition() noexcept; |
88 | | error_condition(int val, const error_category& cat) noexcept; |
89 | | template <class ErrorConditionEnum> |
90 | | error_condition(ErrorConditionEnum e) noexcept; |
91 | | |
92 | | // modifiers: |
93 | | void assign(int val, const error_category& cat) noexcept; |
94 | | template <class ErrorConditionEnum> |
95 | | error_condition& operator=(ErrorConditionEnum e) noexcept; |
96 | | void clear() noexcept; |
97 | | |
98 | | // observers: |
99 | | int value() const noexcept; |
100 | | const error_category& category() const noexcept; |
101 | | string message() const noexcept; |
102 | | explicit operator bool() const noexcept; |
103 | | }; |
104 | | |
105 | | bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; |
106 | | |
107 | | class system_error |
108 | | : public runtime_error |
109 | | { |
110 | | public: |
111 | | system_error(error_code ec, const string& what_arg); |
112 | | system_error(error_code ec, const char* what_arg); |
113 | | system_error(error_code ec); |
114 | | system_error(int ev, const error_category& ecat, const string& what_arg); |
115 | | system_error(int ev, const error_category& ecat, const char* what_arg); |
116 | | system_error(int ev, const error_category& ecat); |
117 | | |
118 | | const error_code& code() const noexcept; |
119 | | const char* what() const noexcept; |
120 | | }; |
121 | | |
122 | | template <> struct is_error_condition_enum<errc> |
123 | | : true_type { } |
124 | | |
125 | | error_code make_error_code(errc e) noexcept; |
126 | | error_condition make_error_condition(errc e) noexcept; |
127 | | |
128 | | // Comparison operators: |
129 | | bool operator==(const error_code& lhs, const error_code& rhs) noexcept; |
130 | | bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; |
131 | | bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; |
132 | | bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; |
133 | | bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; |
134 | | bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; |
135 | | bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; |
136 | | bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; |
137 | | |
138 | | template <> struct hash<std::error_code>; |
139 | | template <> struct hash<std::error_condition>; |
140 | | |
141 | | } // std |
142 | | |
143 | | */ |
144 | | |
145 | | #include <__errc> |
146 | | #include <type_traits> |
147 | | #include <stdexcept> |
148 | | #include <__functional_base> |
149 | | #include <string> |
150 | | |
151 | | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
152 | | #pragma GCC system_header |
153 | | #endif |
154 | | |
155 | | _LIBCPP_BEGIN_NAMESPACE_STD |
156 | | |
157 | | // is_error_code_enum |
158 | | |
159 | | template <class _Tp> |
160 | | struct _LIBCPP_TEMPLATE_VIS is_error_code_enum |
161 | | : public false_type {}; |
162 | | |
163 | | #if _LIBCPP_STD_VER > 14 |
164 | | template <class _Tp> |
165 | | _LIBCPP_INLINE_VAR constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; |
166 | | #endif |
167 | | |
168 | | // is_error_condition_enum |
169 | | |
170 | | template <class _Tp> |
171 | | struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum |
172 | | : public false_type {}; |
173 | | |
174 | | #if _LIBCPP_STD_VER > 14 |
175 | | template <class _Tp> |
176 | | _LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; |
177 | | #endif |
178 | | |
179 | | template <> |
180 | | struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> |
181 | | : true_type { }; |
182 | | |
183 | | #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS |
184 | | template <> |
185 | | struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx> |
186 | | : true_type { }; |
187 | | #endif |
188 | | |
189 | | class _LIBCPP_TYPE_VIS error_condition; |
190 | | class _LIBCPP_TYPE_VIS error_code; |
191 | | |
192 | | // class error_category |
193 | | |
194 | | class _LIBCPP_HIDDEN __do_message; |
195 | | |
196 | | class _LIBCPP_TYPE_VIS error_category |
197 | | { |
198 | | public: |
199 | | virtual ~error_category() _NOEXCEPT; |
200 | | |
201 | | #if defined(_LIBCPP_BUILDING_LIBRARY) && \ |
202 | | defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) |
203 | | error_category() _NOEXCEPT; |
204 | | #else |
205 | | _LIBCPP_INLINE_VISIBILITY |
206 | | _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT |
207 | | #endif |
208 | | private: |
209 | | error_category(const error_category&);// = delete; |
210 | | error_category& operator=(const error_category&);// = delete; |
211 | | |
212 | | public: |
213 | | virtual const char* name() const _NOEXCEPT = 0; |
214 | | virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; |
215 | | virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; |
216 | | virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; |
217 | | virtual string message(int __ev) const = 0; |
218 | | |
219 | | _LIBCPP_INLINE_VISIBILITY |
220 | 13.4M | bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} |
221 | | |
222 | | _LIBCPP_INLINE_VISIBILITY |
223 | 0 | bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} |
224 | | |
225 | | _LIBCPP_INLINE_VISIBILITY |
226 | 0 | bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} |
227 | | |
228 | | friend class _LIBCPP_HIDDEN __do_message; |
229 | | }; |
230 | | |
231 | | class _LIBCPP_HIDDEN __do_message |
232 | | : public error_category |
233 | | { |
234 | | public: |
235 | | virtual string message(int ev) const; |
236 | | }; |
237 | | |
238 | | _LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT; |
239 | | _LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT; |
240 | | |
241 | | class _LIBCPP_TYPE_VIS error_condition |
242 | | { |
243 | | int __val_; |
244 | | const error_category* __cat_; |
245 | | public: |
246 | | _LIBCPP_INLINE_VISIBILITY |
247 | 0 | error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {} |
248 | | |
249 | | _LIBCPP_INLINE_VISIBILITY |
250 | | error_condition(int __val, const error_category& __cat) _NOEXCEPT |
251 | 603 | : __val_(__val), __cat_(&__cat) {} |
252 | | |
253 | | template <class _Ep> |
254 | | _LIBCPP_INLINE_VISIBILITY |
255 | | error_condition(_Ep __e, |
256 | | typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0 |
257 | | ) _NOEXCEPT |
258 | 599 | {*this = make_error_condition(__e);} |
259 | | |
260 | | _LIBCPP_INLINE_VISIBILITY |
261 | | void assign(int __val, const error_category& __cat) _NOEXCEPT |
262 | 0 | { |
263 | 0 | __val_ = __val; |
264 | 0 | __cat_ = &__cat; |
265 | 0 | } |
266 | | |
267 | | template <class _Ep> |
268 | | _LIBCPP_INLINE_VISIBILITY |
269 | | typename enable_if |
270 | | < |
271 | | is_error_condition_enum<_Ep>::value, |
272 | | error_condition& |
273 | | >::type |
274 | | operator=(_Ep __e) _NOEXCEPT |
275 | | {*this = make_error_condition(__e); return *this;} |
276 | | |
277 | | _LIBCPP_INLINE_VISIBILITY |
278 | | void clear() _NOEXCEPT |
279 | 0 | { |
280 | 0 | __val_ = 0; |
281 | 0 | __cat_ = &generic_category(); |
282 | 0 | } |
283 | | |
284 | | _LIBCPP_INLINE_VISIBILITY |
285 | 17 | int value() const _NOEXCEPT {return __val_;} |
286 | | |
287 | | _LIBCPP_INLINE_VISIBILITY |
288 | 17 | const error_category& category() const _NOEXCEPT {return *__cat_;} |
289 | | string message() const; |
290 | | |
291 | | _LIBCPP_INLINE_VISIBILITY |
292 | | _LIBCPP_EXPLICIT |
293 | 0 | operator bool() const _NOEXCEPT {return __val_ != 0;} |
294 | | }; |
295 | | |
296 | | inline _LIBCPP_INLINE_VISIBILITY |
297 | | error_condition |
298 | | make_error_condition(errc __e) _NOEXCEPT |
299 | 599 | { |
300 | 599 | return error_condition(static_cast<int>(__e), generic_category()); |
301 | 599 | } |
302 | | |
303 | | inline _LIBCPP_INLINE_VISIBILITY |
304 | | bool |
305 | | operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT |
306 | 0 | { |
307 | 0 | return __x.category() < __y.category() |
308 | 0 | || (__x.category() == __y.category() && __x.value() < __y.value()); |
309 | 0 | } |
310 | | |
311 | | // error_code |
312 | | |
313 | | class _LIBCPP_TYPE_VIS error_code |
314 | | { |
315 | | int __val_; |
316 | | const error_category* __cat_; |
317 | | public: |
318 | | _LIBCPP_INLINE_VISIBILITY |
319 | 30.7M | error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {} |
320 | | |
321 | | _LIBCPP_INLINE_VISIBILITY |
322 | | error_code(int __val, const error_category& __cat) _NOEXCEPT |
323 | 50.3M | : __val_(__val), __cat_(&__cat) {} |
324 | | |
325 | | template <class _Ep> |
326 | | _LIBCPP_INLINE_VISIBILITY |
327 | | error_code(_Ep __e, |
328 | | typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0 |
329 | | ) _NOEXCEPT |
330 | 0 | {*this = make_error_code(__e);} |
331 | | |
332 | | _LIBCPP_INLINE_VISIBILITY |
333 | | void assign(int __val, const error_category& __cat) _NOEXCEPT |
334 | 0 | { |
335 | 0 | __val_ = __val; |
336 | 0 | __cat_ = &__cat; |
337 | 0 | } |
338 | | |
339 | | template <class _Ep> |
340 | | _LIBCPP_INLINE_VISIBILITY |
341 | | typename enable_if |
342 | | < |
343 | | is_error_code_enum<_Ep>::value, |
344 | | error_code& |
345 | | >::type |
346 | | operator=(_Ep __e) _NOEXCEPT |
347 | | {*this = make_error_code(__e); return *this;} |
348 | | |
349 | | _LIBCPP_INLINE_VISIBILITY |
350 | | void clear() _NOEXCEPT |
351 | 0 | { |
352 | 0 | __val_ = 0; |
353 | 0 | __cat_ = &system_category(); |
354 | 0 | } |
355 | | |
356 | | _LIBCPP_INLINE_VISIBILITY |
357 | 11.8M | int value() const _NOEXCEPT {return __val_;} |
358 | | |
359 | | _LIBCPP_INLINE_VISIBILITY |
360 | 26.9M | const error_category& category() const _NOEXCEPT {return *__cat_;} |
361 | | |
362 | | _LIBCPP_INLINE_VISIBILITY |
363 | | error_condition default_error_condition() const _NOEXCEPT |
364 | 0 | {return __cat_->default_error_condition(__val_);} |
365 | | |
366 | | string message() const; |
367 | | |
368 | | _LIBCPP_INLINE_VISIBILITY |
369 | | _LIBCPP_EXPLICIT |
370 | 35.2M | operator bool() const _NOEXCEPT {return __val_ != 0;} |
371 | | }; |
372 | | |
373 | | inline _LIBCPP_INLINE_VISIBILITY |
374 | | error_code |
375 | | make_error_code(errc __e) _NOEXCEPT |
376 | 30.7M | { |
377 | 30.7M | return error_code(static_cast<int>(__e), generic_category()); |
378 | 30.7M | } |
379 | | |
380 | | inline _LIBCPP_INLINE_VISIBILITY |
381 | | bool |
382 | | operator<(const error_code& __x, const error_code& __y) _NOEXCEPT |
383 | 0 | { |
384 | 0 | return __x.category() < __y.category() |
385 | 0 | || (__x.category() == __y.category() && __x.value() < __y.value()); |
386 | 0 | } |
387 | | |
388 | | inline _LIBCPP_INLINE_VISIBILITY |
389 | | bool |
390 | | operator==(const error_code& __x, const error_code& __y) _NOEXCEPT |
391 | | { |
392 | | return __x.category() == __y.category() && __x.value() == __y.value(); |
393 | | } |
394 | | |
395 | | inline _LIBCPP_INLINE_VISIBILITY |
396 | | bool |
397 | | operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT |
398 | 599 | { |
399 | 599 | return __x.category().equivalent(__x.value(), __y) |
400 | 599 | || __y.category().equivalent(__x, __y.value())9 ; |
401 | 599 | } |
402 | | |
403 | | inline _LIBCPP_INLINE_VISIBILITY |
404 | | bool |
405 | | operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT |
406 | 0 | { |
407 | 0 | return __y == __x; |
408 | 0 | } |
409 | | |
410 | | inline _LIBCPP_INLINE_VISIBILITY |
411 | | bool |
412 | | operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT |
413 | 4 | { |
414 | 4 | return __x.category() == __y.category() && __x.value() == __y.value(); |
415 | 4 | } |
416 | | |
417 | | inline _LIBCPP_INLINE_VISIBILITY |
418 | | bool |
419 | | operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT |
420 | | {return !(__x == __y);} |
421 | | |
422 | | inline _LIBCPP_INLINE_VISIBILITY |
423 | | bool |
424 | | operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT |
425 | 0 | {return !(__x == __y);} |
426 | | |
427 | | inline _LIBCPP_INLINE_VISIBILITY |
428 | | bool |
429 | | operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT |
430 | 0 | {return !(__x == __y);} |
431 | | |
432 | | inline _LIBCPP_INLINE_VISIBILITY |
433 | | bool |
434 | | operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT |
435 | 0 | {return !(__x == __y);} |
436 | | |
437 | | template <> |
438 | | struct _LIBCPP_TEMPLATE_VIS hash<error_code> |
439 | | : public unary_function<error_code, size_t> |
440 | | { |
441 | | _LIBCPP_INLINE_VISIBILITY |
442 | | size_t operator()(const error_code& __ec) const _NOEXCEPT |
443 | 0 | { |
444 | 0 | return static_cast<size_t>(__ec.value()); |
445 | 0 | } |
446 | | }; |
447 | | |
448 | | template <> |
449 | | struct _LIBCPP_TEMPLATE_VIS hash<error_condition> |
450 | | : public unary_function<error_condition, size_t> |
451 | | { |
452 | | _LIBCPP_INLINE_VISIBILITY |
453 | | size_t operator()(const error_condition& __ec) const _NOEXCEPT |
454 | 0 | { |
455 | 0 | return static_cast<size_t>(__ec.value()); |
456 | 0 | } |
457 | | }; |
458 | | |
459 | | // system_error |
460 | | |
461 | | class _LIBCPP_TYPE_VIS system_error |
462 | | : public runtime_error |
463 | | { |
464 | | error_code __ec_; |
465 | | public: |
466 | | system_error(error_code __ec, const string& __what_arg); |
467 | | system_error(error_code __ec, const char* __what_arg); |
468 | | system_error(error_code __ec); |
469 | | system_error(int __ev, const error_category& __ecat, const string& __what_arg); |
470 | | system_error(int __ev, const error_category& __ecat, const char* __what_arg); |
471 | | system_error(int __ev, const error_category& __ecat); |
472 | | system_error(const system_error&) _NOEXCEPT = default; |
473 | | ~system_error() _NOEXCEPT; |
474 | | |
475 | | _LIBCPP_INLINE_VISIBILITY |
476 | 0 | const error_code& code() const _NOEXCEPT {return __ec_;} |
477 | | |
478 | | private: |
479 | | static string __init(const error_code&, string); |
480 | | }; |
481 | | |
482 | | _LIBCPP_NORETURN _LIBCPP_FUNC_VIS |
483 | | void __throw_system_error(int ev, const char* what_arg); |
484 | | |
485 | | _LIBCPP_END_NAMESPACE_STD |
486 | | |
487 | | #endif // _LIBCPP_SYSTEM_ERROR |