blob: 971be3374728a8aec5737ef543547102c9922792 [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001// -*- C++ -*-
2//===---------------------------- system_error ----------------------------===//
3//
Howard Hinnantf5256e12010-05-11 21:36:01 +00004// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00005//
Howard Hinnantb64f8b02010-11-16 22:09:02 +00006// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00008//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_SYSTEM_ERROR
12#define _LIBCPP_SYSTEM_ERROR
13
14/*
15 system_error synopsis
16
17namespace std
18{
19
20class error_category
21{
22public:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000023 virtual ~error_category() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000024
25 error_category(const error_category&) = delete;
26 error_category& operator=(const error_category&) = delete;
27
Howard Hinnant1e15fd12011-05-26 19:48:01 +000028 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;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000032 virtual string message(int ev) const = 0;
33
Howard Hinnant1e15fd12011-05-26 19:48:01 +000034 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;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000037};
38
Howard Hinnant1e15fd12011-05-26 19:48:01 +000039const error_category& generic_category() noexcept;
40const error_category& system_category() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000041
42template <class T> struct is_error_code_enum
43 : public false_type {};
44
45template <class T> struct is_error_condition_enum
46 : public false_type {};
47
48class error_code
49{
50public:
51 // constructors:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000052 error_code() noexcept;
53 error_code(int val, const error_category& cat) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000054 template <class ErrorCodeEnum>
Howard Hinnant1e15fd12011-05-26 19:48:01 +000055 error_code(ErrorCodeEnum e) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000056
57 // modifiers:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000058 void assign(int val, const error_category& cat) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000059 template <class ErrorCodeEnum>
Howard Hinnant1e15fd12011-05-26 19:48:01 +000060 error_code& operator=(ErrorCodeEnum e) noexcept;
61 void clear() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000062
63 // observers:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000064 int value() const noexcept;
65 const error_category& category() const noexcept;
66 error_condition default_error_condition() const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000067 string message() const;
Howard Hinnant1e15fd12011-05-26 19:48:01 +000068 explicit operator bool() const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000069};
70
71// non-member functions:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000072bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000073template <class charT, class traits>
74 basic_ostream<charT,traits>&
75 operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
76
77class error_condition
78{
79public:
80 // constructors:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000081 error_condition() noexcept;
82 error_condition(int val, const error_category& cat) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000083 template <class ErrorConditionEnum>
Howard Hinnant1e15fd12011-05-26 19:48:01 +000084 error_condition(ErrorConditionEnum e) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000085
86 // modifiers:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000087 void assign(int val, const error_category& cat) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000088 template <class ErrorConditionEnum>
Howard Hinnant1e15fd12011-05-26 19:48:01 +000089 error_condition& operator=(ErrorConditionEnum e) noexcept;
90 void clear() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000091
92 // observers:
Howard Hinnant1e15fd12011-05-26 19:48:01 +000093 int value() const noexcept;
94 const error_category& category() const noexcept;
95 string message() const noexcept;
96 explicit operator bool() const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000097};
98
Howard Hinnant1e15fd12011-05-26 19:48:01 +000099bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000100
101class system_error
102 : public runtime_error
103{
104public:
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);
111
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000112 const error_code& code() const noexcept;
113 const char* what() const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000114};
115
116enum class errc
117{
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
148 io_error, // EIO
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
156 no_link, // ENOLINK
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
196};
197
198template <> struct is_error_condition_enum<errc>
199 : true_type { }
200
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000201error_code make_error_code(errc e) noexcept;
202error_condition make_error_condition(errc e) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000203
204// Comparison operators:
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000205bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
206bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
207bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
208bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
209bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
210bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
211bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
212bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000213
214template <> struct hash<std::error_code>;
215
216} // std
217
218*/
219
220#include <__config>
221#include <cerrno>
222#include <type_traits>
223#include <stdexcept>
224#include <__functional_base>
225
Howard Hinnant08e17472011-10-17 20:05:10 +0000226#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000227#pragma GCC system_header
Howard Hinnant08e17472011-10-17 20:05:10 +0000228#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000229
230_LIBCPP_BEGIN_NAMESPACE_STD
231
232// is_error_code_enum
233
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000234template <class _Tp>
235struct _LIBCPP_VISIBLE is_error_code_enum
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000236 : public false_type {};
237
238// is_error_condition_enum
239
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000240template <class _Tp>
241struct _LIBCPP_VISIBLE is_error_condition_enum
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000242 : public false_type {};
243
David Chisnall81e68582010-08-11 16:52:41 +0000244// Some error codes are not present on all platforms, so we provide equivalents
245// for them:
246
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000247//enum class errc
Howard Hinnantf6d875f2011-12-02 19:36:40 +0000248_LIBCPP_DECLARE_STRONG_ENUM(errc)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000249{
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000250 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,
259 broken_pipe = EPIPE,
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,
277 interrupted = EINTR,
278 invalid_argument = EINVAL,
279 invalid_seek = ESPIPE,
280 io_error = EIO,
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,
288 no_link = ENOLINK,
289 no_lock_available = ENOLCK,
David Chisnall81e68582010-08-11 16:52:41 +0000290#ifdef ENODATA
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000291 no_message_available = ENODATA,
David Chisnall81e68582010-08-11 16:52:41 +0000292#else
293 no_message_available = ENOMSG,
294#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000295 no_message = ENOMSG,
296 no_protocol_option = ENOPROTOOPT,
297 no_space_on_device = ENOSPC,
David Chisnall81e68582010-08-11 16:52:41 +0000298#ifdef ENOSR
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000299 no_stream_resources = ENOSR,
David Chisnall81e68582010-08-11 16:52:41 +0000300#else
301 no_stream_resources = ENOMEM,
302#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000303 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,
David Chisnall81e68582010-08-11 16:52:41 +0000309#ifdef ENOSTR
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000310 not_a_stream = ENOSTR,
David Chisnall81e68582010-08-11 16:52:41 +0000311#else
312 not_a_stream = EINVAL,
313#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000314 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,
David Chisnall81e68582010-08-11 16:52:41 +0000331#ifdef ETIME
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000332 stream_timeout = ETIME,
David Chisnall81e68582010-08-11 16:52:41 +0000333#else
334 stream_timeout = ETIMEDOUT,
335#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000336 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
344};
Howard Hinnantf6d875f2011-12-02 19:36:40 +0000345_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000346
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000347template <>
348struct _LIBCPP_VISIBLE is_error_condition_enum<errc>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000349 : true_type { };
350
Howard Hinnantf6d875f2011-12-02 19:36:40 +0000351#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000352template <>
353struct _LIBCPP_VISIBLE is_error_condition_enum<errc::_>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000354 : true_type { };
Howard Hinnantf6d875f2011-12-02 19:36:40 +0000355#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000356
357class error_condition;
358class error_code;
359
360// class error_category
361
362class __do_message;
363
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000364class _LIBCPP_VISIBLE error_category
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000365{
366public:
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000367 virtual ~error_category() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000368
369private:
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000370 error_category() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000371 error_category(const error_category&);// = delete;
372 error_category& operator=(const error_category&);// = delete;
373
374public:
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000375 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;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000379 virtual string message(int __ev) const = 0;
380
381 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000382 bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000383
384 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000385 bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000386
387 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000388 bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000389
390 friend class __do_message;
391};
392
393class _LIBCPP_HIDDEN __do_message
394 : public error_category
395{
396public:
397 virtual string message(int ev) const;
398};
399
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000400const error_category& generic_category() _NOEXCEPT;
401const error_category& system_category() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000402
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000403class _LIBCPP_VISIBLE error_condition
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000404{
405 int __val_;
406 const error_category* __cat_;
407public:
408 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000409 error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000410
411 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000412 error_condition(int __val, const error_category& __cat) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000413 : __val_(__val), __cat_(&__cat) {}
414
Howard Hinnant99968442011-11-29 18:15:50 +0000415 template <class _Ep>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000416 _LIBCPP_ALWAYS_INLINE
Howard Hinnant99968442011-11-29 18:15:50 +0000417 error_condition(_Ep __e,
418 typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000419 ) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000420 {*this = make_error_condition(__e);}
421
422 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000423 void assign(int __val, const error_category& __cat) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000424 {
425 __val_ = __val;
426 __cat_ = &__cat;
427 }
428
Howard Hinnant99968442011-11-29 18:15:50 +0000429 template <class _Ep>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000430 _LIBCPP_ALWAYS_INLINE
431 typename enable_if
432 <
Howard Hinnant99968442011-11-29 18:15:50 +0000433 is_error_condition_enum<_Ep>::value,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000434 error_condition&
435 >::type
Howard Hinnant99968442011-11-29 18:15:50 +0000436 operator=(_Ep __e) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000437 {*this = make_error_condition(__e); return *this;}
438
439 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000440 void clear() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000441 {
442 __val_ = 0;
443 __cat_ = &generic_category();
444 }
445
446 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000447 int value() const _NOEXCEPT {return __val_;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000448
449 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000450 const error_category& category() const _NOEXCEPT {return *__cat_;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000451 string message() const;
452
453 _LIBCPP_ALWAYS_INLINE
454 //explicit
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000455 operator bool() const _NOEXCEPT {return __val_ != 0;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000456};
457
458inline _LIBCPP_INLINE_VISIBILITY
459error_condition
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000460make_error_condition(errc __e) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000461{
462 return error_condition(static_cast<int>(__e), generic_category());
463}
464
465inline _LIBCPP_INLINE_VISIBILITY
466bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000467operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000468{
469 return __x.category() < __y.category()
Howard Hinnantec3773c2011-12-01 20:21:04 +0000470 || (__x.category() == __y.category() && __x.value() < __y.value());
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000471}
472
473// error_code
474
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000475class _LIBCPP_VISIBLE error_code
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000476{
477 int __val_;
478 const error_category* __cat_;
479public:
480 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000481 error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000482
483 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000484 error_code(int __val, const error_category& __cat) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000485 : __val_(__val), __cat_(&__cat) {}
486
Howard Hinnant99968442011-11-29 18:15:50 +0000487 template <class _Ep>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000488 _LIBCPP_ALWAYS_INLINE
Howard Hinnant99968442011-11-29 18:15:50 +0000489 error_code(_Ep __e,
490 typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000491 ) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000492 {*this = make_error_code(__e);}
493
494 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000495 void assign(int __val, const error_category& __cat) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000496 {
497 __val_ = __val;
498 __cat_ = &__cat;
499 }
500
Howard Hinnant99968442011-11-29 18:15:50 +0000501 template <class _Ep>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000502 _LIBCPP_ALWAYS_INLINE
503 typename enable_if
504 <
Howard Hinnant99968442011-11-29 18:15:50 +0000505 is_error_code_enum<_Ep>::value,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000506 error_code&
507 >::type
Howard Hinnant99968442011-11-29 18:15:50 +0000508 operator=(_Ep __e) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000509 {*this = make_error_code(__e); return *this;}
510
511 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000512 void clear() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000513 {
514 __val_ = 0;
515 __cat_ = &system_category();
516 }
517
518 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000519 int value() const _NOEXCEPT {return __val_;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000520
521 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000522 const error_category& category() const _NOEXCEPT {return *__cat_;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000523
524 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000525 error_condition default_error_condition() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000526 {return __cat_->default_error_condition(__val_);}
527
528 string message() const;
529
530 _LIBCPP_ALWAYS_INLINE
531 //explicit
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000532 operator bool() const _NOEXCEPT {return __val_ != 0;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000533};
534
535inline _LIBCPP_INLINE_VISIBILITY
536error_code
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000537make_error_code(errc __e) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000538{
539 return error_code(static_cast<int>(__e), generic_category());
540}
541
542inline _LIBCPP_INLINE_VISIBILITY
543bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000544operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000545{
546 return __x.category() < __y.category()
Howard Hinnantec3773c2011-12-01 20:21:04 +0000547 || (__x.category() == __y.category() && __x.value() < __y.value());
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000548}
549
550inline _LIBCPP_INLINE_VISIBILITY
551bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000552operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000553{
554 return __x.category() == __y.category() && __x.value() == __y.value();
555}
556
557inline _LIBCPP_INLINE_VISIBILITY
558bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000559operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000560{
561 return __x.category().equivalent(__x.value(), __y)
562 || __y.category().equivalent(__x, __y.value());
563}
564
565inline _LIBCPP_INLINE_VISIBILITY
566bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000567operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000568{
569 return __y == __x;
570}
571
572inline _LIBCPP_INLINE_VISIBILITY
573bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000574operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000575{
576 return __x.category() == __y.category() && __x.value() == __y.value();
577}
578
579inline _LIBCPP_INLINE_VISIBILITY
580bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000581operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
582{return !(__x == __y);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000583
584inline _LIBCPP_INLINE_VISIBILITY
585bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000586operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
587{return !(__x == __y);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000588
589inline _LIBCPP_INLINE_VISIBILITY
590bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000591operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
592{return !(__x == __y);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000593
594inline _LIBCPP_INLINE_VISIBILITY
595bool
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000596operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
597{return !(__x == __y);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000598
599template <>
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000600struct _LIBCPP_VISIBLE hash<error_code>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000601 : public unary_function<error_code, size_t>
602{
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000603 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000604 size_t operator()(const error_code& __ec) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000605 {
606 return static_cast<size_t>(__ec.value());
607 }
608};
609
610// system_error
611
Howard Hinnant8d7a9552010-09-23 17:31:07 +0000612class _LIBCPP_VISIBLE system_error
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000613 : public runtime_error
614{
615 error_code __ec_;
616public:
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);
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000623 ~system_error() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000624
625 _LIBCPP_ALWAYS_INLINE
Howard Hinnant1e15fd12011-05-26 19:48:01 +0000626 const error_code& code() const _NOEXCEPT {return __ec_;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000627
628private:
629 static string __init(const error_code&, string);
630};
631
632void __throw_system_error(int ev, const char* what_arg);
633
634_LIBCPP_END_NAMESPACE_STD
635
636#endif // _LIBCPP_SYSTEM_ERROR