mirror of
https://github.com/boostorg/system.git
synced 2025-12-25 08:18:05 +01:00
Compare commits
16 Commits
feature/us
...
boost-1.69
| Author | SHA1 | Date | |
|---|---|---|---|
|
3a4fff686e | ||
|
054c0caf60 | ||
|
|
b31fb4804d | ||
|
|
7f303cc4b6 | ||
|
|
504fb05c2f | ||
|
|
d13fa54450 | ||
|
|
fb44b43f0a | ||
|
|
e87cd333a8 | ||
|
|
3d01409fe6 | ||
|
|
25a34e1647 | ||
|
|
342400c7ec | ||
|
|
1b4c7f366d | ||
|
|
af2edc5bea | ||
|
|
1e6dc86a68 | ||
|
|
efff0260f7 | ||
|
|
62ca8e6d8c |
@@ -22,4 +22,4 @@ lib boost_system
|
||||
<link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
|
||||
;
|
||||
|
||||
boost-install boost_system ;
|
||||
boost-install boost_system ;
|
||||
|
||||
2
doc/.gitignore
vendored
Normal file
2
doc/.gitignore
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
/html/
|
||||
/pdf/
|
||||
23
doc/Jamfile
Normal file
23
doc/Jamfile
Normal file
@@ -0,0 +1,23 @@
|
||||
# Copyright 2017, 2018 Peter Dimov
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
import asciidoctor ;
|
||||
|
||||
html system.html : system.adoc ;
|
||||
|
||||
install html_ : system.html : <location>html ;
|
||||
|
||||
pdf system.pdf : system.adoc ;
|
||||
explicit system.pdf ;
|
||||
|
||||
install pdf_ : system.pdf : <location>pdf ;
|
||||
explicit pdf_ ;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease : html_ ;
|
||||
explicit boostrelease ;
|
||||
163
doc/index.html
163
doc/index.html
@@ -1,163 +0,0 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Language" content="en-us">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<title>Boost System Library</title>
|
||||
<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
|
||||
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
|
||||
<tr>
|
||||
<td width="277">
|
||||
<a href="../../../index.html">
|
||||
<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86" border="0"></a></td>
|
||||
<td width="337" align="middle">
|
||||
<font size="7">System Library</font>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
|
||||
<tr>
|
||||
<td><a href="../../../index.htm">Boost Home</a> <a href="index.html">
|
||||
Library Home</a> Tutorial <a href="reference.html">
|
||||
Reference</a></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" align="right">
|
||||
<tr>
|
||||
<td width="100%" bgcolor="#D7EEFF" align="center">
|
||||
<i><b>Contents</b></i></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="100%" bgcolor="#E8F5FF">
|
||||
<a href="#Introduction">Introduction</a><br>
|
||||
<a href="#Release_History">Release History</a><br>
|
||||
<a href="#Design_Rationale">Design Rationale</a><br>
|
||||
<a href="#History">History</a><br>
|
||||
<a href="#Acknowledgements">Acknowledgements</a>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="100%" bgcolor="#D7EEFF" align="center">
|
||||
<b><i>Headers</i></b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="100%" bgcolor="#E8F5FF">
|
||||
<a href="reference.html#Header-error_code"><boost/system/error_code.hpp></a><br>
|
||||
<a href="reference.html#Header-system_error">
|
||||
<boost/system/system_error.hpp></a><br>
|
||||
<a href="../../../boost/system/cygwin_error.hpp">
|
||||
<boost/system/cygwin_error.hpp></a><br>
|
||||
<a href="../../../boost/system/linux_error.hpp">
|
||||
<boost/system/linux_error.hpp></a><br>
|
||||
<a href="../../../boost/system/windows_error.hpp">
|
||||
<boost/system/windows_error.hpp></a></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>Error conditions originating from the operating system or other low-level
|
||||
application program interfaces (API's) are typically reported via an integer
|
||||
representing an error code. When these low-level API calls are wrapped in
|
||||
portable code, such as in a portable library, some users want to deal with the
|
||||
error codes in portable ways. Other users need to get at the system specific
|
||||
error codes, so they can deal with system specific needs. The Boost System
|
||||
library provides simple, light-weight <a href="reference.html#Class-error_code">
|
||||
error_code</a> objects that encapsulate system-specific error code values, yet
|
||||
also provide access to more abstract and portable error conditions via
|
||||
<a href="reference.html#Class-error_condition">error_condition</a> objects.
|
||||
Because error_code objects can represent errors from sources other than the
|
||||
operating system, including user-defined sources, each error_code and
|
||||
error_condition has an associated <a href="reference.html#Class-error_category">
|
||||
error_category</a>.</p>
|
||||
|
||||
<p>An exception class, <a href="reference.html#Class-system_error">
|
||||
system_error</a>, is provided. Derived from std::runtime_error, it captures the
|
||||
underlying error_code for the problem causing the exception so that this
|
||||
important information is not lost.</p>
|
||||
<p>While exceptions are the preferred C++ default error code reporting
|
||||
mechanism, users of libraries dependent on low-level API's often need overloads
|
||||
reporting error conditions via error code arguments and/or return values rather
|
||||
than via throwing exceptions. Otherwise, when errors are not exceptional
|
||||
occurrences and must be dealt with as they arise, programs become littered with
|
||||
try/catch blocks, unreadable, and very inefficient. The Boost System library
|
||||
supports both error reporting by exception and by error code.</p>
|
||||
<p>In addition to portable errors codes and conditions supported by the <code>
|
||||
error_code.hpp</code> header, system-specific headers support the Cygwin, Linux,
|
||||
and Windows platforms. These headers are effectively no-ops if included for
|
||||
platforms other than their intended target.</p>
|
||||
<table border="1" cellpadding="10" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
|
||||
<tr>
|
||||
<td>The Boost System Library is part of the C++11 Standard Library.
|
||||
A number of changes, particularly to names, were made by the C++ committee
|
||||
during standardization. The Boost implementation is tracking those changes.
|
||||
See <a href="reference.html#Deprecated-names">Deprecated names</a> for
|
||||
synonyms provided to prevent breakage of existing user code. See
|
||||
<a href="reference.html#Breaking-changes">Breaking changes</a> for changes
|
||||
that unavoidably break existing user code. All breaking changes are noisy
|
||||
and will cause compile-time errors.</td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2><a name="Release_History">Release History</a></h2>
|
||||
<p><code>system-2014-06-02</code>: First modular Boost release. Minor
|
||||
maintenance changes.</p>
|
||||
<h2><a name="Design_Rationale">Design Rationale</a></h2>
|
||||
<p>Class <code>error_code</code> and <code>error_condition</code> are designed as a value types so
|
||||
they can be copied
|
||||
without slicing and do not requiring heap allocation, but still have polymorphic
|
||||
behavior based on the error category. This is achieved by abstract base class
|
||||
<code>error_category</code> supplying the polymorphic behavior, and <code>
|
||||
error_code</code> and <code>error_condition</code> containing a pointer to an object of a type derived from <code>
|
||||
error_category</code>.</p>
|
||||
<p>Many of the detailed design decisions were driven by the requirements that
|
||||
users to be able to add additional error categories, and that it be no more
|
||||
difficult to write portable code than system-specific code.</p>
|
||||
<p>The <code>operator<<</code> overload for <code>error_code</code> eliminates a
|
||||
misleading conversion to bool in code like <code>cout << ec</code>, where <code>
|
||||
ec</code> is of type <code>error_code</code>. It is also useful in its own
|
||||
right.</p>
|
||||
<h2><a name="History">History</a></h2>
|
||||
<p><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1975.html">
|
||||
N1975</a>, Filesystem Library Proposal for TR2, accepted for Library Technical
|
||||
Report 2 (TR2) at the Berlin meeting, included additional components to
|
||||
supplement the Standard Library's Diagnostics clause. Since then, these error
|
||||
reporting components have received wider public scrutiny and enhancements have
|
||||
been made to the design. The enhanced version has been used by N2054, Networking
|
||||
Library Proposal for TR2, demonstrating that these error reporting components
|
||||
are useful beyond the original Filesystem Library.</p>
|
||||
<p>The original proposal viewed error categories as a binary choice between
|
||||
<code>errno</code> (i.e. POSIX-style) and the native operating system's error
|
||||
codes. The proposed components now allow as many additional error categories as
|
||||
are needed by either implementations or by users. The need to support additional
|
||||
error categories, for example, occurs in some networking library implementations
|
||||
because they are built on top of the POSIX <code>getaddrinfo</code> API that
|
||||
uses error codes not based on <code>errno</code>.</p>
|
||||
<h2><a name="Acknowledgements">Acknowledgements</a></h2>
|
||||
<p>Christopher Kohlhoff and Peter Dimov made important contributions to the
|
||||
design. Comments and suggestions were also received from Pavel Vozenilek,
|
||||
Gennaro Prota, Dave Abrahams, Jeff Garland, Iain Hanson, Oliver Kowalke, and
|
||||
Oleg Abrosimov. Christopher Kohlhoff suggested several improvements to the N2066
|
||||
paper. Johan Nilsson's comments led to several of the refinements in N2066 .</p>
|
||||
<hr>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->June 02, 2014<!--webbot bot="Timestamp" endspan i-checksum="13984" --> </font>
|
||||
</p>
|
||||
|
||||
<p><EFBFBD> Copyright Beman Dawes, 1999</p>
|
||||
|
||||
<p>Distributed under the Boost Software License, Version 1.0.
|
||||
(See file <a href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
|
||||
or <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>) </p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
@@ -1,834 +0,0 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Language" content="en-us">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<title>System Library Reference</title>
|
||||
<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
|
||||
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="637">
|
||||
<tr>
|
||||
<td width="277">
|
||||
<a href="../../../index.htm">
|
||||
<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86" border="0"></a></td>
|
||||
<td width="337" align="middle">
|
||||
<font size="7">System Library</font>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
|
||||
<tr>
|
||||
<td><a href="../../../index.htm">Boost Home</a> <a href="index.html">
|
||||
Library Home</a> Tutorial <a href="reference.html">
|
||||
Reference</a></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" align="right">
|
||||
<tr>
|
||||
<td width="100%" bgcolor="#D7EEFF" align="center">
|
||||
<i><b>Contents</b></i></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="100%" bgcolor="#E8F5FF">
|
||||
<a href="#Introduction">Introduction</a><br>
|
||||
<a href="#C++11">C++11</a><br>
|
||||
<a href="#Macros">Macros</a><br>
|
||||
<a href="#Deprecated-names">Deprecated names</a><br>
|
||||
<a href="#Breaking-changes">Breaking changes</a><br>
|
||||
<a href="#Header-error_code">Header <boost/system/error_code.hpp></a><br>
|
||||
<a href="#Class-error_category">Class <code>error_category</code></a><br>
|
||||
<a href="#Class-error_category-synopsis">Class <code>error_category</code> synopsis</a><br>
|
||||
<a href="#Class-error_category-virtual-members">Class <code>error_category</code> virtual members</a><br>
|
||||
<a href="#Class-error_category-non-virtual-members">Class <code>error_category</code> non-virtual members</a><br>
|
||||
<a href="#Class-error_category-non-member-functions">Class <code>error_category</code>
|
||||
non-member functions</a><br>
|
||||
<a href="#Class-error_category-predefined-objects">Class <code>error_category</code> predefined objects</a><br>
|
||||
<a href="#Class-error_code">Class <code>error_code</code></a><br>
|
||||
<a href="#Class-error_code-synopsis">Class <code>error_code</code> synopsis</a><br>
|
||||
<a href="#Class-error_code-constructors">Class <code>error_code</code> constructors</a><br>
|
||||
<a href="#Class-error_code-modifiers">Class <code>error_code</code> modifiers</a><br>
|
||||
<a href="#Class-error_code-observers">Class <code>error_code</code> observers</a><br>
|
||||
<a href="#Class-error_condition">Class <code>error_condition</code></a><br>
|
||||
<a href="#Class-error_condition-synopsis">Class <code>error_condition</code> synopsis</a><br>
|
||||
<a href="#Class-error_condition-constructors">Class <code>error_condition</code> constructors</a><br>
|
||||
<a href="#Class-error_condition-modifiers">Class <code>error_condition</code> modifiers</a><br>
|
||||
<a href="#Class-error_condition-observers">Class <code>error_condition</code> observers</a><br>
|
||||
<a href="#Function-boost-throws">Function <code>boost::throws()</code></a><br>
|
||||
<a href="#Non-member-functions">Non-member functions</a><br>
|
||||
<a href="#Header-system_error">Header <boost/system/system_error.hpp></a><br>
|
||||
<a href="#Class-system_error">Class <code>system_error</code></a><br>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>This reference documentation describes components that programs may use to report error conditions originating from the operating
|
||||
system or other low-level application program interfaces.</p>
|
||||
<p>Boost.System library components never change the value of <code>
|
||||
errno</code>.</p>
|
||||
<h2><a name="C++11">C++11</a></h2>
|
||||
<p>The library is documented to use several C++11 features, including <code>
|
||||
noexcept</code> and explicit conversion operators. The actual implementation
|
||||
uses C++11 features only when they are available, and otherwise falls back on
|
||||
C++03 features.</p>
|
||||
<h2><a name="Macros">Macros</a></h2>
|
||||
<p>Users may define the following macros if desired. Sensible defaults are
|
||||
provided, so users may ignore these macros if they prefer.</p>
|
||||
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" height="368">
|
||||
<tr>
|
||||
<td height="16"><b><i>Macro Name</i></b></td>
|
||||
<td height="16"><b><i>Default</i></b></td>
|
||||
<td height="16"><b><i>Effect if defined</i></b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" height="64"><code>BOOST_ERROR_CODE_HEADER_ONLY</code></td>
|
||||
<td valign="top" height="64">Not defined.</td>
|
||||
<td valign="top" height="64">The implementation is header-only, and the
|
||||
Boost.System library is not built. Overrides other link and library macros.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" height="64"><code>BOOST_SYSTEM_DYN_LINK</code></td>
|
||||
<td valign="top" height="64">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined,
|
||||
otherwise not defined.</td>
|
||||
<td valign="top" height="64">Boost.System library is dynamically linked. If not defined,
|
||||
static linking is assumed.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" height="47"><code>BOOST_SYSTEM_NO_LIB</code></td>
|
||||
<td valign="top" height="47">Defined if <code>BOOST_ALL_NO_LIB</code> is defined,
|
||||
otherwise not defined.</td>
|
||||
<td valign="top" height="47">Boost.System library does not use the Boost auto-link
|
||||
facility.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" height="32"><code>BOOST_SYSTEM_ENABLE_DEPRECATED</code></td>
|
||||
<td valign="top" height="32">Not defined.</td>
|
||||
<td valign="top" height="32">Deprecated features are provided for compatibility.</td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2><a name="Deprecated-names">Deprecated names</a></h2>
|
||||
<p>In the process of adding Boost.System to the C++11 standard library, the
|
||||
C++ committee changed some names. To ease transition, Boost.System deprecates
|
||||
the old names, but will provide them when the macro
|
||||
<code>BOOST_SYSTEM_ENABLE_DEPRECATED</code> is defined.</p>
|
||||
<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
|
||||
<tr>
|
||||
<td><b><i>Old usage, now deprecated</i></b></td>
|
||||
<td><b><i>Replacement</i></b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>get_generic_category()</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>get_system_category()</code></td>
|
||||
<td><code>system_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>namespace posix</code></td>
|
||||
<td><code>namespace errc</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>namespace posix_error</code></td>
|
||||
<td><code>namespace errc</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>enum posix_errno</code></td>
|
||||
<td><code>enum errc_t</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>get_posix_category()</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>posix_category</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>errno_ecat</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>native_ecat</code></td>
|
||||
<td><code>system_category()</code></td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2><a name="Breaking-changes">Breaking changes</a></h2>
|
||||
<p>Two static consts are replaced by functions. These are breaking changes best
|
||||
fixed by globally adding () to these names to turn them into function calls.</p>
|
||||
<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
|
||||
<tr>
|
||||
<td><b><i>Old usage, now broken</i></b></td>
|
||||
<td><b><i>Replacement</i></b></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>generic_category</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>system_category</code></td>
|
||||
<td><code>system_category()</code></td>
|
||||
</tr>
|
||||
</table>
|
||||
<p>User-defined BOOST_POSIX_API and BOOST_WINDOWS_API macros are no longer supported.</p>
|
||||
<h2><a name="Header-error_code">Header <boost/system/error_code.hpp></a></h2>
|
||||
<h3><boost/system/error_code.hpp> synopsis</h3>
|
||||
<blockquote>
|
||||
<pre>namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
class <a href="#Class-error_category">error_category</a>;
|
||||
const error_category & <a href="#system_category">system_category</a>() noexcept;
|
||||
const error_category & <a href="#generic_category">generic_category</a>() noexcept;
|
||||
|
||||
class <a href="#Class-error_code">error_code</a>;
|
||||
class <a href="#Class-error_condition">error_condition</a>;
|
||||
|
||||
// "Concept" helpers
|
||||
template< class T="" >
|
||||
struct is_error_code_enum { static const bool value = false; };
|
||||
|
||||
template< class T="" >
|
||||
struct is_error_condition_enum { static const bool value = false; };
|
||||
|
||||
// generic error_conditions
|
||||
namespace errc
|
||||
{
|
||||
enum errc_t
|
||||
{
|
||||
success = 0,
|
||||
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_synbolic_link_levels, //ELOOP
|
||||
value_too_large, //EOVERFLOW
|
||||
wrong_protocol_type //EPROTOTYPE
|
||||
};
|
||||
|
||||
} // namespace errc
|
||||
|
||||
template<> struct is_error_condition_enum<posix::posix_errno><errc::errc_t>
|
||||
{ static const bool value = true; };
|
||||
|
||||
// <a href="#Non-member-functions">non-member functions</a>
|
||||
|
||||
bool operator==( const error_code & lhs, const error_code & rhs ) noexcept;
|
||||
bool operator==( const error_code & code, const error_condition & condition ) noexcept;
|
||||
bool operator==( const error_condition & condition, const error_code & code ) noexcept;
|
||||
bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept;
|
||||
|
||||
bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept;
|
||||
bool operator!=( const error_code & code, const error_condition & condition ) noexcept;
|
||||
bool operator!=( const error_condition & condition, const error_code & code ) noexcept;
|
||||
bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept;
|
||||
|
||||
bool operator<( const error_code & lhs, const error_code & rhs ) noexcept;
|
||||
bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept;
|
||||
|
||||
error_code make_error_code( errc::errc_t e ) noexcept;
|
||||
error_condition make_error_condition( errc::errc_t e ) noexcept;
|
||||
|
||||
template <class charT, class traits>
|
||||
std::basic_ostream<charT,traits>&
|
||||
operator<<( basic_ostream<charT,traits>& os, const error_code & ec );
|
||||
|
||||
size_t hash_value( const error_code & ec );
|
||||
|
||||
} // namespace system
|
||||
|
||||
system::error_code & throws();
|
||||
|
||||
} // namespace boost</pre>
|
||||
</blockquote>
|
||||
<p>The value of each<code> errc_t</code> constant shall be the same as the
|
||||
value of the <code><cerrno></code> macro shown in the above synopsis.</p>
|
||||
<p>Users may specialize <code>is_error_code_enum</code> and <code>
|
||||
is_error_condition_enum</code> templates to indicate that a type is eligible for
|
||||
class <code>error_code</code> and <code>error_condition</code> automatic
|
||||
conversions respectively.</p>
|
||||
|
||||
<pre>const error_category & <a name="system_category">system_category</a>();</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A reference to a <code>error_category</code> object
|
||||
identifying errors originating from the operating system.</p>
|
||||
</blockquote>
|
||||
<pre>const error_category & <a name="generic_category">generic_category</a>();</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A reference to a <code>error_category</code> object
|
||||
identifying portable error conditions.</p>
|
||||
</blockquote>
|
||||
|
||||
<h2><a name="Class-error_category">Class <code>error_category</code></a></h2>
|
||||
<p>The class <code>error_category</code> defines the base class for types used
|
||||
to identify the source and encoding of a particular category of error code.</p>
|
||||
<p><i>[Note:</i> Classes may be derived from <code>error_category</code>
|
||||
to support additional categories of errors. <i>--end note]</i></p>
|
||||
<p>The class <code>error_category</code> serves as a base class for types used
|
||||
to identify the source and encoding of a particular category of error code.
|
||||
Classes may be derived from <code>error_category</code> to support categories of
|
||||
errors in addition to those defined in the Boost System library. Such classes
|
||||
shall behave as specified in this subclause. [<i> Note:</i> <code>error_category</code>
|
||||
objects are passed by reference, and two such objects are equal if they have the
|
||||
same address. This means that applications using custom <code>error_category</code>
|
||||
types should create a single object of each such type. <i><EFBFBD>end note</i> ]</p>
|
||||
<h3><a name="Class-error_category-synopsis">Class <code>error_category</code> synopsis</a></h3>
|
||||
<blockquote>
|
||||
<pre>namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
class error_category : public noncopyable
|
||||
{
|
||||
public:
|
||||
virtual ~error_category();
|
||||
|
||||
virtual const char * name() const noexcept = 0;
|
||||
virtual string message( int ev ) const = 0;
|
||||
virtual error_condition default_error_condition( int ev ) const noexcept;
|
||||
virtual bool equivalent( int code, const error_condition & condition )
|
||||
const noexcept;
|
||||
virtual bool equivalent( const error_code & code, int condition ) const noexcept;
|
||||
|
||||
bool operator==( const error_category & rhs ) const noexcept;
|
||||
bool operator!=( const error_category & rhs ) const noexcept;
|
||||
bool operator< ( const error_category & rhs ) const noexcept;
|
||||
};
|
||||
}
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_category-virtual-members">Class <code>error_category</code> virtual members</a></h3>
|
||||
<p>Classes derived from <code>error_category</code> shall behave as specified in
|
||||
this subclause.</p>
|
||||
<pre>virtual const char * name() const noexcept =0;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns: </i>a string naming the error category.</p>
|
||||
</blockquote>
|
||||
<pre>virtual string message( int ev ) const noexcept =0;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A string that describes the error denoted by
|
||||
<code>ev</code>.</p>
|
||||
</blockquote>
|
||||
<pre>virtual error_condition default_error_condition( int ev ) const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_condition( ev, *this )</code>.</p>
|
||||
<blockquote>
|
||||
<p dir="ltr"> [<i>--Note:</i> Derived classes will typically convert <code>ev</code>
|
||||
to some portable <code>error_category</code>, such as <code>generic_category()</code>,
|
||||
and return it as an <code>error_condition</code> for that category. <i>--end
|
||||
note</i>]</p>
|
||||
</blockquote>
|
||||
</blockquote>
|
||||
<pre>virtual bool equivalent( int code, const error_condition & condition ) const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>default_error_condition( code ) == condition</code>.</p>
|
||||
</blockquote>
|
||||
<pre>virtual bool equivalent( const error_code & code, int condition ) const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>*this == code.category() && code.value() == condition</code>.</p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_category-non-virtual-members">Class <code>error_category</code> non-virtual members</a></h3>
|
||||
<pre>bool operator==( const error_category & rhs ) const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>this == &rhs</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_category & rhs ) const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>this != &rhs</code>.</p>
|
||||
</blockquote>
|
||||
|
||||
<pre>bool operator<( const error_category & rhs ) const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>std::less<const error_category*>()( this, &rhs
|
||||
noexcept)</code>.</p>
|
||||
<blockquote>
|
||||
<p><i>[Note:</i> <code>std::less</code> provides a total ordering for
|
||||
pointers. <i>--end note]</i></p>
|
||||
</blockquote>
|
||||
</blockquote>
|
||||
<h2><a name="Class-error_code">Class <code>
|
||||
error_code</code></a></h2>
|
||||
<p>The class <code>error_code</code> describes an object used to hold error code
|
||||
values, such as those originating from the operating<br>
|
||||
system or other low-level application program interfaces. <i>[ Note: </i>Class
|
||||
<code>error_code</code> is an adjunct to error reporting by<br>
|
||||
exception. <i><EFBFBD>end note ]</i></p>
|
||||
<h3><a name="Class-error_code-synopsis">Class <code>
|
||||
error_code</code> synopsis</a></h3>
|
||||
<blockquote>
|
||||
<pre>namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
class error_code {
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_code() noexcept;
|
||||
error_code( val, const error_category & cat ) noexcept;
|
||||
template <class <code>ErrorCodeEnum</code>>
|
||||
error_code(<code> ErrorCodeEnum</code> e ) noexcept;
|
||||
|
||||
// modifiers:
|
||||
void assign( int val, const error_category & cat ) noexcept;
|
||||
template<typename <code>ErrorCodeEnum</code>>
|
||||
error_code & operator=( <code>ErrorCodeEnum</code> val ) noexcept;
|
||||
void clear() noexcept;
|
||||
|
||||
// observers:
|
||||
int value() const noexcept;
|
||||
cont error_category & category() const noexcept;
|
||||
error_condition default_error_condition() const noexcept;
|
||||
string message() const;
|
||||
operator unspecified-bool-type() const;
|
||||
|
||||
private:
|
||||
int val_; // <i>exposition only</i>
|
||||
const error_category * cat_; // <i>exposition only</i>
|
||||
};
|
||||
}
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_code-constructors">Class <code>
|
||||
error_code</code> constructors</a></h3>
|
||||
<pre>error_code() noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == 0 && cat_ == &system_category()</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_code( int val, const error_category & cat ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == val && cat_ == &cat</code>.</p>
|
||||
</blockquote>
|
||||
<pre>template <class <code>ErrorCodeEnum</code>>
|
||||
error_code(<code> ErrorCodeEnum</code> val ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_code( val )</code>.</p>
|
||||
<p><i>Remarks:</i> This constructor shall not participate in overload
|
||||
resolution unless <code>is_error_code_enum<ErrorCodeEnum>::value</code> is
|
||||
<code>true</code>.</p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_code-modifiers">Class <code>
|
||||
error_code</code> modifiers</a></h3>
|
||||
<pre>void assign( int val, const error_category & cat ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>val_ == val && cat_ == &cat</code>.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename <code>ErrorCodeEnum</code>>
|
||||
error_code & operator=( <code>ErrorCodeEnum</code> val ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_code( val )</code>.</p>
|
||||
<p><i>Remarks:</i> This operator shall not participate in overload resolution
|
||||
unless <code>is_error_code_enum<ErrorCodeEnum>::value</code> is <code>true</code>.</p>
|
||||
</blockquote>
|
||||
<pre><code>void clear() noexcept;</code></pre>
|
||||
<blockquote>
|
||||
<p><i>postcondition:</i> <code>value() == 0 && category() ==
|
||||
system_category()</code></p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_code-observers">Class <code>
|
||||
error_code</code> observers</a></h3>
|
||||
<pre><code>int value() const noexcept;</code></pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>val_</code>.</p>
|
||||
</blockquote>
|
||||
<pre><code>const error_category & category() const noexcept;</code></pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>*cat_</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition default_error_condition() const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>category().default_error_condition( value())</code>.</p>
|
||||
</blockquote>
|
||||
<pre><code>string message() const;</code></pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>category().message( value())</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>operator unspecified-bool-type() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> if <code>value() != 0</code>, returns a value that will evaluate
|
||||
<code>true</code> in a boolean context; otherwise, returns a value that will
|
||||
evaluate <code>false</code> in a boolean context. The value type returned shall
|
||||
not be convertible to <code>int</code>.</p>
|
||||
<p><i>Throws:</i> nothing.</p>
|
||||
<p><i>[Note: </i>This conversion can be used in contexts where a <code>bool</code>
|
||||
is expected ( e.g., an <code>if</code> condition ); however, implicit conversions
|
||||
( e.g., to <code>int</code>) that can occur with <code>bool</code> are not
|
||||
allowed, eliminating some sources of user error. One possible implementation
|
||||
choice for this type is pointer-to-member. <i>--end note ]</i></p>
|
||||
</blockquote>
|
||||
<h2><a name="Class-error_condition">Class <code>error_condition</code></a></h2>
|
||||
<p>The class <code>error_condition</code> describes an object used to hold
|
||||
values identifying error conditions. <i>[ Note: </i><code>error_condition</code>
|
||||
values are portable abstractions, while <code>error_code</code> values are
|
||||
implementation specific. <i>--end note ]</i></p>
|
||||
<h3><a name="Class-error_condition-synopsis">Class <code>error_condition</code> synopsis</a></h3>
|
||||
<blockquote>
|
||||
<pre>namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
class error_condition
|
||||
{
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_condition() noexcept;
|
||||
error_condition( int val, const error_category & cat ) noexcept;
|
||||
template <class ErrorConditionEnum>
|
||||
error_condition( errorConditionEnum val ) noexcept;
|
||||
|
||||
// modifiers:
|
||||
void assign( int val, const error_category & cat ) noexcept;
|
||||
template<typename ErrorConditionEnum>
|
||||
error_condition & operator=( ErrorConditionEnum val ) noexcept;
|
||||
void clear() noexcept;
|
||||
|
||||
// observers:
|
||||
int value() const noexcept;
|
||||
const error_category & category() const noexcept;
|
||||
string message() const;
|
||||
operator unspecified-bool-type () const noexcept;
|
||||
|
||||
private:
|
||||
int val_; // <i>exposition only</i>
|
||||
const error_category * cat_; // <i>exposition only</i>
|
||||
};
|
||||
}
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_condition-constructors">Class <code>error_condition</code>
|
||||
constructors</a></h3>
|
||||
<pre>error_condition() noexcept; </pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of type <code>error_condition</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == 0 and cat_ == &generic_category()</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition( int val, const error_category & cat ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects: </i>Constructs an object of type error_condition.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == val and cat_ == &cat</code>.</p>
|
||||
</blockquote>
|
||||
<pre>template <class ErrorConditionEnum>
|
||||
error_condition( ErrorConditionEnum e ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of type <code>error_condition</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_condition(e)</code>.</p>
|
||||
<p><i>Remarks:</i> This constructor shall not participate in overload
|
||||
resolution unless <code>is_error_condition_enum<ErrorConditionEnum>::value</code>
|
||||
is <code>true</code>.</p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_condition-modifiers">Class <code>error_condition</code>
|
||||
modifiers</a></h3>
|
||||
<pre>void assign( int val, const error_category & cat ) noexcept; </pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>val_ == val and cat_ == &cat</code>. </p>
|
||||
</blockquote>
|
||||
<pre>template<typename ErrorConditionEnum>
|
||||
error_condition & operator=( ErrorConditionEnum e ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_condition( e )</code>.</p>
|
||||
<p><i>Returns:</i> <code>*this</code>.</p>
|
||||
<p><i>Remarks:</i> This operator shall not participate in overload resolution
|
||||
unless <code>is_error_condition_enum<ErrorConditionEnum>::value</code> is
|
||||
<code>true</code>.</p>
|
||||
</blockquote>
|
||||
<pre>void clear() noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Postcondition:</i> <code>value() == 0 && category() == generic_category()</code></p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_condition-observers">Class <code>error_condition</code>
|
||||
observers</a></h3>
|
||||
<pre>int value() const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>val_</code>.</p>
|
||||
</blockquote>
|
||||
<pre>const error_category & category() const noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>*cat_</code>.</p>
|
||||
</blockquote>
|
||||
<pre>string message() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>category().message( value() )</code>.</p>
|
||||
</blockquote>
|
||||
<pre>operator unspecified-bool-type () const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns: </i>If <code>value() != 0</code>, returns a value that will
|
||||
evaluate <code>true</code> in a boolean context; otherwise, returns a value
|
||||
that will evaluate <code>false</code>. The return type shall not be
|
||||
convertible to <code>int</code>. </p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
<p><i> [ Note:</i> This conversion can be used in contexts where a <code>bool</code>
|
||||
is expected ( e.g., an if condition ); however, implicit conversions ( e.g., to
|
||||
<code>int</code>) that can occur with <code>bool</code> are not allowed,
|
||||
eliminating some sources of user error. One possible implementation choice for
|
||||
this type is pointer to member. <i>--end note</i> <i>]</i></p>
|
||||
</blockquote>
|
||||
<h2><a name="Non-member-functions">Non-member functions</a></h2>
|
||||
<pre>bool operator==( const error_code & lhs, const error_code & rhs ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() == rhs.category() && lhs.value() ==
|
||||
rhs.value()</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator==( const error_code & code, const error_condition & condition ) noexcept;
|
||||
bool operator==( const error_condition & condition, const error_code & code ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>code.category().equivalent( code.value(), condition )<br>
|
||||
|| condition.category().equivalent( code, condition.value() )</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() == rhs.category() && lhs.value() ==
|
||||
rhs.value()</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_code & code, const error_condition & condition ) noexcept;
|
||||
bool operator!=( const error_condition & condition, const error_code & code ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i><code> !( code == condition )</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator<( const error_code & lhs, const error_code & rhs ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() < rhs.category()<br>
|
||||
|| (lhs.category() == rhs.category() && lhs.value() < rhs.value())</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() < rhs.category()<br>
|
||||
|| (lhs.category() == rhs.category() && lhs.value() < rhs.value())</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_code make_error_code( errc::errc_t e ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_code( e, generic_category())</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition make_error_condition( errc::errc_t e ) noexcept;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_condition( static_cast<int>( e ), generic_category())</code>.</p>
|
||||
</blockquote>
|
||||
|
||||
<pre>template <class charT, class traits>
|
||||
std::basic_ostream<charT,traits>&
|
||||
operator<<( basic_ostream<charT,traits>& os, const error_code & ec );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> <code>os << ec.category().name() << ':' << ec.value()</code>.</p>
|
||||
<p><i>Returns:</i> <code>os</code>.</p>
|
||||
</blockquote>
|
||||
<pre>size_t <a name="hash_value">hash_value</a>( const error_code & ec );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns: </i> A hash value representing <code>ec</code>.</p>
|
||||
</blockquote>
|
||||
|
||||
<h2><a name="Function-boost-throws">Function <code>boost::throws()</code></a></h2>
|
||||
|
||||
<pre>system::error_code& throws();</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A <code>system::error_code</code> reference
|
||||
for use in some user-defined function signature as a "throw on error" tag.</p>
|
||||
<p><i>Remark:</i> The only valid use for the returned reference is to test its
|
||||
address for equality or inequality to the address of the reference returned by
|
||||
another call to throws(). The returned reference itself has been poisoned so
|
||||
that an attempt to dereference it will fail.</p>
|
||||
<p>[<i>Example: </i>Example of a function that uses the <code>throws()</code> idiom:</p>
|
||||
<blockquote>
|
||||
<pre>int divide(int dividend, int divisor,
|
||||
boost::system::error_code& ec = boost::throws())
|
||||
{
|
||||
if (divisor == 0) // is there an error?
|
||||
{
|
||||
if (&ec == &boost::throws()) // throw on error
|
||||
throw "oops!"; // whatever exception you prefer
|
||||
ec = error_code(EDOM, generic_category()); // report error via error_code
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (&ec != &boost::throws()) // error reporting via error_code
|
||||
ec.clear();
|
||||
return dividend / divisor;
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<p>— <i>end Example</i>]</p>
|
||||
</blockquote>
|
||||
|
||||
<h2><a name="Header-system_error">Header <boost/system/system_error.hpp></a></h2>
|
||||
|
||||
<h3><a name="Class-system_error">Class <code>
|
||||
system_error</code></a></h3>
|
||||
<p>The class <code>system_error</code> describes an exception object used to
|
||||
report errors that have an associated <code><a href="#Class-error_code">error_code</a></code>. Such errors typically originate from operating system or other low-level
|
||||
application program interfaces.</p>
|
||||
<blockquote>
|
||||
<pre>namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
class system_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
system_error( error_code ec );
|
||||
system_error( error_code ec, const char * what_arg );
|
||||
system_error( error_code ec, const std::string & what_arg );
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const char * what_arg );
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const std::string & what_arg );
|
||||
system_error( int ev, const error_category & ecat);
|
||||
|
||||
const error_code & code() const throw();
|
||||
const char * what() const throw();
|
||||
};
|
||||
}
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<pre>system_error( error_code ec );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
|
||||
<p><i>Postcondition:</i> <code>code() == ec <br>
|
||||
&& std::strcmp( this->runtime_error::what(), "" ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( error_code ec, const char * what_arg );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
|
||||
<p><i>Postcondition:</i> <code>code() == ec <br>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( error_code ec, const std::string & what_arg );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
|
||||
<p><i>Postcondition:</i> <code>code() == ec <br>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg.c_str() ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( int ev, const error_category & ecat,
|
||||
const char * what_arg );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
|
||||
<p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( int ev, const error_category & ecat,
|
||||
const std::string & what_arg );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
|
||||
<p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg.c_str() ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( int ev, const error_category & ecat );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
|
||||
<p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
|
||||
&& std::strcmp( this->runtime_error::what(), "" ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>const error_code & code() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>ec</code> or <code>error_code( ev, ecat )</code>, from
|
||||
the constructor, as appropriate.</p>
|
||||
</blockquote>
|
||||
<pre>const char * what() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns: </i>A string incorporating <code>
|
||||
this->runtime_error::what()</code> and <code>
|
||||
code.message()</code>.</p>
|
||||
</blockquote>
|
||||
<hr>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->September 07, 2017<!--webbot bot="Timestamp" endspan i-checksum="38006" --> </font>
|
||||
</p>
|
||||
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2006, 2007, 2008, 2013</p>
|
||||
|
||||
<p>Distributed under the Boost Software License, Version 1.0. See
|
||||
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
5
doc/system-docinfo-footer.html
Normal file
5
doc/system-docinfo-footer.html
Normal file
@@ -0,0 +1,5 @@
|
||||
<style>
|
||||
|
||||
*:not(pre)>code { background: none; color: #600000; }
|
||||
|
||||
</style>
|
||||
27
doc/system.adoc
Normal file
27
doc/system.adoc
Normal file
@@ -0,0 +1,27 @@
|
||||
////
|
||||
Copyright 2018 Peter Dimov
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
# Boost.System: Extensible Error Reporting
|
||||
Beman Dawes, Christopher Kohlhoff, Peter Dimov
|
||||
:toc: left
|
||||
:toclevels: 3
|
||||
:idprefix:
|
||||
:docinfo: private-footer
|
||||
|
||||
:leveloffset: +1
|
||||
|
||||
include::system/introduction.adoc[]
|
||||
include::system/changes.adoc[]
|
||||
include::system/rationale.adoc[]
|
||||
include::system/reference.adoc[]
|
||||
include::system/history.adoc[]
|
||||
include::system/acknowledgements.adoc[]
|
||||
include::system/copyright.adoc[]
|
||||
|
||||
:leveloffset: -1
|
||||
19
doc/system/acknowledgements.adoc
Normal file
19
doc/system/acknowledgements.adoc
Normal file
@@ -0,0 +1,19 @@
|
||||
////
|
||||
Copyright 2003-2017 Beman Dawes
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#acknowledgments]
|
||||
# Acknowledgments
|
||||
:idprefix: ack_
|
||||
|
||||
Christopher Kohlhoff and Peter Dimov made important contributions to the
|
||||
design. Comments and suggestions were also received from Pavel Vozenilek,
|
||||
Gennaro Prota, Dave Abrahams, Jeff Garland, Iain Hanson, Oliver Kowalke, and
|
||||
Oleg Abrosimov. Christopher Kohlhoff suggested several improvements to the
|
||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2066.html[N2066]
|
||||
paper. Johan Nilsson's comments led to several of the refinements in N2066.
|
||||
62
doc/system/changes.adoc
Normal file
62
doc/system/changes.adoc
Normal file
@@ -0,0 +1,62 @@
|
||||
////
|
||||
Copyright 2018 Peter Dimov
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#changes]
|
||||
# Release History
|
||||
:idprefix:
|
||||
|
||||
## Changes in Boost 1.69
|
||||
|
||||
* Boost.System is now header-only. A stub library is still built for
|
||||
compatibility, but linking to it is no longer necessary.
|
||||
* Even more functions have been marked `constexpr`.
|
||||
* The destructor of `error_category` is now protected and no longer
|
||||
virtual. This is a _potentially breaking change_ but its impact
|
||||
is expected to be limited.
|
||||
* `error_category` now has a constructor that accepts a 64 bit identifier,
|
||||
enabling distinct category objects to compare equal.
|
||||
* The constructors of `error_category` are now protected.
|
||||
* A non-allocating, nonthrowing overload of `message` has been added.
|
||||
* A virtual function `failed` has been added, allowing categories for
|
||||
which success is not synonymous with 0.
|
||||
* The deprecated `boost::system::throws` object has been removed.
|
||||
* `boost::throws()` is now deprecated and its use is discouraged.
|
||||
* The constructor of `system_error` taking a single `error_code` argument
|
||||
is now explicit.
|
||||
* `system_error::code()` now returns by value.
|
||||
|
||||
## Changes in Boost 1.68
|
||||
|
||||
On a {cpp}14 compiler, many Boost.System functions and member functions
|
||||
are now `constexpr`, and `error_code` and `error_condition` are literal
|
||||
classes.
|
||||
|
||||
In addition to enabling use in constant expressions (and `constexpr`
|
||||
functions), this significantly improves the quality of the generated code.
|
||||
|
||||
As a result of this change, however, now using Boost.System from {cpp}14
|
||||
or {cpp}17 code requires that the library be also built with {cpp}14 or
|
||||
above. This is the default on GCC 6 and newer, but not on GCC 5 or Clang.
|
||||
One can build Boost for {cpp}14 by passing the `cxxstd=14` option to `b2`.
|
||||
|
||||
(Previous versions allowed code built against any {cpp} standard to link
|
||||
with Boost.System built against any {cpp} standard. In 1.68, code using
|
||||
any {cpp} standard can link with Boost.System built with {cpp}14 or above,
|
||||
but if Boost.System is built with {cpp}11 or below, only code also built
|
||||
with {cpp}11 and below can link to it successfully.)
|
||||
|
||||
## Changes in Boost 1.65
|
||||
|
||||
On a {cpp}11 compiler, Boost.System now provides implicit conversions
|
||||
from `boost::system::error_category`, `error_code`, and `error_condition`
|
||||
to their standard equivalents from `<system_error>`.
|
||||
|
||||
This allows libraries to expose a {cpp}11 interface and report errors
|
||||
via `std::error_code` even when using Boost.System, directly or through a
|
||||
dependency such as Boost.ASIO.
|
||||
19
doc/system/copyright.adoc
Normal file
19
doc/system/copyright.adoc
Normal file
@@ -0,0 +1,19 @@
|
||||
////
|
||||
Copyright 2018 Peter Dimov
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#copyright]
|
||||
# Copyright and License
|
||||
:idprefix:
|
||||
|
||||
This documentation is
|
||||
|
||||
* Copyright 2003-2017 Beman Dawes
|
||||
* Copyright 2018 Peter Dimov
|
||||
|
||||
and is distributed under the http://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].
|
||||
30
doc/system/history.adoc
Normal file
30
doc/system/history.adoc
Normal file
@@ -0,0 +1,30 @@
|
||||
////
|
||||
Copyright 2003-2017 Beman Dawes
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#history]
|
||||
# History
|
||||
:idprefix: history_
|
||||
|
||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1975.html[N1975],
|
||||
Filesystem Library Proposal for TR2, accepted for Library Technical
|
||||
Report 2 (TR2) at the Berlin meeting, included additional components to
|
||||
supplement the Standard Library's Diagnostics clause. Since then, these error
|
||||
reporting components have received wider public scrutiny and enhancements have
|
||||
been made to the design. The enhanced version has been used by
|
||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2054.pdf[N2054],
|
||||
Networking Library Proposal for TR2, demonstrating that these error reporting
|
||||
components are useful beyond the original Filesystem Library.
|
||||
|
||||
The original proposal viewed error categories as a binary choice between
|
||||
`errno` (i.e. POSIX-style) and the native operating system's error
|
||||
codes. The proposed components now allow as many additional error categories as
|
||||
are needed by either implementations or by users. The need to support additional
|
||||
error categories, for example, occurs in some networking library implementations
|
||||
because they are built on top of the POSIX `getaddrinfo` API that
|
||||
uses error codes not based on `errno`.
|
||||
50
doc/system/introduction.adoc
Normal file
50
doc/system/introduction.adoc
Normal file
@@ -0,0 +1,50 @@
|
||||
////
|
||||
Copyright 2003-2017 Beman Dawes
|
||||
Copyright 2018 Peter Dimov
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#introduction]
|
||||
# Introduction
|
||||
:idprefix: intro_
|
||||
|
||||
Error conditions originating from the operating system or other low-level
|
||||
application program interfaces (API's) are typically reported via an integer
|
||||
representing an error code. When these low-level API calls are wrapped in
|
||||
portable code, such as in a portable library, some users want to deal with the
|
||||
error codes in portable ways. Other users need to get at the system specific
|
||||
error codes, so they can deal with system specific needs. The Boost System
|
||||
library provides simple, light-weight `error_code` objects that encapsulate
|
||||
system-specific error code values, yet also provide access to more abstract
|
||||
and portable error conditions via `error_condition` objects.
|
||||
|
||||
Because `error_code` objects can represent errors from sources other than the
|
||||
operating system, including user-defined sources, each `error_code` and
|
||||
`error_condition` has an associated `error_category`.
|
||||
|
||||
An exception class, `system_error`, is provided. Derived from
|
||||
`std::runtime_error`, it captures the underlying `error_code` for the problem
|
||||
causing the exception so that this important information is not lost.
|
||||
|
||||
While exceptions are the preferred {cpp} default error code reporting
|
||||
mechanism, users of libraries dependent on low-level API's often need overloads
|
||||
reporting error conditions via error code arguments and/or return values rather
|
||||
than via throwing exceptions. Otherwise, when errors are not exceptional
|
||||
occurrences and must be dealt with as they arise, programs become littered with
|
||||
try/catch blocks, unreadable, and inefficient. The Boost System library
|
||||
supports both error reporting by exception and by error code.
|
||||
|
||||
In addition to portable errors codes and conditions supported by the
|
||||
`error_code.hpp` header, system-specific headers support the Cygwin, Linux,
|
||||
and Windows platforms. These headers are effectively no-ops if included for
|
||||
platforms other than their intended target.
|
||||
|
||||
Boost.System is part of the {cpp}11 Standard Library.
|
||||
A number of changes, particularly to names, were made by the C++ committee
|
||||
during standardization. The Boost implementation has been tracking those changes.
|
||||
See <<#ref_deprecated_names,Deprecated Names>> for synonyms provided to prevent
|
||||
breakage of existing user code.
|
||||
27
doc/system/rationale.adoc
Normal file
27
doc/system/rationale.adoc
Normal file
@@ -0,0 +1,27 @@
|
||||
////
|
||||
Copyright 2003-2017 Beman Dawes
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#rationale]
|
||||
# Design Rationale
|
||||
:idprefix: rationale_
|
||||
|
||||
`error_code` and `error_condition` are designed as value types so
|
||||
they can be copied without slicing and do not require heap allocation, but
|
||||
still have polymorphic behavior based on the error category. This is achieved
|
||||
by abstract base class `error_category` supplying the polymorphic behavior,
|
||||
and `error_code` and `error_condition` containing a pointer to an object of a
|
||||
type derived from `error_category`.
|
||||
|
||||
Many of the detailed design decisions were driven by the requirements that
|
||||
users to be able to add additional error categories, and that it be no more
|
||||
difficult to write portable code than system-specific code.
|
||||
|
||||
The `operator<<` overload for `error_code` eliminates a misleading conversion to
|
||||
`bool` in code like `cout << ec`, where `ec` is of type `error_code`. It is also
|
||||
useful in its own right.
|
||||
963
doc/system/reference.adoc
Normal file
963
doc/system/reference.adoc
Normal file
@@ -0,0 +1,963 @@
|
||||
////
|
||||
Copyright 2003-2017 Beman Dawes
|
||||
Copyright 2018 Peter Dimov
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#reference]
|
||||
# Reference
|
||||
:idprefix: ref_
|
||||
|
||||
## Use of {cpp}11 and {cpp}14 Features
|
||||
|
||||
The library is documented to use several {cpp}11 and {cpp}14 features,
|
||||
including `noexcept`, explicit conversion operators and `constexpr`. The
|
||||
actual implementation uses {cpp}11 and {cpp}14 features only when they are
|
||||
available, and otherwise falls back on {cpp}03 features.
|
||||
|
||||
## Macros
|
||||
|
||||
When `BOOST_SYSTEM_ENABLE_DEPRECATED` is defined, the library provides
|
||||
deprecated features for compatibility. These features are bound to eventually
|
||||
disappear.
|
||||
|
||||
When `BOOST_SYSTEM_USE_UTF8` is defined, on Windows the library returns
|
||||
UTF-8 messages using code page `CP_UTF8` instead of the default `CP_ACP`.
|
||||
This macro has no effect on POSIX.
|
||||
|
||||
## Deprecated Names
|
||||
|
||||
In the process of adding Boost.System to the {cpp}11 standard library, the
|
||||
{cpp} committee changed some names. To ease transition, Boost.System deprecates
|
||||
the old names, but will provide them when the macro `BOOST_SYSTEM_ENABLE_DEPRECATED` is defined.
|
||||
|
||||
|===
|
||||
|Old usage, now deprecated|Replacement
|
||||
|
||||
|`get_generic_category()`|`generic_category()`
|
||||
|`get_system_category()`|`system_category()`
|
||||
|`namespace posix`|`namespace errc`
|
||||
|`namespace posix_error`|`namespace errc`
|
||||
|`get_posix_category()`|`generic_category()`
|
||||
|`posix_category`|`generic_category()`
|
||||
|`errno_ecat`|`generic_category()`
|
||||
|`native_ecat`|`system_category()`
|
||||
|===
|
||||
|
||||
## <boost/system/error_code.hpp>
|
||||
|
||||
### Synopsis
|
||||
|
||||
```
|
||||
namespace boost {
|
||||
namespace system {
|
||||
|
||||
class error_category;
|
||||
|
||||
constexpr const error_category & system_category() noexcept;
|
||||
constexpr const error_category & generic_category() noexcept;
|
||||
|
||||
class error_code;
|
||||
class error_condition;
|
||||
|
||||
// "Concept" helpers
|
||||
|
||||
template<class T>
|
||||
struct is_error_code_enum { static const bool value = false; };
|
||||
|
||||
template<class T>
|
||||
struct is_error_condition_enum { static const bool value = false; };
|
||||
|
||||
// generic error conditions
|
||||
|
||||
namespace errc {
|
||||
enum errc_t
|
||||
{
|
||||
success = 0,
|
||||
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_synbolic_link_levels, //ELOOP
|
||||
value_too_large, //EOVERFLOW
|
||||
wrong_protocol_type //EPROTOTYPE
|
||||
};
|
||||
|
||||
} // namespace errc
|
||||
|
||||
template<> struct is_error_condition_enum<errc::errc_t>
|
||||
{ static const bool value = true; };
|
||||
|
||||
// non-member functions
|
||||
|
||||
constexpr bool operator==( const error_code & lhs,
|
||||
const error_code & rhs ) noexcept;
|
||||
bool operator==( const error_code & code,
|
||||
const error_condition & condition ) noexcept;
|
||||
bool operator==( const error_condition & condition,
|
||||
const error_code & code ) noexcept;
|
||||
constexpr bool operator==( const error_condition & lhs,
|
||||
const error_condition & rhs ) noexcept;
|
||||
|
||||
constexpr bool operator!=( const error_code & lhs,
|
||||
const error_code & rhs ) noexcept;
|
||||
bool operator!=( const error_code & code,
|
||||
const error_condition & condition ) noexcept;
|
||||
bool operator!=( const error_condition & condition,
|
||||
const error_code & code ) noexcept;
|
||||
constexpr bool operator!=( const error_condition & lhs,
|
||||
const error_condition & rhs ) noexcept;
|
||||
|
||||
constexpr bool operator<( const error_code & lhs,
|
||||
const error_code & rhs ) noexcept;
|
||||
constexpr bool operator<( const error_condition & lhs,
|
||||
const error_condition & rhs ) noexcept;
|
||||
|
||||
constexpr error_code make_error_code( errc::errc_t e ) noexcept;
|
||||
constexpr error_condition make_error_condition( errc::errc_t e ) noexcept;
|
||||
|
||||
template <class charT, class traits>
|
||||
std::basic_ostream<charT, traits>&
|
||||
operator<<( basic_ostream<charT, traits>& os, const error_code & ec );
|
||||
|
||||
std::size_t hash_value( const error_code & ec );
|
||||
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
```
|
||||
|
||||
The value of each `errc_t` constant is the same as the value of the `<cerrno>`
|
||||
macro shown in the above synopsis.
|
||||
|
||||
Users may specialize `is_error_code_enum` and `is_error_condition_enum`
|
||||
templates to indicate that a type is eligible for class `error_code` and
|
||||
`error_condition` automatic conversions respectively.
|
||||
|
||||
### Class error_category
|
||||
|
||||
The class `error_category` defines the base class for types used
|
||||
to identify the source and encoding of a particular category of error code.
|
||||
|
||||
Classes may be derived from `error_category` to support categories of
|
||||
errors in addition to those defined in Boost.System.
|
||||
|
||||
```
|
||||
namespace boost {
|
||||
namespace system {
|
||||
|
||||
class error_category
|
||||
{
|
||||
public: // noncopyable
|
||||
|
||||
error_category( error_category const & ) = delete;
|
||||
error_category& operator=( error_category const & ) = delete;
|
||||
|
||||
protected:
|
||||
|
||||
~error_category() = default;
|
||||
|
||||
constexpr error_category() noexcept;
|
||||
explicit constexpr error_category( unsigned long long id ) noexcept;
|
||||
|
||||
public:
|
||||
|
||||
virtual const char * name() const noexcept = 0;
|
||||
|
||||
virtual error_condition default_error_condition( int ev ) const noexcept;
|
||||
|
||||
virtual bool equivalent( int code, const error_condition & condition )
|
||||
const noexcept;
|
||||
virtual bool equivalent( const error_code & code, int condition )
|
||||
const noexcept;
|
||||
|
||||
virtual std::string message( int ev ) const = 0;
|
||||
virtual char const * message( int ev, char * buffer, std::size_t len )
|
||||
const noexcept;
|
||||
|
||||
virtual bool failed( int ev ) const noexcept;
|
||||
|
||||
constexpr bool operator==( const error_category & rhs ) const noexcept;
|
||||
constexpr bool operator!=( const error_category & rhs ) const noexcept;
|
||||
constexpr bool operator< ( const error_category & rhs ) const noexcept;
|
||||
|
||||
operator std::error_category const & () const;
|
||||
|
||||
private:
|
||||
|
||||
unsigned long long id_; // exposition only
|
||||
|
||||
};
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Constructors
|
||||
|
||||
```
|
||||
constexpr error_category() noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Effects: :: Initializes `id_` to 0.
|
||||
Remarks: :: Since equivalence for categories that do not have an identifier is
|
||||
based on comparing object addresses, a user-defined derived category of type
|
||||
`C` that uses this constructor should ensure that only one object of type `C`
|
||||
exists in the program.
|
||||
|
||||
```
|
||||
explicit constexpr error_category( unsigned long long id ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Effects: :: Initializes `id_` to `id`.
|
||||
Remarks: :: User-defined derived categories that use this constructor are considered
|
||||
equivalent when their identifiers match. Therefore, those categories may have more
|
||||
than one instance existing in a program, but to minimize the possibility of
|
||||
collision, their identifiers must be randomly chosen (at the time the category
|
||||
is implemented, not at runtime). One way of generating a 64 bit random identifier
|
||||
is https://www.random.org/cgi-bin/randbyte?nbytes=8&format=h.
|
||||
|
||||
#### Virtuals
|
||||
|
||||
```
|
||||
virtual const char * name() const noexcept = 0;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: In derived classes, a character literal naming the error category.
|
||||
|
||||
```
|
||||
virtual error_condition default_error_condition( int ev ) const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: ::
|
||||
- In derived classes, an error condition corresponding to `ev`.
|
||||
The returned error condition will typically come from the generic category.
|
||||
- In the default implementation, `error_condition( ev, *this )`.
|
||||
|
||||
```
|
||||
virtual bool equivalent( int code, const error_condition & condition )
|
||||
const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: ::
|
||||
- In derived classes, `true` when `error_code( code, *this )` is equivalent to `condition`.
|
||||
- In the default implementation, `default_error_condition( code ) == condition`.
|
||||
|
||||
```
|
||||
virtual bool equivalent( const error_code & code, int condition )
|
||||
const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: ::
|
||||
- In derived classes, `true` when `code` is equivalent to `error_condition( condition, *this )`.
|
||||
- In the default implementation, `*this == code.category() && code.value() == condition`.
|
||||
|
||||
```
|
||||
virtual std::string message( int ev ) const = 0;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: In derived classes, a string that describes the error denoted by `ev`.
|
||||
|
||||
```
|
||||
virtual char const * message( int ev, char * buffer, std::size_t len )
|
||||
const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Effects: ::
|
||||
** Derived classes should either
|
||||
*** return a pointer to a character literal describing the error denoted by `ev`, or
|
||||
*** copy a string describing the error into `buffer`, truncating it to `len-1`
|
||||
characters and storing a null terminator, and return `buffer`. If `len` is 0,
|
||||
nothing is copied, but the function still returns `buffer`. Note that
|
||||
when `len` is 0, `buffer` may be `nullptr`.
|
||||
** The default implementation calls `message(ev)` and copies the result into
|
||||
`buffer`, truncating it to `len-1` characters and storing a null terminator.
|
||||
If `len` is 0, copies nothing. Returns `buffer`. If `message(ev)` throws an
|
||||
exception, the string `"Message text unavailable"` is used.
|
||||
Example: ::
|
||||
+
|
||||
```
|
||||
const char* my_category::message(int ev, char* buffer, size_t len) const noexcept
|
||||
{
|
||||
switch(ev)
|
||||
{
|
||||
case 0: return "no error";
|
||||
case 1: return "voltage out of range";
|
||||
case 2: return "impedance mismatch";
|
||||
case 31:
|
||||
case 32:
|
||||
case 33:
|
||||
std::snprintf(buffer, len, "component %d failure", ev-30);
|
||||
return buffer;
|
||||
default:
|
||||
std::snprintf(buffer, len, "unknown error %d", ev);
|
||||
return buffer;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```
|
||||
virtual bool failed( int ev ) const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: ::
|
||||
- In derived classes, `true` when `ev` represents a failure.
|
||||
- In the default implementation, `ev != 0`.
|
||||
Remarks: ::
|
||||
All calls to this function with the same `ev` must return the same value.
|
||||
|
||||
#### Nonvirtuals
|
||||
|
||||
```
|
||||
constexpr bool operator==( const error_category & rhs ) const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `rhs.id_ == 0? this == &rhs: id_ == rhs.id_`.
|
||||
Remarks: :: Two category objects are considered equivalent when they have matching
|
||||
nonzero identifiers, or are the same object.
|
||||
|
||||
```
|
||||
constexpr bool operator!=( const error_category & rhs ) const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `!( *this == rhs )`.
|
||||
|
||||
```
|
||||
constexpr bool operator< ( const error_category & rhs ) const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: ::
|
||||
** If `id_ < rhs.id_`, `true`;
|
||||
** Otherwise, if `id_ > rhs.id_`, `false`;
|
||||
** Otherwise, if `rhs.id_ != 0`, `false`;
|
||||
** Otherwise, `std::less<error_category const *>()( this, &rhs )`.
|
||||
|
||||
```
|
||||
operator std::error_category const & () const;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: A reference to an `std::error_category` object corresponding
|
||||
to `*this`.
|
||||
|
||||
### Predefined Categories
|
||||
|
||||
```
|
||||
constexpr const error_category & system_category() noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: A reference to an `error_category` object identifying errors
|
||||
originating from the operating system.
|
||||
|
||||
```
|
||||
constexpr const error_category & generic_category() noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: A reference to an `error_category` object identifying portable
|
||||
error conditions.
|
||||
|
||||
### Class error_code
|
||||
|
||||
The class `error_code` describes an object used to hold error code
|
||||
values, such as those originating from the operating system or other
|
||||
low-level application program interfaces. It's an adjunct to error reporting
|
||||
by exception.
|
||||
|
||||
```
|
||||
namespace boost {
|
||||
namespace system {
|
||||
|
||||
class error_code {
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
|
||||
constexpr error_code() noexcept;
|
||||
constexpr error_code( int val, const error_category & cat ) noexcept;
|
||||
|
||||
template <class ErrorCodeEnum>
|
||||
constexpr error_code( ErrorCodeEnum e ) noexcept;
|
||||
|
||||
// modifiers:
|
||||
|
||||
constexpr void assign( int val, const error_category & cat ) noexcept;
|
||||
|
||||
template<typename ErrorCodeEnum>
|
||||
constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;
|
||||
|
||||
constexpr void clear() noexcept;
|
||||
|
||||
// observers:
|
||||
|
||||
constexpr int value() const noexcept;
|
||||
constexpr const error_category & category() const noexcept;
|
||||
|
||||
error_condition default_error_condition() const noexcept;
|
||||
|
||||
std::string message() const;
|
||||
char const * message( char * buffer, std::size_t len ) const noexcept;
|
||||
|
||||
constexpr bool failed() const noexcept;
|
||||
constexpr explicit operator bool() const noexcept;
|
||||
|
||||
operator std::error_code() const;
|
||||
|
||||
private: // exposition only
|
||||
|
||||
int val_;
|
||||
const error_category * cat_;
|
||||
|
||||
};
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Constructors
|
||||
|
||||
```
|
||||
constexpr error_code() noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == 0`; `*cat_ == system_category()`.
|
||||
|
||||
```
|
||||
constexpr error_code( int val, const error_category & cat ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == val`; `cat_ == &cat`.
|
||||
|
||||
```
|
||||
template <class ErrorCodeEnum>
|
||||
constexpr error_code( ErrorCodeEnum e ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `*this == make_error_code( e )`.
|
||||
Remarks: :: This constructor is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
|
||||
|
||||
#### Modifiers
|
||||
|
||||
```
|
||||
constexpr void assign( int val, const error_category & cat ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == val`; `cat_ == &cat`.
|
||||
|
||||
```
|
||||
template<typename ErrorCodeEnum>
|
||||
constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `*this == make_error_code( e )`.
|
||||
Remarks: :: This operator is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
|
||||
|
||||
```
|
||||
constexpr void clear() noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == 0`; `*cat_ == system_category()`.
|
||||
|
||||
#### Observers
|
||||
|
||||
```
|
||||
constexpr int value() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `val_`.
|
||||
|
||||
```
|
||||
constexpr const error_category & category() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `*cat_`.
|
||||
|
||||
```
|
||||
error_condition default_error_condition() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `cat_\->default_error_condition( val_ )`.
|
||||
|
||||
```
|
||||
std::string message() const;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `cat_\->message( val_ )`.
|
||||
|
||||
```
|
||||
char const * message( char * buffer, std::size_t len ) const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `cat_\->message( val_, buffer, len )`.
|
||||
|
||||
```
|
||||
constexpr bool failed() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `cat_\->failed( val_ )`.
|
||||
|
||||
```
|
||||
constexpr explicit operator bool() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `failed()`.
|
||||
|
||||
```
|
||||
operator std::error_code() const;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `std::error_code( val_, *cat_ )`.
|
||||
|
||||
### Class error_condition
|
||||
|
||||
```
|
||||
namespace boost {
|
||||
namespace system {
|
||||
|
||||
class error_condition {
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
|
||||
constexpr error_condition() noexcept;
|
||||
constexpr error_condition( int val, const error_category & cat ) noexcept;
|
||||
|
||||
template <class ErrorConditionEnum>
|
||||
constexpr error_condition( ErrorConditionEnum e ) noexcept;
|
||||
|
||||
// modifiers:
|
||||
|
||||
constexpr void assign( int val, const error_category & cat ) noexcept;
|
||||
|
||||
template<typename ErrorConditionEnum>
|
||||
constexpr error_condition & operator=( ErrorConditionEnum e ) noexcept;
|
||||
|
||||
constexpr void clear() noexcept;
|
||||
|
||||
// observers:
|
||||
|
||||
constexpr int value() const noexcept;
|
||||
constexpr const error_category & category() const noexcept;
|
||||
|
||||
std::string message() const;
|
||||
char const * message( char * buffer, std::size_t len ) const noexcept;
|
||||
|
||||
constexpr bool failed() const noexcept;
|
||||
constexpr explicit operator bool() const noexcept;
|
||||
|
||||
operator std::error_condition() const;
|
||||
|
||||
private: // exposition only
|
||||
|
||||
int val_;
|
||||
const error_category * cat_;
|
||||
|
||||
};
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Constructors
|
||||
|
||||
```
|
||||
constexpr error_condition() noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == 0`; `*cat_ == generic_category()`.
|
||||
|
||||
```
|
||||
constexpr error_condition( int val, const error_category & cat ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == val`; `cat_ == &cat`.
|
||||
|
||||
```
|
||||
template <class ErrorConditionEnum>
|
||||
constexpr error_condition( ErrorConditionEnum e ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `*this == make_error_condition( e )`.
|
||||
Remarks: :: This constructor is only enabled when `is_error_condition_enum<ErrorConditionEnum>::value` is `true`.
|
||||
|
||||
#### Modifiers
|
||||
|
||||
```
|
||||
constexpr void assign( int val, const error_category & cat ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == val`; `cat_ == &cat`.
|
||||
|
||||
```
|
||||
template <class ErrorConditionEnum>
|
||||
constexpr error_condition & operator=( ErrorConditionEnum e ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `*this == make_error_condition( e )`.
|
||||
Remarks: :: This operator is only enabled when `is_error_condition_enum<ErrorConditionEnum>::value` is `true`.
|
||||
|
||||
```
|
||||
constexpr void clear() noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `val_ == 0`; `*cat_ == generic_category()`.
|
||||
|
||||
#### Observers
|
||||
|
||||
```
|
||||
constexpr int value() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `val_`.
|
||||
|
||||
```
|
||||
constexpr const error_category & category() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `*cat_`.
|
||||
|
||||
```
|
||||
std::string message() const;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `cat_\->message( val_ )`.
|
||||
|
||||
```
|
||||
char const * message( char * buffer, std::size_t len ) const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `cat_\->message( val_, buffer, len )`.
|
||||
|
||||
```
|
||||
constexpr bool failed() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `cat_\->failed( val_ )`.
|
||||
|
||||
```
|
||||
constexpr explicit operator bool() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `failed()`.
|
||||
|
||||
```
|
||||
operator std::error_condition() const;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `std::error_condition( val_, *cat_ )`.
|
||||
|
||||
### Nonmember functions
|
||||
|
||||
```
|
||||
constexpr bool operator==( const error_code & lhs,
|
||||
const error_code & rhs ) noexcept;
|
||||
constexpr bool operator==( const error_condition & lhs,
|
||||
const error_condition & rhs ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `lhs.value() == rhs.value() && lhs.category() == rhs.category()`.
|
||||
|
||||
```
|
||||
bool operator==( const error_code & code,
|
||||
const error_condition & condition ) noexcept;
|
||||
bool operator==( const error_condition & condition,
|
||||
const error_code & code ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() )`.
|
||||
|
||||
```
|
||||
constexpr bool operator!=( const error_code & lhs,
|
||||
const error_code & rhs ) noexcept;
|
||||
constexpr bool operator!=( const error_condition & lhs,
|
||||
const error_condition & rhs ) noexcept;
|
||||
bool operator!=( const error_code & code,
|
||||
const error_condition & condition ) noexcept;
|
||||
bool operator!=( const error_condition & condition,
|
||||
const error_code & code ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `!( lhs == rhs )`.
|
||||
|
||||
```
|
||||
constexpr bool operator<( const error_code & lhs,
|
||||
const error_code & rhs ) noexcept;
|
||||
constexpr bool operator<( const error_condition & lhs,
|
||||
const error_condition & rhs ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `lhs.category() < rhs.category() || ( lhs.category() == rhs.category() && lhs.value() < rhs.value() )`.
|
||||
|
||||
```
|
||||
constexpr error_code make_error_code( errc::errc_t e ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `error_code( e, generic_category() )`.
|
||||
|
||||
```
|
||||
constexpr error_condition make_error_condition( errc::errc_t e ) noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `error_condition( e, generic_category() )`.
|
||||
|
||||
```
|
||||
template <class charT, class traits>
|
||||
std::basic_ostream<charT, traits>&
|
||||
operator<<( basic_ostream<charT, traits>& os, const error_code & ec );
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Effects: :: `os << ec.category().name() << ':' << ec.value()`.
|
||||
Returns: :: `os`.
|
||||
|
||||
```
|
||||
std::size_t hash_value( const error_code & ec );
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: A hash value representing `ec`.
|
||||
|
||||
## <boost/system/system_error.hpp>
|
||||
|
||||
### Class system_error
|
||||
|
||||
The class `system_error` describes an exception object used to
|
||||
report errors that have an associated `error_code`. Such errors
|
||||
typically originate from operating system or other low-level
|
||||
application program interfaces.
|
||||
|
||||
```
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
class system_error: public std::runtime_error
|
||||
{
|
||||
public:
|
||||
|
||||
explicit system_error( error_code ec );
|
||||
system_error( error_code ec, const char * what_arg );
|
||||
system_error( error_code ec, const std::string & what_arg );
|
||||
|
||||
system_error( int ev, const error_category & ecat );
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const char * what_arg );
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const std::string & what_arg );
|
||||
|
||||
error_code code() const noexcept;
|
||||
const char * what() const noexcept;
|
||||
};
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Constructors
|
||||
|
||||
```
|
||||
explicit system_error( error_code ec );
|
||||
system_error( error_code ec, const char * what_arg );
|
||||
system_error( error_code ec, const std::string & what_arg );
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `code() == ec`.
|
||||
|
||||
```
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const char * what_arg );
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const std::string & what_arg );
|
||||
system_error( int ev, const error_category & ecat );
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Ensures: :: `code() == error_code( ev, ecat )`.
|
||||
|
||||
#### Observers
|
||||
|
||||
```
|
||||
error_code code() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: `ec` or `error_code( ev, ecat )`, from the constructor, as appropriate.
|
||||
|
||||
```
|
||||
const char * what() const noexcept;
|
||||
```
|
||||
[none]
|
||||
* {blank}
|
||||
+
|
||||
Returns: :: A null-terminated character string incorporating the arguments supplied
|
||||
in the constructor, typically of the form `what_arg + ": " + code.message()`.
|
||||
@@ -50,6 +50,11 @@ inline std::string generic_error_category_message( int ev )
|
||||
# if defined( BOOST_MSVC )
|
||||
# pragma warning( push )
|
||||
# pragma warning( disable: 4996 )
|
||||
# elif defined(__clang__) && defined(__has_warning)
|
||||
# pragma clang diagnostic push
|
||||
# if __has_warning("-Wdeprecated-declarations")
|
||||
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||||
# endif
|
||||
# endif
|
||||
|
||||
inline std::string generic_error_category_message( int ev )
|
||||
@@ -83,6 +88,8 @@ inline char const * generic_error_category_message( int ev, char * buffer, std::
|
||||
|
||||
# if defined( BOOST_MSVC )
|
||||
# pragma warning( pop )
|
||||
# elif defined(__clang__) && defined(__has_warning)
|
||||
# pragma clang diagnostic pop
|
||||
# endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -170,6 +170,7 @@ inline std::string system_category_message_win32( int ev )
|
||||
}
|
||||
|
||||
local_free lf_ = { lpMsgBuf };
|
||||
(void)lf_;
|
||||
|
||||
UINT_ const code_page = message_cp_win32();
|
||||
|
||||
|
||||
@@ -205,16 +205,16 @@ protected:
|
||||
|
||||
#endif
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 )
|
||||
{
|
||||
}
|
||||
|
||||
explicit BOOST_SYSTEM_CONSTEXPR error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id )
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 )
|
||||
{
|
||||
}
|
||||
|
||||
virtual const char * name() const BOOST_NOEXCEPT = 0;
|
||||
|
||||
virtual error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
|
||||
@@ -278,7 +278,8 @@ public:
|
||||
|
||||
// clang++ 3.8 and below: initialization of const object
|
||||
// requires a user-provided default constructor
|
||||
BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT: error_category( 0xB2AB117A257EDF0Dull )
|
||||
BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT:
|
||||
error_category( ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDF0D )
|
||||
{
|
||||
}
|
||||
|
||||
@@ -295,7 +296,8 @@ class BOOST_SYMBOL_VISIBLE system_error_category: public error_category
|
||||
{
|
||||
public:
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT: error_category( 0x8FAFD21E25C5E09Bull )
|
||||
BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT:
|
||||
error_category( ( boost::ulong_long_type( 0x8FAFD21E ) << 32 ) + 0x25C5E09B )
|
||||
{
|
||||
}
|
||||
|
||||
@@ -651,7 +653,7 @@ public:
|
||||
return failed_? unspecified_bool_true: 0;
|
||||
}
|
||||
|
||||
BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error
|
||||
BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error
|
||||
{
|
||||
return !failed_;
|
||||
}
|
||||
@@ -746,7 +748,7 @@ inline bool operator!=( const error_code & lhs, const error_condition & rhs ) BO
|
||||
|
||||
inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT
|
||||
{
|
||||
return condition.category().equivalent( code, condition.value() ) || code.category().equivalent( code.value(), condition );
|
||||
return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
|
||||
}
|
||||
|
||||
inline bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_NOEXCEPT
|
||||
@@ -773,8 +775,8 @@ inline std::size_t hash_value( error_code const & ec )
|
||||
id = reinterpret_cast<boost::ulong_long_type>( &cat );
|
||||
}
|
||||
|
||||
boost::ulong_long_type hv = 0xCBF29CE484222325ull;
|
||||
boost::ulong_long_type const prime = 0x00000100000001B3ull;
|
||||
boost::ulong_long_type hv = ( boost::ulong_long_type( 0xCBF29CE4 ) << 32 ) + 0x84222325;
|
||||
boost::ulong_long_type const prime = ( boost::ulong_long_type( 0x00000100 ) << 32 ) + 0x000001B3;
|
||||
|
||||
// id
|
||||
|
||||
@@ -847,6 +849,11 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
|
||||
# if defined( BOOST_MSVC )
|
||||
# pragma warning( push )
|
||||
# pragma warning( disable: 4996 )
|
||||
# elif defined(__clang__) && defined(__has_warning)
|
||||
# pragma clang diagnostic push
|
||||
# if __has_warning("-Wdeprecated-declarations")
|
||||
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||||
# endif
|
||||
# endif
|
||||
|
||||
std::strncpy( buffer, m.c_str(), len - 1 );
|
||||
@@ -854,6 +861,8 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
|
||||
|
||||
# if defined( BOOST_MSVC )
|
||||
# pragma warning( pop )
|
||||
# elif defined(__clang__) && defined(__has_warning)
|
||||
# pragma clang diagnostic pop
|
||||
# endif
|
||||
|
||||
return buffer;
|
||||
|
||||
@@ -24,7 +24,7 @@ namespace boost
|
||||
// library can be caught. See svn.boost.org/trac/boost/ticket/3697
|
||||
{
|
||||
public:
|
||||
system_error( error_code ec )
|
||||
explicit system_error( error_code ec )
|
||||
: std::runtime_error(""), m_error_code(ec) {}
|
||||
|
||||
system_error( error_code ec, const std::string & what_arg )
|
||||
@@ -46,8 +46,8 @@ namespace boost
|
||||
|
||||
virtual ~system_error() BOOST_NOEXCEPT_OR_NOTHROW {}
|
||||
|
||||
const error_code & code() const BOOST_NOEXCEPT_OR_NOTHROW { return m_error_code; }
|
||||
const char * what() const BOOST_NOEXCEPT_OR_NOTHROW;
|
||||
error_code code() const BOOST_NOEXCEPT { return m_error_code; }
|
||||
const char * what() const BOOST_NOEXCEPT_OR_NOTHROW;
|
||||
|
||||
private:
|
||||
error_code m_error_code;
|
||||
|
||||
17
index.html
17
index.html
@@ -1,14 +1,15 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=doc/index.html">
|
||||
<meta http-equiv="refresh" content="0; URL=doc/html/system.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="doc/index.html">doc/index.html</a>.
|
||||
<hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2003</p>
|
||||
<p> Distribution under the Boost Software License, Version 1.0.
|
||||
(See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
|
||||
www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
<a href="doc/html/system.html">doc/html/system.html</a>.
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
<!--
|
||||
<09> Copyright Beman Dawes, 2001
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
-->
|
||||
|
||||
@@ -132,3 +132,5 @@ system-run- failed_constexpr_test.cpp ;
|
||||
|
||||
# Quick (CI) test
|
||||
run quick.cpp ;
|
||||
|
||||
run quick.cpp : : : <warnings>all <warnings-as-errors>on : warnings_test ;
|
||||
|
||||
Reference in New Issue
Block a user