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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/* Copyright (C) 2015 Povilas Kanapickas <povilas@radix.lt>
This file is part of cppreference-doc
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0
Unported License. To view a copy of this license, visit
http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
*/
#ifndef CPPREFERENCE_SYSTEM_ERROR_H
#define CPPREFERENCE_SYSTEM_ERROR_H
#if CPPREFERENCE_STDVER>= 2011
namespace std {
class error_category {
public:
error_category(const error_category& other) = delete;
#if CPPREFERENCE_STDVER>= 2014
constexpr error_category();
#endif
virtual ~error_category();
virtual const char* name() const = 0;
virtual std::error_condition default_error_condition(int code) const;
virtual bool equivalent(int code,
const std::error_condition& condition) const;
virtual bool equivalent(const std::error_code& code,
int condition) const;
virtual std::string message(int condition) const = 0;
bool operator==(const error_category& rhs) const;
bool operator!=(const error_category& rhs) const;
bool operator<(const error_category& rhs) const;
};
const std::error_category& generic_category();
const std::error_category& system_category();
class error_condition {
public:
error_condition();
error_condition(const error_condition& other);
error_condition(int val, const error_category& cat);
template<class ErrorConditionEnum>
error_condition(ErrorConditionEnum e);
error_condition& operator=(const error_condition& other);
template<class ErrorConditionEnum>
error_condition& operator=(ErrorConditionEnum e);
void assign(int val, const error_category& cat);
void clear();
int value() const;
const error_category& category() const;
std::string message() const;
explicit operator bool() const;
};
bool operator==(const error_condition& lhs, const error_condition& rhs);
bool operator==(const error_code& lhs, const error_condition& rhs);
bool operator==(const error_condition& lhs, const error_code& rhs);
bool operator!=(const error_condition& lhs, const error_condition& rhs);
bool operator!=(const error_code& lhs, const error_condition& rhs);
bool operator!=(const error_condition& lhs, const error_code& rhs);
bool operator<(const error_condition& lhs, const error_condition& rhs);
enum class errc {
address_family_not_supported, // EAFNOSUPPORT
address_in_use, // EADDRINUSE
address_not_available, // EADDRNOTAVAIL
already_connected, // EISCONN
argument_list_too_long, // E2BIG
argument_out_of_domain, // EDOM
bad_address, // EFAULT
bad_file_descriptor, // EBADF
bad_message, // EBADMSG
broken_pipe, // EPIPE
connection_aborted, // ECONNABORTED
connection_already_in_progress, // EALREADY
connection_refused, // ECONNREFUSED
connection_reset, // ECONNRESET
cross_device_link, // EXDEV
destination_address_required, // EDESTADDRREQ
device_or_resource_busy, // EBUSY
directory_not_empty, // ENOTEMPTY
executable_format_error, // ENOEXEC
file_exists, // EEXIST
file_too_large, // EFBIG
filename_too_long, // ENAMETOOLONG
function_not_supported, // ENOSYS
host_unreachable, // EHOSTUNREACH
identifier_removed, // EIDRM
illegal_byte_sequence, // EILSEQ
inappropriate_io_control_operation, // ENOTTY
interrupted, // EINTR
invalid_argument, // EINVAL
invalid_seek, // ESPIPE
io_error, // EIO
is_a_directory, // EISDIR
message_size, // EMSGSIZE
network_down, // ENETDOWN
network_reset, // ENETRESET
network_unreachable, // ENETUNREACH
no_buffer_space, // ENOBUFS
no_child_process, // ECHILD
no_link, // ENOLINK
no_lock_available, // ENOLCK
no_message_available, // ENODATA
no_message, // ENOMSG
no_protocol_option, // ENOPROTOOPT
no_space_on_device, // ENOSPC
no_stream_resources, // ENOSR
no_such_device_or_address, // ENXIO
no_such_device, // ENODEV
no_such_file_or_directory, // ENOENT
no_such_process, // ESRCH
not_a_directory, // ENOTDIR
not_a_socket, // ENOTSOCK
not_a_stream, // ENOSTR
not_connected, // ENOTCONN
not_enough_memory, // ENOMEM
not_supported, // ENOTSUP
operation_canceled, // ECANCELED
operation_in_progress, // EINPROGRESS
operation_not_permitted, // EPERM
operation_not_supported, // EOPNOTSUPP
operation_would_block, // EWOULDBLOCK
owner_dead, // EOWNERDEAD
permission_denied, // EACCES
protocol_error, // EPROTO
protocol_not_supported, // EPROTONOSUPPORT
read_only_file_system, // EROFS
resource_deadlock_would_occur, // EDEADLK
resource_unavailable_try_again, // EAGAIN
result_out_of_range, // ERANGE
state_not_recoverable, // ENOTRECOVERABLE
stream_timeout, // ETIME
text_file_busy, // ETXTBSY
timed_out, // ETIMEDOUT
too_many_files_open_in_system, // ENFILE
too_many_files_open, // EMFILE
too_many_links, // EMLINK
too_many_symbolic_link_levels, // ELOOP
value_too_large, // EOVERFLOW
wrong_protocol_type, // EPROTOTYPE
};
class error_code {
public:
error_code();
error_code(int ec, const error_category& ecat);
template<class ErrorCodeEnum>
error_code(ErrorCodeEnum e);
template<class ErrorCodeEnum>
error_code& operator=(ErrorCodeEnum e);
void assign(int ec, const error_category& ecat);
void clear();
int value() const;
const std::error_category& category() const;
std::error_condition default_error_condition() const;
std::string message() const;
explicit operator bool() const;
};
bool operator==(const error_code& lhs, const error_code& rhs);
bool operator!=(const error_code& lhs, const error_code& rhs);
bool operator<(const error_code& lhs, const error_code& rhs);
template<class CharT, class Traits>
std::basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const error_code& ec);
class system_error : public runtime_error {
public:
system_error(std::error_code ec);
system_error(std::error_code ec, const std::string& what_arg);
system_error(std::error_code ec, const char* what_arg);
system_error(int ev, const std::error_category& ecat);
system_error(int ev, const std::error_category& ecat,
const std::string& what_arg);
system_error(int ev, const std::error_category& ecat,
const char* what_arg);
const std::error_code& code() const;
virtual const char* what() const;
};
template<class T>
struct is_error_code_enum : integral_constant<bool, false> {};
template<class T>
struct is_error_condition_enum : integral_constant<bool, false> {};
std::error_code make_error_code(std::errc e);
std::error_condition make_error_condition(std::errc e);
} // namespace std
#endif // CPPREFERENCE_STDVER>= 2011
#endif // CPPREFERENCE_SYSTEM_ERROR_H
|
