Statistics
| Revision:

root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / asio / error.hpp @ 2486

History | View | Annotate | Download (9.5 kB)

1
//
2
// error.hpp
3
// ~~~~~~~~~
4
//
5
// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6
//
7
// Distributed under the Boost Software License, Version 1.0. (See accompanying
8
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9
//
10

    
11
#ifndef BOOST_ASIO_ERROR_HPP
12
#define BOOST_ASIO_ERROR_HPP
13

    
14
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
15
# pragma once
16
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
17

    
18
#include <boost/asio/detail/config.hpp>
19
#include <boost/cerrno.hpp>
20
#include <boost/system/error_code.hpp>
21
#include <boost/system/system_error.hpp>
22
#if defined(BOOST_ASIO_WINDOWS) \
23
  || defined(__CYGWIN__) \
24
  || defined(BOOST_ASIO_WINDOWS_RUNTIME)
25
# include <winerror.h>
26
#else
27
# include <cerrno>
28
# include <netdb.h>
29
#endif
30

    
31
#if defined(GENERATING_DOCUMENTATION)
32
/// INTERNAL ONLY.
33
# define BOOST_ASIO_NATIVE_ERROR(e) implementation_defined
34
/// INTERNAL ONLY.
35
# define BOOST_ASIO_SOCKET_ERROR(e) implementation_defined
36
/// INTERNAL ONLY.
37
# define BOOST_ASIO_NETDB_ERROR(e) implementation_defined
38
/// INTERNAL ONLY.
39
# define BOOST_ASIO_GETADDRINFO_ERROR(e) implementation_defined
40
/// INTERNAL ONLY.
41
# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) implementation_defined
42
#elif defined(BOOST_ASIO_WINDOWS_RUNTIME)
43
# define BOOST_ASIO_NATIVE_ERROR(e) __HRESULT_FROM_WIN32(e)
44
# define BOOST_ASIO_SOCKET_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
45
# define BOOST_ASIO_NETDB_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
46
# define BOOST_ASIO_GETADDRINFO_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
47
# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
48
#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
49
# define BOOST_ASIO_NATIVE_ERROR(e) e
50
# define BOOST_ASIO_SOCKET_ERROR(e) WSA ## e
51
# define BOOST_ASIO_NETDB_ERROR(e) WSA ## e
52
# define BOOST_ASIO_GETADDRINFO_ERROR(e) WSA ## e
53
# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
54
#else
55
# define BOOST_ASIO_NATIVE_ERROR(e) e
56
# define BOOST_ASIO_SOCKET_ERROR(e) e
57
# define BOOST_ASIO_NETDB_ERROR(e) e
58
# define BOOST_ASIO_GETADDRINFO_ERROR(e) e
59
# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_posix
60
#endif
61

    
62
#include <boost/asio/detail/push_options.hpp>
63

    
64
namespace boost {
65
namespace asio {
66
namespace error {
67

    
68
enum basic_errors
69
{
70
  /// Permission denied.
71
  access_denied = BOOST_ASIO_SOCKET_ERROR(EACCES),
72

    
73
  /// Address family not supported by protocol.
74
  address_family_not_supported = BOOST_ASIO_SOCKET_ERROR(EAFNOSUPPORT),
75

    
76
  /// Address already in use.
77
  address_in_use = BOOST_ASIO_SOCKET_ERROR(EADDRINUSE),
78

    
79
  /// Transport endpoint is already connected.
80
  already_connected = BOOST_ASIO_SOCKET_ERROR(EISCONN),
81

    
82
  /// Operation already in progress.
83
  already_started = BOOST_ASIO_SOCKET_ERROR(EALREADY),
84

    
85
  /// Broken pipe.
86
  broken_pipe = BOOST_ASIO_WIN_OR_POSIX(
87
      BOOST_ASIO_NATIVE_ERROR(ERROR_BROKEN_PIPE),
88
      BOOST_ASIO_NATIVE_ERROR(EPIPE)),
89

    
90
  /// A connection has been aborted.
91
  connection_aborted = BOOST_ASIO_SOCKET_ERROR(ECONNABORTED),
92

    
93
  /// Connection refused.
94
  connection_refused = BOOST_ASIO_SOCKET_ERROR(ECONNREFUSED),
95

    
96
  /// Connection reset by peer.
97
  connection_reset = BOOST_ASIO_SOCKET_ERROR(ECONNRESET),
98

    
99
  /// Bad file descriptor.
100
  bad_descriptor = BOOST_ASIO_SOCKET_ERROR(EBADF),
101

    
102
  /// Bad address.
103
  fault = BOOST_ASIO_SOCKET_ERROR(EFAULT),
104

    
105
  /// No route to host.
106
  host_unreachable = BOOST_ASIO_SOCKET_ERROR(EHOSTUNREACH),
107

    
108
  /// Operation now in progress.
109
  in_progress = BOOST_ASIO_SOCKET_ERROR(EINPROGRESS),
110

    
111
  /// Interrupted system call.
112
  interrupted = BOOST_ASIO_SOCKET_ERROR(EINTR),
113

    
114
  /// Invalid argument.
115
  invalid_argument = BOOST_ASIO_SOCKET_ERROR(EINVAL),
116

    
117
  /// Message too long.
118
  message_size = BOOST_ASIO_SOCKET_ERROR(EMSGSIZE),
119

    
120
  /// The name was too long.
121
  name_too_long = BOOST_ASIO_SOCKET_ERROR(ENAMETOOLONG),
122

    
123
  /// Network is down.
124
  network_down = BOOST_ASIO_SOCKET_ERROR(ENETDOWN),
125

    
126
  /// Network dropped connection on reset.
127
  network_reset = BOOST_ASIO_SOCKET_ERROR(ENETRESET),
128

    
129
  /// Network is unreachable.
130
  network_unreachable = BOOST_ASIO_SOCKET_ERROR(ENETUNREACH),
131

    
132
  /// Too many open files.
133
  no_descriptors = BOOST_ASIO_SOCKET_ERROR(EMFILE),
134

    
135
  /// No buffer space available.
136
  no_buffer_space = BOOST_ASIO_SOCKET_ERROR(ENOBUFS),
137

    
138
  /// Cannot allocate memory.
139
  no_memory = BOOST_ASIO_WIN_OR_POSIX(
140
      BOOST_ASIO_NATIVE_ERROR(ERROR_OUTOFMEMORY),
141
      BOOST_ASIO_NATIVE_ERROR(ENOMEM)),
142

    
143
  /// Operation not permitted.
144
  no_permission = BOOST_ASIO_WIN_OR_POSIX(
145
      BOOST_ASIO_NATIVE_ERROR(ERROR_ACCESS_DENIED),
146
      BOOST_ASIO_NATIVE_ERROR(EPERM)),
147

    
148
  /// Protocol not available.
149
  no_protocol_option = BOOST_ASIO_SOCKET_ERROR(ENOPROTOOPT),
150

    
151
  /// No such device.
152
  no_such_device = BOOST_ASIO_WIN_OR_POSIX(
153
      BOOST_ASIO_NATIVE_ERROR(ERROR_BAD_UNIT),
154
      BOOST_ASIO_NATIVE_ERROR(ENODEV)),
155

    
156
  /// Transport endpoint is not connected.
157
  not_connected = BOOST_ASIO_SOCKET_ERROR(ENOTCONN),
158

    
159
  /// Socket operation on non-socket.
160
  not_socket = BOOST_ASIO_SOCKET_ERROR(ENOTSOCK),
161

    
162
  /// Operation cancelled.
163
  operation_aborted = BOOST_ASIO_WIN_OR_POSIX(
164
      BOOST_ASIO_NATIVE_ERROR(ERROR_OPERATION_ABORTED),
165
      BOOST_ASIO_NATIVE_ERROR(ECANCELED)),
166

    
167
  /// Operation not supported.
168
  operation_not_supported = BOOST_ASIO_SOCKET_ERROR(EOPNOTSUPP),
169

    
170
  /// Cannot send after transport endpoint shutdown.
171
  shut_down = BOOST_ASIO_SOCKET_ERROR(ESHUTDOWN),
172

    
173
  /// Connection timed out.
174
  timed_out = BOOST_ASIO_SOCKET_ERROR(ETIMEDOUT),
175

    
176
  /// Resource temporarily unavailable.
177
  try_again = BOOST_ASIO_WIN_OR_POSIX(
178
      BOOST_ASIO_NATIVE_ERROR(ERROR_RETRY),
179
      BOOST_ASIO_NATIVE_ERROR(EAGAIN)),
180

    
181
  /// The socket is marked non-blocking and the requested operation would block.
182
  would_block = BOOST_ASIO_SOCKET_ERROR(EWOULDBLOCK)
183
};
184

    
185
enum netdb_errors
186
{
187
  /// Host not found (authoritative).
188
  host_not_found = BOOST_ASIO_NETDB_ERROR(HOST_NOT_FOUND),
189

    
190
  /// Host not found (non-authoritative).
191
  host_not_found_try_again = BOOST_ASIO_NETDB_ERROR(TRY_AGAIN),
192

    
193
  /// The query is valid but does not have associated address data.
194
  no_data = BOOST_ASIO_NETDB_ERROR(NO_DATA),
195

    
196
  /// A non-recoverable error occurred.
197
  no_recovery = BOOST_ASIO_NETDB_ERROR(NO_RECOVERY)
198
};
199

    
200
enum addrinfo_errors
201
{
202
  /// The service is not supported for the given socket type.
203
  service_not_found = BOOST_ASIO_WIN_OR_POSIX(
204
      BOOST_ASIO_NATIVE_ERROR(WSATYPE_NOT_FOUND),
205
      BOOST_ASIO_GETADDRINFO_ERROR(EAI_SERVICE)),
206

    
207
  /// The socket type is not supported.
208
  socket_type_not_supported = BOOST_ASIO_WIN_OR_POSIX(
209
      BOOST_ASIO_NATIVE_ERROR(WSAESOCKTNOSUPPORT),
210
      BOOST_ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE))
211
};
212

    
213
enum misc_errors
214
{
215
  /// Already open.
216
  already_open = 1,
217

    
218
  /// End of file or stream.
219
  eof,
220

    
221
  /// Element not found.
222
  not_found,
223

    
224
  /// The descriptor cannot fit into the select system call's fd_set.
225
  fd_set_failure
226
};
227

    
228
inline const boost::system::error_category& get_system_category()
229
{
230
  return boost::system::system_category();
231
}
232

    
233
#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
234

    
235
extern BOOST_ASIO_DECL
236
const boost::system::error_category& get_netdb_category();
237

    
238
extern BOOST_ASIO_DECL
239
const boost::system::error_category& get_addrinfo_category();
240

    
241
#else // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
242

    
243
inline const boost::system::error_category& get_netdb_category()
244
{
245
  return get_system_category();
246
}
247

    
248
inline const boost::system::error_category& get_addrinfo_category()
249
{
250
  return get_system_category();
251
}
252

    
253
#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
254

    
255
extern BOOST_ASIO_DECL
256
const boost::system::error_category& get_misc_category();
257

    
258
static const boost::system::error_category& system_category
259
  = boost::asio::error::get_system_category();
260
static const boost::system::error_category& netdb_category
261
  = boost::asio::error::get_netdb_category();
262
static const boost::system::error_category& addrinfo_category
263
  = boost::asio::error::get_addrinfo_category();
264
static const boost::system::error_category& misc_category
265
  = boost::asio::error::get_misc_category();
266

    
267
} // namespace error
268
} // namespace asio
269
} // namespace boost
270

    
271
namespace boost {
272
namespace system {
273

    
274
template<> struct is_error_code_enum<boost::asio::error::basic_errors>
275
{
276
  static const bool value = true;
277
};
278

    
279
template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
280
{
281
  static const bool value = true;
282
};
283

    
284
template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
285
{
286
  static const bool value = true;
287
};
288

    
289
template<> struct is_error_code_enum<boost::asio::error::misc_errors>
290
{
291
  static const bool value = true;
292
};
293

    
294
} // namespace system
295
} // namespace boost
296

    
297
namespace boost {
298
namespace asio {
299
namespace error {
300

    
301
inline boost::system::error_code make_error_code(basic_errors e)
302
{
303
  return boost::system::error_code(
304
      static_cast<int>(e), get_system_category());
305
}
306

    
307
inline boost::system::error_code make_error_code(netdb_errors e)
308
{
309
  return boost::system::error_code(
310
      static_cast<int>(e), get_netdb_category());
311
}
312

    
313
inline boost::system::error_code make_error_code(addrinfo_errors e)
314
{
315
  return boost::system::error_code(
316
      static_cast<int>(e), get_addrinfo_category());
317
}
318

    
319
inline boost::system::error_code make_error_code(misc_errors e)
320
{
321
  return boost::system::error_code(
322
      static_cast<int>(e), get_misc_category());
323
}
324

    
325
} // namespace error
326
} // namespace asio
327
} // namespace boost
328

    
329
#include <boost/asio/detail/pop_options.hpp>
330

    
331
#undef BOOST_ASIO_NATIVE_ERROR
332
#undef BOOST_ASIO_SOCKET_ERROR
333
#undef BOOST_ASIO_NETDB_ERROR
334
#undef BOOST_ASIO_GETADDRINFO_ERROR
335
#undef BOOST_ASIO_WIN_OR_POSIX
336

    
337
#if defined(BOOST_ASIO_HEADER_ONLY)
338
# include <boost/asio/impl/error.ipp>
339
#endif // defined(BOOST_ASIO_HEADER_ONLY)
340

    
341
#endif // BOOST_ASIO_ERROR_HPP