root / lab4 / .minix-src / include / c++ / system_error
History | View | Annotate | Download (21.1 KB)
1 |
// -*- C++ -*- |
---|---|
2 |
//===---------------------------- system_error ----------------------------===// |
3 |
// |
4 |
// The LLVM Compiler Infrastructure |
5 |
// |
6 |
// This file is dual licensed under the MIT and the University of Illinois Open |
7 |
// Source Licenses. See LICENSE.TXT for details. |
8 |
// |
9 |
//===----------------------------------------------------------------------===// |
10 | |
11 |
#ifndef _LIBCPP_SYSTEM_ERROR |
12 |
#define _LIBCPP_SYSTEM_ERROR |
13 | |
14 |
/* |
15 |
system_error synopsis |
16 | |
17 |
namespace std |
18 |
{ |
19 | |
20 |
class error_category |
21 |
{ |
22 |
public: |
23 |
virtual ~error_category() noexcept; |
24 | |
25 |
constexpr error_category(); |
26 |
error_category(const error_category&) = delete; |
27 |
error_category& operator=(const error_category&) = delete; |
28 | |
29 |
virtual const char* name() const noexcept = 0; |
30 |
virtual error_condition default_error_condition(int ev) const noexcept; |
31 |
virtual bool equivalent(int code, const error_condition& condition) const noexcept; |
32 |
virtual bool equivalent(const error_code& code, int condition) const noexcept; |
33 |
virtual string message(int ev) const = 0; |
34 | |
35 |
bool operator==(const error_category& rhs) const noexcept; |
36 |
bool operator!=(const error_category& rhs) const noexcept; |
37 |
bool operator<(const error_category& rhs) const noexcept; |
38 |
}; |
39 | |
40 |
const error_category& generic_category() noexcept; |
41 |
const error_category& system_category() noexcept; |
42 | |
43 |
template <class T> struct is_error_code_enum |
44 |
: public false_type {}; |
45 | |
46 |
template <class T> struct is_error_condition_enum |
47 |
: public false_type {}; |
48 | |
49 |
class error_code |
50 |
{ |
51 |
public: |
52 |
// constructors: |
53 |
error_code() noexcept; |
54 |
error_code(int val, const error_category& cat) noexcept; |
55 |
template <class ErrorCodeEnum> |
56 |
error_code(ErrorCodeEnum e) noexcept; |
57 | |
58 |
// modifiers: |
59 |
void assign(int val, const error_category& cat) noexcept; |
60 |
template <class ErrorCodeEnum> |
61 |
error_code& operator=(ErrorCodeEnum e) noexcept; |
62 |
void clear() noexcept; |
63 | |
64 |
// observers: |
65 |
int value() const noexcept; |
66 |
const error_category& category() const noexcept; |
67 |
error_condition default_error_condition() const noexcept; |
68 |
string message() const; |
69 |
explicit operator bool() const noexcept; |
70 |
}; |
71 | |
72 |
// non-member functions: |
73 |
bool operator<(const error_code& lhs, const error_code& rhs) noexcept; |
74 |
template <class charT, class traits> |
75 |
basic_ostream<charT,traits>& |
76 |
operator<<(basic_ostream<charT,traits>& os, const error_code& ec); |
77 | |
78 |
class error_condition |
79 |
{ |
80 |
public: |
81 |
// constructors: |
82 |
error_condition() noexcept; |
83 |
error_condition(int val, const error_category& cat) noexcept; |
84 |
template <class ErrorConditionEnum> |
85 |
error_condition(ErrorConditionEnum e) noexcept; |
86 | |
87 |
// modifiers: |
88 |
void assign(int val, const error_category& cat) noexcept; |
89 |
template <class ErrorConditionEnum> |
90 |
error_condition& operator=(ErrorConditionEnum e) noexcept; |
91 |
void clear() noexcept; |
92 | |
93 |
// observers: |
94 |
int value() const noexcept; |
95 |
const error_category& category() const noexcept; |
96 |
string message() const noexcept; |
97 |
explicit operator bool() const noexcept; |
98 |
}; |
99 | |
100 |
bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; |
101 | |
102 |
class system_error |
103 |
: public runtime_error |
104 |
{ |
105 |
public: |
106 |
system_error(error_code ec, const string& what_arg); |
107 |
system_error(error_code ec, const char* what_arg); |
108 |
system_error(error_code ec); |
109 |
system_error(int ev, const error_category& ecat, const string& what_arg); |
110 |
system_error(int ev, const error_category& ecat, const char* what_arg); |
111 |
system_error(int ev, const error_category& ecat); |
112 | |
113 |
const error_code& code() const noexcept; |
114 |
const char* what() const noexcept; |
115 |
}; |
116 | |
117 |
enum class errc |
118 |
{ |
119 |
address_family_not_supported, // EAFNOSUPPORT |
120 |
address_in_use, // EADDRINUSE |
121 |
address_not_available, // EADDRNOTAVAIL |
122 |
already_connected, // EISCONN |
123 |
argument_list_too_long, // E2BIG |
124 |
argument_out_of_domain, // EDOM |
125 |
bad_address, // EFAULT |
126 |
bad_file_descriptor, // EBADF |
127 |
bad_message, // EBADMSG |
128 |
broken_pipe, // EPIPE |
129 |
connection_aborted, // ECONNABORTED |
130 |
connection_already_in_progress, // EALREADY |
131 |
connection_refused, // ECONNREFUSED |
132 |
connection_reset, // ECONNRESET |
133 |
cross_device_link, // EXDEV |
134 |
destination_address_required, // EDESTADDRREQ |
135 |
device_or_resource_busy, // EBUSY |
136 |
directory_not_empty, // ENOTEMPTY |
137 |
executable_format_error, // ENOEXEC |
138 |
file_exists, // EEXIST |
139 |
file_too_large, // EFBIG |
140 |
filename_too_long, // ENAMETOOLONG |
141 |
function_not_supported, // ENOSYS |
142 |
host_unreachable, // EHOSTUNREACH |
143 |
identifier_removed, // EIDRM |
144 |
illegal_byte_sequence, // EILSEQ |
145 |
inappropriate_io_control_operation, // ENOTTY |
146 |
interrupted, // EINTR |
147 |
invalid_argument, // EINVAL |
148 |
invalid_seek, // ESPIPE |
149 |
io_error, // EIO |
150 |
is_a_directory, // EISDIR |
151 |
message_size, // EMSGSIZE |
152 |
network_down, // ENETDOWN |
153 |
network_reset, // ENETRESET |
154 |
network_unreachable, // ENETUNREACH |
155 |
no_buffer_space, // ENOBUFS |
156 |
no_child_process, // ECHILD |
157 |
no_link, // ENOLINK |
158 |
no_lock_available, // ENOLCK |
159 |
no_message_available, // ENODATA |
160 |
no_message, // ENOMSG |
161 |
no_protocol_option, // ENOPROTOOPT |
162 |
no_space_on_device, // ENOSPC |
163 |
no_stream_resources, // ENOSR |
164 |
no_such_device_or_address, // ENXIO |
165 |
no_such_device, // ENODEV |
166 |
no_such_file_or_directory, // ENOENT |
167 |
no_such_process, // ESRCH |
168 |
not_a_directory, // ENOTDIR |
169 |
not_a_socket, // ENOTSOCK |
170 |
not_a_stream, // ENOSTR |
171 |
not_connected, // ENOTCONN |
172 |
not_enough_memory, // ENOMEM |
173 |
not_supported, // ENOTSUP |
174 |
operation_canceled, // ECANCELED |
175 |
operation_in_progress, // EINPROGRESS |
176 |
operation_not_permitted, // EPERM |
177 |
operation_not_supported, // EOPNOTSUPP |
178 |
operation_would_block, // EWOULDBLOCK |
179 |
owner_dead, // EOWNERDEAD |
180 |
permission_denied, // EACCES |
181 |
protocol_error, // EPROTO |
182 |
protocol_not_supported, // EPROTONOSUPPORT |
183 |
read_only_file_system, // EROFS |
184 |
resource_deadlock_would_occur, // EDEADLK |
185 |
resource_unavailable_try_again, // EAGAIN |
186 |
result_out_of_range, // ERANGE |
187 |
state_not_recoverable, // ENOTRECOVERABLE |
188 |
stream_timeout, // ETIME |
189 |
text_file_busy, // ETXTBSY |
190 |
timed_out, // ETIMEDOUT |
191 |
too_many_files_open_in_system, // ENFILE |
192 |
too_many_files_open, // EMFILE |
193 |
too_many_links, // EMLINK |
194 |
too_many_symbolic_link_levels, // ELOOP |
195 |
value_too_large, // EOVERFLOW |
196 |
wrong_protocol_type // EPROTOTYPE |
197 |
}; |
198 | |
199 |
template <> struct is_error_condition_enum<errc> |
200 |
: true_type { } |
201 | |
202 |
error_code make_error_code(errc e) noexcept; |
203 |
error_condition make_error_condition(errc e) noexcept; |
204 | |
205 |
// Comparison operators: |
206 |
bool operator==(const error_code& lhs, const error_code& rhs) noexcept; |
207 |
bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; |
208 |
bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; |
209 |
bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; |
210 |
bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; |
211 |
bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; |
212 |
bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; |
213 |
bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; |
214 | |
215 |
template <> struct hash<std::error_code>; |
216 | |
217 |
} // std |
218 | |
219 |
*/ |
220 | |
221 |
#include <__config> |
222 |
#include <cerrno> |
223 |
#include <type_traits> |
224 |
#include <stdexcept> |
225 |
#include <__functional_base> |
226 | |
227 |
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
228 |
#pragma GCC system_header |
229 |
#endif |
230 | |
231 |
_LIBCPP_BEGIN_NAMESPACE_STD |
232 | |
233 |
// is_error_code_enum |
234 | |
235 |
template <class _Tp> |
236 |
struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum |
237 |
: public false_type {}; |
238 | |
239 |
// is_error_condition_enum |
240 | |
241 |
template <class _Tp> |
242 |
struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum |
243 |
: public false_type {}; |
244 | |
245 |
// Some error codes are not present on all platforms, so we provide equivalents |
246 |
// for them: |
247 | |
248 |
//enum class errc |
249 |
_LIBCPP_DECLARE_STRONG_ENUM(errc) |
250 |
{ |
251 |
address_family_not_supported = EAFNOSUPPORT, |
252 |
address_in_use = EADDRINUSE, |
253 |
address_not_available = EADDRNOTAVAIL, |
254 |
already_connected = EISCONN, |
255 |
argument_list_too_long = E2BIG, |
256 |
argument_out_of_domain = EDOM, |
257 |
bad_address = EFAULT, |
258 |
bad_file_descriptor = EBADF, |
259 |
bad_message = EBADMSG, |
260 |
broken_pipe = EPIPE, |
261 |
connection_aborted = ECONNABORTED, |
262 |
connection_already_in_progress = EALREADY, |
263 |
connection_refused = ECONNREFUSED, |
264 |
connection_reset = ECONNRESET, |
265 |
cross_device_link = EXDEV, |
266 |
destination_address_required = EDESTADDRREQ, |
267 |
device_or_resource_busy = EBUSY, |
268 |
directory_not_empty = ENOTEMPTY, |
269 |
executable_format_error = ENOEXEC, |
270 |
file_exists = EEXIST, |
271 |
file_too_large = EFBIG, |
272 |
filename_too_long = ENAMETOOLONG, |
273 |
function_not_supported = ENOSYS, |
274 |
host_unreachable = EHOSTUNREACH, |
275 |
identifier_removed = EIDRM, |
276 |
illegal_byte_sequence = EILSEQ, |
277 |
inappropriate_io_control_operation = ENOTTY, |
278 |
interrupted = EINTR, |
279 |
invalid_argument = EINVAL, |
280 |
invalid_seek = ESPIPE, |
281 |
io_error = EIO, |
282 |
is_a_directory = EISDIR, |
283 |
message_size = EMSGSIZE, |
284 |
network_down = ENETDOWN, |
285 |
network_reset = ENETRESET, |
286 |
network_unreachable = ENETUNREACH, |
287 |
no_buffer_space = ENOBUFS, |
288 |
no_child_process = ECHILD, |
289 |
no_link = ENOLINK, |
290 |
no_lock_available = ENOLCK, |
291 |
#ifdef ENODATA |
292 |
no_message_available = ENODATA, |
293 |
#else |
294 |
no_message_available = ENOMSG, |
295 |
#endif |
296 |
no_message = ENOMSG, |
297 |
no_protocol_option = ENOPROTOOPT, |
298 |
no_space_on_device = ENOSPC, |
299 |
#ifdef ENOSR |
300 |
no_stream_resources = ENOSR, |
301 |
#else |
302 |
no_stream_resources = ENOMEM, |
303 |
#endif |
304 |
no_such_device_or_address = ENXIO, |
305 |
no_such_device = ENODEV, |
306 |
no_such_file_or_directory = ENOENT, |
307 |
no_such_process = ESRCH, |
308 |
not_a_directory = ENOTDIR, |
309 |
not_a_socket = ENOTSOCK, |
310 |
#ifdef ENOSTR |
311 |
not_a_stream = ENOSTR, |
312 |
#else |
313 |
not_a_stream = EINVAL, |
314 |
#endif |
315 |
not_connected = ENOTCONN, |
316 |
not_enough_memory = ENOMEM, |
317 |
not_supported = ENOTSUP, |
318 |
operation_canceled = ECANCELED, |
319 |
operation_in_progress = EINPROGRESS, |
320 |
operation_not_permitted = EPERM, |
321 |
operation_not_supported = EOPNOTSUPP, |
322 |
operation_would_block = EWOULDBLOCK, |
323 |
owner_dead = EOWNERDEAD, |
324 |
permission_denied = EACCES, |
325 |
protocol_error = EPROTO, |
326 |
protocol_not_supported = EPROTONOSUPPORT, |
327 |
read_only_file_system = EROFS, |
328 |
resource_deadlock_would_occur = EDEADLK, |
329 |
resource_unavailable_try_again = EAGAIN, |
330 |
result_out_of_range = ERANGE, |
331 |
state_not_recoverable = ENOTRECOVERABLE, |
332 |
#ifdef ETIME |
333 |
stream_timeout = ETIME, |
334 |
#else |
335 |
stream_timeout = ETIMEDOUT, |
336 |
#endif |
337 |
text_file_busy = ETXTBSY, |
338 |
timed_out = ETIMEDOUT, |
339 |
too_many_files_open_in_system = ENFILE, |
340 |
too_many_files_open = EMFILE, |
341 |
too_many_links = EMLINK, |
342 |
too_many_symbolic_link_levels = ELOOP, |
343 |
value_too_large = EOVERFLOW, |
344 |
wrong_protocol_type = EPROTOTYPE |
345 |
}; |
346 |
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc) |
347 | |
348 |
template <> |
349 |
struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc> |
350 |
: true_type { }; |
351 | |
352 |
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS |
353 |
template <> |
354 |
struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc::__lx> |
355 |
: true_type { }; |
356 |
#endif |
357 | |
358 |
class _LIBCPP_TYPE_VIS error_condition; |
359 |
class _LIBCPP_TYPE_VIS error_code; |
360 | |
361 |
// class error_category |
362 | |
363 |
class _LIBCPP_HIDDEN __do_message; |
364 | |
365 |
class _LIBCPP_TYPE_VIS error_category |
366 |
{ |
367 |
public: |
368 |
virtual ~error_category() _NOEXCEPT; |
369 | |
370 |
#ifdef _LIBCPP_BUILDING_SYSTEM_ERROR |
371 |
error_category() _NOEXCEPT; |
372 |
#else |
373 |
_LIBCPP_ALWAYS_INLINE |
374 |
_LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT; |
375 |
#endif |
376 |
private: |
377 |
error_category(const error_category&);// = delete; |
378 |
error_category& operator=(const error_category&);// = delete; |
379 | |
380 |
public: |
381 |
virtual const char* name() const _NOEXCEPT = 0; |
382 |
virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; |
383 |
virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; |
384 |
virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; |
385 |
virtual string message(int __ev) const = 0; |
386 | |
387 |
_LIBCPP_ALWAYS_INLINE |
388 |
bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} |
389 | |
390 |
_LIBCPP_ALWAYS_INLINE |
391 |
bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} |
392 | |
393 |
_LIBCPP_ALWAYS_INLINE |
394 |
bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} |
395 | |
396 |
friend class _LIBCPP_HIDDEN __do_message; |
397 |
}; |
398 | |
399 |
class _LIBCPP_HIDDEN __do_message |
400 |
: public error_category |
401 |
{ |
402 |
public: |
403 |
virtual string message(int ev) const; |
404 |
}; |
405 | |
406 |
_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT; |
407 |
_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT; |
408 | |
409 |
class _LIBCPP_TYPE_VIS error_condition |
410 |
{ |
411 |
int __val_; |
412 |
const error_category* __cat_; |
413 |
public: |
414 |
_LIBCPP_ALWAYS_INLINE |
415 |
error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {} |
416 | |
417 |
_LIBCPP_ALWAYS_INLINE |
418 |
error_condition(int __val, const error_category& __cat) _NOEXCEPT |
419 |
: __val_(__val), __cat_(&__cat) {} |
420 | |
421 |
template <class _Ep> |
422 |
_LIBCPP_ALWAYS_INLINE |
423 |
error_condition(_Ep __e, |
424 |
typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0 |
425 |
) _NOEXCEPT |
426 |
{*this = make_error_condition(__e);} |
427 | |
428 |
_LIBCPP_ALWAYS_INLINE |
429 |
void assign(int __val, const error_category& __cat) _NOEXCEPT |
430 |
{ |
431 |
__val_ = __val; |
432 |
__cat_ = &__cat; |
433 |
} |
434 | |
435 |
template <class _Ep> |
436 |
_LIBCPP_ALWAYS_INLINE |
437 |
typename enable_if |
438 |
< |
439 |
is_error_condition_enum<_Ep>::value, |
440 |
error_condition& |
441 |
>::type |
442 |
operator=(_Ep __e) _NOEXCEPT |
443 |
{*this = make_error_condition(__e); return *this;} |
444 | |
445 |
_LIBCPP_ALWAYS_INLINE |
446 |
void clear() _NOEXCEPT |
447 |
{ |
448 |
__val_ = 0; |
449 |
__cat_ = &generic_category(); |
450 |
} |
451 | |
452 |
_LIBCPP_ALWAYS_INLINE |
453 |
int value() const _NOEXCEPT {return __val_;} |
454 | |
455 |
_LIBCPP_ALWAYS_INLINE |
456 |
const error_category& category() const _NOEXCEPT {return *__cat_;} |
457 |
string message() const; |
458 | |
459 |
_LIBCPP_ALWAYS_INLINE |
460 |
_LIBCPP_EXPLICIT |
461 |
operator bool() const _NOEXCEPT {return __val_ != 0;} |
462 |
}; |
463 | |
464 |
inline _LIBCPP_INLINE_VISIBILITY |
465 |
error_condition |
466 |
make_error_condition(errc __e) _NOEXCEPT |
467 |
{ |
468 |
return error_condition(static_cast<int>(__e), generic_category()); |
469 |
} |
470 | |
471 |
inline _LIBCPP_INLINE_VISIBILITY |
472 |
bool |
473 |
operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT |
474 |
{ |
475 |
return __x.category() < __y.category() |
476 |
|| (__x.category() == __y.category() && __x.value() < __y.value()); |
477 |
} |
478 | |
479 |
// error_code |
480 | |
481 |
class _LIBCPP_TYPE_VIS error_code |
482 |
{ |
483 |
int __val_; |
484 |
const error_category* __cat_; |
485 |
public: |
486 |
_LIBCPP_ALWAYS_INLINE |
487 |
error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {} |
488 | |
489 |
_LIBCPP_ALWAYS_INLINE |
490 |
error_code(int __val, const error_category& __cat) _NOEXCEPT |
491 |
: __val_(__val), __cat_(&__cat) {} |
492 | |
493 |
template <class _Ep> |
494 |
_LIBCPP_ALWAYS_INLINE |
495 |
error_code(_Ep __e, |
496 |
typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0 |
497 |
) _NOEXCEPT |
498 |
{*this = make_error_code(__e);} |
499 | |
500 |
_LIBCPP_ALWAYS_INLINE |
501 |
void assign(int __val, const error_category& __cat) _NOEXCEPT |
502 |
{ |
503 |
__val_ = __val; |
504 |
__cat_ = &__cat; |
505 |
} |
506 | |
507 |
template <class _Ep> |
508 |
_LIBCPP_ALWAYS_INLINE |
509 |
typename enable_if |
510 |
< |
511 |
is_error_code_enum<_Ep>::value, |
512 |
error_code& |
513 |
>::type |
514 |
operator=(_Ep __e) _NOEXCEPT |
515 |
{*this = make_error_code(__e); return *this;} |
516 | |
517 |
_LIBCPP_ALWAYS_INLINE |
518 |
void clear() _NOEXCEPT |
519 |
{ |
520 |
__val_ = 0; |
521 |
__cat_ = &system_category(); |
522 |
} |
523 | |
524 |
_LIBCPP_ALWAYS_INLINE |
525 |
int value() const _NOEXCEPT {return __val_;} |
526 | |
527 |
_LIBCPP_ALWAYS_INLINE |
528 |
const error_category& category() const _NOEXCEPT {return *__cat_;} |
529 | |
530 |
_LIBCPP_ALWAYS_INLINE |
531 |
error_condition default_error_condition() const _NOEXCEPT |
532 |
{return __cat_->default_error_condition(__val_);} |
533 | |
534 |
string message() const; |
535 | |
536 |
_LIBCPP_ALWAYS_INLINE |
537 |
_LIBCPP_EXPLICIT |
538 |
operator bool() const _NOEXCEPT {return __val_ != 0;} |
539 |
}; |
540 | |
541 |
inline _LIBCPP_INLINE_VISIBILITY |
542 |
error_code |
543 |
make_error_code(errc __e) _NOEXCEPT |
544 |
{ |
545 |
return error_code(static_cast<int>(__e), generic_category()); |
546 |
} |
547 | |
548 |
inline _LIBCPP_INLINE_VISIBILITY |
549 |
bool |
550 |
operator<(const error_code& __x, const error_code& __y) _NOEXCEPT |
551 |
{ |
552 |
return __x.category() < __y.category() |
553 |
|| (__x.category() == __y.category() && __x.value() < __y.value()); |
554 |
} |
555 | |
556 |
inline _LIBCPP_INLINE_VISIBILITY |
557 |
bool |
558 |
operator==(const error_code& __x, const error_code& __y) _NOEXCEPT |
559 |
{ |
560 |
return __x.category() == __y.category() && __x.value() == __y.value(); |
561 |
} |
562 | |
563 |
inline _LIBCPP_INLINE_VISIBILITY |
564 |
bool |
565 |
operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT |
566 |
{ |
567 |
return __x.category().equivalent(__x.value(), __y) |
568 |
|| __y.category().equivalent(__x, __y.value()); |
569 |
} |
570 | |
571 |
inline _LIBCPP_INLINE_VISIBILITY |
572 |
bool |
573 |
operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT |
574 |
{ |
575 |
return __y == __x; |
576 |
} |
577 | |
578 |
inline _LIBCPP_INLINE_VISIBILITY |
579 |
bool |
580 |
operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT |
581 |
{ |
582 |
return __x.category() == __y.category() && __x.value() == __y.value(); |
583 |
} |
584 | |
585 |
inline _LIBCPP_INLINE_VISIBILITY |
586 |
bool |
587 |
operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT |
588 |
{return !(__x == __y);} |
589 | |
590 |
inline _LIBCPP_INLINE_VISIBILITY |
591 |
bool |
592 |
operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT |
593 |
{return !(__x == __y);} |
594 | |
595 |
inline _LIBCPP_INLINE_VISIBILITY |
596 |
bool |
597 |
operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT |
598 |
{return !(__x == __y);} |
599 | |
600 |
inline _LIBCPP_INLINE_VISIBILITY |
601 |
bool |
602 |
operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT |
603 |
{return !(__x == __y);} |
604 | |
605 |
template <> |
606 |
struct _LIBCPP_TYPE_VIS_ONLY hash<error_code> |
607 |
: public unary_function<error_code, size_t> |
608 |
{ |
609 |
_LIBCPP_INLINE_VISIBILITY |
610 |
size_t operator()(const error_code& __ec) const _NOEXCEPT |
611 |
{ |
612 |
return static_cast<size_t>(__ec.value()); |
613 |
} |
614 |
}; |
615 | |
616 |
// system_error |
617 | |
618 |
class _LIBCPP_TYPE_VIS system_error |
619 |
: public runtime_error |
620 |
{ |
621 |
error_code __ec_; |
622 |
public: |
623 |
system_error(error_code __ec, const string& __what_arg); |
624 |
system_error(error_code __ec, const char* __what_arg); |
625 |
system_error(error_code __ec); |
626 |
system_error(int __ev, const error_category& __ecat, const string& __what_arg); |
627 |
system_error(int __ev, const error_category& __ecat, const char* __what_arg); |
628 |
system_error(int __ev, const error_category& __ecat); |
629 |
~system_error() _NOEXCEPT; |
630 | |
631 |
_LIBCPP_ALWAYS_INLINE |
632 |
const error_code& code() const _NOEXCEPT {return __ec_;} |
633 | |
634 |
private: |
635 |
static string __init(const error_code&, string); |
636 |
}; |
637 | |
638 |
_LIBCPP_FUNC_VIS void __throw_system_error(int ev, const char* what_arg); |
639 | |
640 |
_LIBCPP_END_NAMESPACE_STD |
641 | |
642 |
#endif // _LIBCPP_SYSTEM_ERROR |