2 //===---------------------------- system_error ----------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #ifndef _LIBCPP_SYSTEM_ERROR
12 #define _LIBCPP_SYSTEM_ERROR
23 virtual ~error_category() noexcept;
25 error_category(const error_category&) = delete;
26 error_category& operator=(const error_category&) = delete;
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;
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;
39 const error_category& generic_category() noexcept;
40 const error_category& system_category() noexcept;
42 template <class T> struct is_error_code_enum
43 : public false_type {};
45 template <class T> struct is_error_condition_enum
46 : public false_type {};
52 error_code() noexcept;
53 error_code(int val, const error_category& cat) noexcept;
54 template <class ErrorCodeEnum>
55 error_code(ErrorCodeEnum e) noexcept;
58 void assign(int val, const error_category& cat) noexcept;
59 template <class ErrorCodeEnum>
60 error_code& operator=(ErrorCodeEnum e) noexcept;
61 void clear() noexcept;
64 int value() const noexcept;
65 const error_category& category() const noexcept;
66 error_condition default_error_condition() const noexcept;
67 string message() const;
68 explicit operator bool() const noexcept;
71 // non-member functions:
72 bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
73 template <class charT, class traits>
74 basic_ostream<charT,traits>&
75 operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
81 error_condition() noexcept;
82 error_condition(int val, const error_category& cat) noexcept;
83 template <class ErrorConditionEnum>
84 error_condition(ErrorConditionEnum e) noexcept;
87 void assign(int val, const error_category& cat) noexcept;
88 template <class ErrorConditionEnum>
89 error_condition& operator=(ErrorConditionEnum e) noexcept;
90 void clear() noexcept;
93 int value() const noexcept;
94 const error_category& category() const noexcept;
95 string message() const noexcept;
96 explicit operator bool() const noexcept;
99 bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
102 : public runtime_error
105 system_error(error_code ec, const string& what_arg);
106 system_error(error_code ec, const char* what_arg);
107 system_error(error_code ec);
108 system_error(int ev, const error_category& ecat, const string& what_arg);
109 system_error(int ev, const error_category& ecat, const char* what_arg);
110 system_error(int ev, const error_category& ecat);
112 const error_code& code() const noexcept;
113 const char* what() const noexcept;
118 address_family_not_supported, // EAFNOSUPPORT
119 address_in_use, // EADDRINUSE
120 address_not_available, // EADDRNOTAVAIL
121 already_connected, // EISCONN
122 argument_list_too_long, // E2BIG
123 argument_out_of_domain, // EDOM
124 bad_address, // EFAULT
125 bad_file_descriptor, // EBADF
126 bad_message, // EBADMSG
127 broken_pipe, // EPIPE
128 connection_aborted, // ECONNABORTED
129 connection_already_in_progress, // EALREADY
130 connection_refused, // ECONNREFUSED
131 connection_reset, // ECONNRESET
132 cross_device_link, // EXDEV
133 destination_address_required, // EDESTADDRREQ
134 device_or_resource_busy, // EBUSY
135 directory_not_empty, // ENOTEMPTY
136 executable_format_error, // ENOEXEC
137 file_exists, // EEXIST
138 file_too_large, // EFBIG
139 filename_too_long, // ENAMETOOLONG
140 function_not_supported, // ENOSYS
141 host_unreachable, // EHOSTUNREACH
142 identifier_removed, // EIDRM
143 illegal_byte_sequence, // EILSEQ
144 inappropriate_io_control_operation, // ENOTTY
145 interrupted, // EINTR
146 invalid_argument, // EINVAL
147 invalid_seek, // ESPIPE
149 is_a_directory, // EISDIR
150 message_size, // EMSGSIZE
151 network_down, // ENETDOWN
152 network_reset, // ENETRESET
153 network_unreachable, // ENETUNREACH
154 no_buffer_space, // ENOBUFS
155 no_child_process, // ECHILD
157 no_lock_available, // ENOLCK
158 no_message_available, // ENODATA
159 no_message, // ENOMSG
160 no_protocol_option, // ENOPROTOOPT
161 no_space_on_device, // ENOSPC
162 no_stream_resources, // ENOSR
163 no_such_device_or_address, // ENXIO
164 no_such_device, // ENODEV
165 no_such_file_or_directory, // ENOENT
166 no_such_process, // ESRCH
167 not_a_directory, // ENOTDIR
168 not_a_socket, // ENOTSOCK
169 not_a_stream, // ENOSTR
170 not_connected, // ENOTCONN
171 not_enough_memory, // ENOMEM
172 not_supported, // ENOTSUP
173 operation_canceled, // ECANCELED
174 operation_in_progress, // EINPROGRESS
175 operation_not_permitted, // EPERM
176 operation_not_supported, // EOPNOTSUPP
177 operation_would_block, // EWOULDBLOCK
178 owner_dead, // EOWNERDEAD
179 permission_denied, // EACCES
180 protocol_error, // EPROTO
181 protocol_not_supported, // EPROTONOSUPPORT
182 read_only_file_system, // EROFS
183 resource_deadlock_would_occur, // EDEADLK
184 resource_unavailable_try_again, // EAGAIN
185 result_out_of_range, // ERANGE
186 state_not_recoverable, // ENOTRECOVERABLE
187 stream_timeout, // ETIME
188 text_file_busy, // ETXTBSY
189 timed_out, // ETIMEDOUT
190 too_many_files_open_in_system, // ENFILE
191 too_many_files_open, // EMFILE
192 too_many_links, // EMLINK
193 too_many_symbolic_link_levels, // ELOOP
194 value_too_large, // EOVERFLOW
195 wrong_protocol_type // EPROTOTYPE
198 template <> struct is_error_condition_enum<errc>
201 error_code make_error_code(errc e) noexcept;
202 error_condition make_error_condition(errc e) noexcept;
204 // Comparison operators:
205 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
206 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
207 bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
208 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
209 bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
210 bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
211 bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
212 bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
214 template <> struct hash<std::error_code>;
222 #include <type_traits>
224 #include <__functional_base>
226 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
227 #pragma GCC system_header
230 _LIBCPP_BEGIN_NAMESPACE_STD
232 // is_error_code_enum
235 struct _LIBCPP_TYPE_VIS is_error_code_enum
236 : public false_type {};
238 // is_error_condition_enum
241 struct _LIBCPP_TYPE_VIS is_error_condition_enum
242 : public false_type {};
244 // Some error codes are not present on all platforms, so we provide equivalents
248 _LIBCPP_DECLARE_STRONG_ENUM(errc)
250 address_family_not_supported = EAFNOSUPPORT,
251 address_in_use = EADDRINUSE,
252 address_not_available = EADDRNOTAVAIL,
253 already_connected = EISCONN,
254 argument_list_too_long = E2BIG,
255 argument_out_of_domain = EDOM,
256 bad_address = EFAULT,
257 bad_file_descriptor = EBADF,
258 bad_message = EBADMSG,
260 connection_aborted = ECONNABORTED,
261 connection_already_in_progress = EALREADY,
262 connection_refused = ECONNREFUSED,
263 connection_reset = ECONNRESET,
264 cross_device_link = EXDEV,
265 destination_address_required = EDESTADDRREQ,
266 device_or_resource_busy = EBUSY,
267 directory_not_empty = ENOTEMPTY,
268 executable_format_error = ENOEXEC,
269 file_exists = EEXIST,
270 file_too_large = EFBIG,
271 filename_too_long = ENAMETOOLONG,
272 function_not_supported = ENOSYS,
273 host_unreachable = EHOSTUNREACH,
274 identifier_removed = EIDRM,
275 illegal_byte_sequence = EILSEQ,
276 inappropriate_io_control_operation = ENOTTY,
278 invalid_argument = EINVAL,
279 invalid_seek = ESPIPE,
281 is_a_directory = EISDIR,
282 message_size = EMSGSIZE,
283 network_down = ENETDOWN,
284 network_reset = ENETRESET,
285 network_unreachable = ENETUNREACH,
286 no_buffer_space = ENOBUFS,
287 no_child_process = ECHILD,
289 no_lock_available = ENOLCK,
291 no_message_available = ENODATA,
293 no_message_available = ENOMSG,
296 no_protocol_option = ENOPROTOOPT,
297 no_space_on_device = ENOSPC,
299 no_stream_resources = ENOSR,
301 no_stream_resources = ENOMEM,
303 no_such_device_or_address = ENXIO,
304 no_such_device = ENODEV,
305 no_such_file_or_directory = ENOENT,
306 no_such_process = ESRCH,
307 not_a_directory = ENOTDIR,
308 not_a_socket = ENOTSOCK,
310 not_a_stream = ENOSTR,
312 not_a_stream = EINVAL,
314 not_connected = ENOTCONN,
315 not_enough_memory = ENOMEM,
316 not_supported = ENOTSUP,
317 operation_canceled = ECANCELED,
318 operation_in_progress = EINPROGRESS,
319 operation_not_permitted = EPERM,
320 operation_not_supported = EOPNOTSUPP,
321 operation_would_block = EWOULDBLOCK,
322 owner_dead = EOWNERDEAD,
323 permission_denied = EACCES,
324 protocol_error = EPROTO,
325 protocol_not_supported = EPROTONOSUPPORT,
326 read_only_file_system = EROFS,
327 resource_deadlock_would_occur = EDEADLK,
328 resource_unavailable_try_again = EAGAIN,
329 result_out_of_range = ERANGE,
330 state_not_recoverable = ENOTRECOVERABLE,
332 stream_timeout = ETIME,
334 stream_timeout = ETIMEDOUT,
336 text_file_busy = ETXTBSY,
337 timed_out = ETIMEDOUT,
338 too_many_files_open_in_system = ENFILE,
339 too_many_files_open = EMFILE,
340 too_many_links = EMLINK,
341 too_many_symbolic_link_levels = ELOOP,
342 value_too_large = EOVERFLOW,
343 wrong_protocol_type = EPROTOTYPE
345 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
348 struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc>
351 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
353 struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc::__lx>
357 class _LIBCPP_TYPE_VIS error_condition;
358 class _LIBCPP_TYPE_VIS error_code;
360 // class error_category
362 class _LIBCPP_HIDDEN __do_message;
364 class _LIBCPP_TYPE_VIS error_category
367 virtual ~error_category() _NOEXCEPT;
369 error_category() _NOEXCEPT;
371 error_category(const error_category&);// = delete;
372 error_category& operator=(const error_category&);// = delete;
375 virtual const char* name() const _NOEXCEPT = 0;
376 virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
377 virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
378 virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
379 virtual string message(int __ev) const = 0;
381 _LIBCPP_ALWAYS_INLINE
382 bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
384 _LIBCPP_ALWAYS_INLINE
385 bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
387 _LIBCPP_ALWAYS_INLINE
388 bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
390 friend class _LIBCPP_HIDDEN __do_message;
393 class _LIBCPP_HIDDEN __do_message
394 : public error_category
397 virtual string message(int ev) const;
400 const error_category& generic_category() _NOEXCEPT;
401 const error_category& system_category() _NOEXCEPT;
403 class _LIBCPP_TYPE_VIS error_condition
406 const error_category* __cat_;
408 _LIBCPP_ALWAYS_INLINE
409 error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
411 _LIBCPP_ALWAYS_INLINE
412 error_condition(int __val, const error_category& __cat) _NOEXCEPT
413 : __val_(__val), __cat_(&__cat) {}
416 _LIBCPP_ALWAYS_INLINE
417 error_condition(_Ep __e,
418 typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
420 {*this = make_error_condition(__e);}
422 _LIBCPP_ALWAYS_INLINE
423 void assign(int __val, const error_category& __cat) _NOEXCEPT
430 _LIBCPP_ALWAYS_INLINE
433 is_error_condition_enum<_Ep>::value,
436 operator=(_Ep __e) _NOEXCEPT
437 {*this = make_error_condition(__e); return *this;}
439 _LIBCPP_ALWAYS_INLINE
440 void clear() _NOEXCEPT
443 __cat_ = &generic_category();
446 _LIBCPP_ALWAYS_INLINE
447 int value() const _NOEXCEPT {return __val_;}
449 _LIBCPP_ALWAYS_INLINE
450 const error_category& category() const _NOEXCEPT {return *__cat_;}
451 string message() const;
453 _LIBCPP_ALWAYS_INLINE
455 operator bool() const _NOEXCEPT {return __val_ != 0;}
458 inline _LIBCPP_INLINE_VISIBILITY
460 make_error_condition(errc __e) _NOEXCEPT
462 return error_condition(static_cast<int>(__e), generic_category());
465 inline _LIBCPP_INLINE_VISIBILITY
467 operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
469 return __x.category() < __y.category()
470 || (__x.category() == __y.category() && __x.value() < __y.value());
475 class _LIBCPP_TYPE_VIS error_code
478 const error_category* __cat_;
480 _LIBCPP_ALWAYS_INLINE
481 error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
483 _LIBCPP_ALWAYS_INLINE
484 error_code(int __val, const error_category& __cat) _NOEXCEPT
485 : __val_(__val), __cat_(&__cat) {}
488 _LIBCPP_ALWAYS_INLINE
490 typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
492 {*this = make_error_code(__e);}
494 _LIBCPP_ALWAYS_INLINE
495 void assign(int __val, const error_category& __cat) _NOEXCEPT
502 _LIBCPP_ALWAYS_INLINE
505 is_error_code_enum<_Ep>::value,
508 operator=(_Ep __e) _NOEXCEPT
509 {*this = make_error_code(__e); return *this;}
511 _LIBCPP_ALWAYS_INLINE
512 void clear() _NOEXCEPT
515 __cat_ = &system_category();
518 _LIBCPP_ALWAYS_INLINE
519 int value() const _NOEXCEPT {return __val_;}
521 _LIBCPP_ALWAYS_INLINE
522 const error_category& category() const _NOEXCEPT {return *__cat_;}
524 _LIBCPP_ALWAYS_INLINE
525 error_condition default_error_condition() const _NOEXCEPT
526 {return __cat_->default_error_condition(__val_);}
528 string message() const;
530 _LIBCPP_ALWAYS_INLINE
532 operator bool() const _NOEXCEPT {return __val_ != 0;}
535 inline _LIBCPP_INLINE_VISIBILITY
537 make_error_code(errc __e) _NOEXCEPT
539 return error_code(static_cast<int>(__e), generic_category());
542 inline _LIBCPP_INLINE_VISIBILITY
544 operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
546 return __x.category() < __y.category()
547 || (__x.category() == __y.category() && __x.value() < __y.value());
550 inline _LIBCPP_INLINE_VISIBILITY
552 operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
554 return __x.category() == __y.category() && __x.value() == __y.value();
557 inline _LIBCPP_INLINE_VISIBILITY
559 operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
561 return __x.category().equivalent(__x.value(), __y)
562 || __y.category().equivalent(__x, __y.value());
565 inline _LIBCPP_INLINE_VISIBILITY
567 operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
572 inline _LIBCPP_INLINE_VISIBILITY
574 operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
576 return __x.category() == __y.category() && __x.value() == __y.value();
579 inline _LIBCPP_INLINE_VISIBILITY
581 operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
582 {return !(__x == __y);}
584 inline _LIBCPP_INLINE_VISIBILITY
586 operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
587 {return !(__x == __y);}
589 inline _LIBCPP_INLINE_VISIBILITY
591 operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
592 {return !(__x == __y);}
594 inline _LIBCPP_INLINE_VISIBILITY
596 operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
597 {return !(__x == __y);}
600 struct _LIBCPP_TYPE_VIS hash<error_code>
601 : public unary_function<error_code, size_t>
603 _LIBCPP_INLINE_VISIBILITY
604 size_t operator()(const error_code& __ec) const _NOEXCEPT
606 return static_cast<size_t>(__ec.value());
612 class _LIBCPP_TYPE_VIS system_error
613 : public runtime_error
617 system_error(error_code __ec, const string& __what_arg);
618 system_error(error_code __ec, const char* __what_arg);
619 system_error(error_code __ec);
620 system_error(int __ev, const error_category& __ecat, const string& __what_arg);
621 system_error(int __ev, const error_category& __ecat, const char* __what_arg);
622 system_error(int __ev, const error_category& __ecat);
623 ~system_error() _NOEXCEPT;
625 _LIBCPP_ALWAYS_INLINE
626 const error_code& code() const _NOEXCEPT {return __ec_;}
629 static string __init(const error_code&, string);
632 void __throw_system_error(int ev, const char* what_arg);
634 _LIBCPP_END_NAMESPACE_STD
636 #endif // _LIBCPP_SYSTEM_ERROR