boost-react-native-bundle

<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"> System Library </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"> Contents</td> </tr> <tr> <td width="100%" bgcolor="#E8F5FF"> <a href="#Introduction">Introduction</a> <a href="#C++11">C++11</a> <a href="#Macros">Macros</a> <a href="#Deprecated-names">Deprecated names</a> <a href="#Breaking-changes">Breaking changes</a> <a href="#Header-error_code">Header <boost/system/error_code.hpp></a> <a href="#Class-error_category">Class <code>error_category</code></a>    <a href="#Class-error_category-synopsis">Class <code>error_category</code> synopsis</a>    <a href="#Class-error_category-virtual-members">Class <code>error_category</code> virtual members</a>    <a href="#Class-error_category-non-virtual-members">Class <code>error_category</code> non-virtual members</a>    <a href="#Class-error_category-non-member-functions">Class <code>error_category</code> non-member functions</a>    <a href="#Class-error_category-predefined-objects">Class <code>error_category</code> predefined objects</a> <a href="#Class-error_code">Class <code>error_code</code></a>    <a href="#Class-error_code-synopsis">Class <code>error_code</code> synopsis</a>    <a href="#Class-error_code-constructors">Class <code>error_code</code> constructors</a>    <a href="#Class-error_code-modifiers">Class <code>error_code</code> modifiers</a>    <a href="#Class-error_code-observers">Class <code>error_code</code> observers</a> <a href="#Class-error_condition">Class <code>error_condition</code></a>    <a href="#Class-error_condition-synopsis">Class <code>error_condition</code> synopsis</a>    <a href="#Class-error_condition-constructors">Class <code>error_condition</code> constructors</a>    <a href="#Class-error_condition-modifiers">Class <code>error_condition</code> modifiers</a>    <a href="#Class-error_condition-observers">Class <code>error_condition</code> observers</a> <a href="#throws-object"><code>throws</code> object</a> <a href="#Semantics-of-throws">Semantics of <code>throws</code> object</a> <a href="#Non-member-functions">Non-member functions</a> <a href="#Header-system_error">Header <boost/system/system_error.hpp></a>    <a href="#Class-system_error">Class <code>system_error</code></a> </td> </tr> </table> <h2><a name="Introduction">Introduction</a></h2> 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. Boost.System library components never change the value of <code> errno</code>. <h2><a name="C++11">C++11</a></h2> 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. <h2><a name="Macros">Macros</a></h2> Users may defined the following macros if desired. Sensible defaults are provided, so users may ignore these macros if they prefer. <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" height="368"> <tr> <td height="16">Macro Name</td> <td height="16">Default</td> <td height="16">Effect if defined</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_NO_DEPRECATED</code></td> <td valign="top" height="32">Not defined.</td> <td valign="top" height="32">Deprecated features are excluded.</td> </tr> </table> <h2><a name="Deprecated-names">Deprecated names</a></h2> In the process of adding Boost.System to C++0x standard library, the C++ committee changed some names. To ease transition, Boost.System deprecates the old names, but continues to provide them unless macro <code>BOOST_SYSTEM_NO_DEPRECATED</code> is defined. <table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111"> <tr> <td>Old usage, now deprecated</td> <td>Replacement</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> 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. <table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111"> <tr> <td>Old usage, now broken</td> <td>Replacement</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> User-defined BOOST_POSIX_API and BOOST_WINDOWS_API macros are no longer supported. <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 ); } }</pre> </blockquote> 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. 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. <pre>const error_category & <a name="system_category">system_category</a>();</pre> <blockquote> Returns: A reference to a <code>error_category</code> object identifying errors originating from the operating system. </blockquote> <pre>const error_category & <a name="generic_category">generic_category</a>();</pre> <blockquote> Returns: A reference to a <code>error_category</code> object identifying portable error conditions. </blockquote> <h2><a name="Class-error_category">Class <code>error_category</code></a></h2> 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. [Note: Classes may be derived from <code>error_category</code> to support additional categories of errors. --end note] 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. [ Note: <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. �end note ] <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> Classes derived from <code>error_category</code> shall behave as specified in this subclause. <pre>virtual const char * name() const noexcept =0;</pre> <blockquote> Returns: a string naming the error category. </blockquote> <pre>virtual string message( int ev ) const noexcept =0;</pre> <blockquote> Returns: A string that describes the error denoted by <code>ev</code>. </blockquote> <pre>virtual error_condition default_error_condition( int ev ) const noexcept;</pre> <blockquote> Returns:  <code>error_condition( ev, *this )</code>. <blockquote>  [--Note: 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. --end note] </blockquote> </blockquote> <pre>virtual bool equivalent( int code, const error_condition & condition ) const noexcept;</pre> <blockquote> Returns: <code>default_error_condition( code ) == condition</code>. </blockquote> <pre>virtual bool equivalent( const error_code & code, int condition ) const noexcept;</pre> <blockquote> Returns: <code>*this == code.category() && code.value() == condition</code>. </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> Returns: <code>this == &rhs</code>. </blockquote> <pre>bool operator!=( const error_category & rhs ) const noexcept;</pre> <blockquote> Returns: <code>this != &rhs</code>. </blockquote> <pre>bool operator<( const error_category & rhs ) const noexcept;</pre> <blockquote> Returns: <code>std::less<const error_category*>()( this, &rhs  noexcept)</code>. <blockquote> [Note: <code>std::less</code> provides a total ordering for pointers. --end note] </blockquote> </blockquote> <h2><a name="Class-error_code">Class <code> error_code</code></a></h2> The class <code>error_code</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. [ Note: Class <code>error_code</code> is an adjunct to error reporting by exception. �end note ] <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_; // exposition only const error_category * cat_; // exposition only }; } }</pre> </blockquote> <h3><a name="Class-error_code-constructors">Class <code> error_code</code> constructors</a></h3> <pre>error_code() noexcept;</pre> <blockquote> Effects: Constructs an object of type <code>error_code</code>. Postconditions: <code>val_ == 0 && cat_ == &system_category()</code>. </blockquote> <pre>error_code( int val, const error_category & cat ) noexcept;</pre> <blockquote> Effects: Constructs an object of type <code>error_code</code>. Postconditions: <code>val_ == val && cat_ == &cat</code>. </blockquote> <pre>template <class <code>ErrorCodeEnum</code>> error_code(<code> ErrorCodeEnum</code> val ) noexcept;</pre> <blockquote> Effects: Constructs an object of type <code>error_code</code>. Postconditions: <code>*this == make_error_code( val )</code>. Remarks: This constructor shall not participate in overload resolution unless <code>is_error_code_enum<ErrorCodeEnum>::value</code> is <code>true</code>. </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> Postconditions: <code>val_ == val && cat_ == &cat</code>. </blockquote> <pre>template<typename <code>ErrorCodeEnum</code>> error_code & operator=( <code>ErrorCodeEnum</code> val ) noexcept;</pre> <blockquote> Postconditions: <code>*this == make_error_code( val )</code>. Remarks: This operator shall not participate in overload resolution unless <code>is_error_code_enum<ErrorCodeEnum>::value</code> is <code>true</code>. </blockquote> <pre><code>void clear() noexcept;</code></pre> <blockquote> postcondition: <code>value() == 0 && category() == system_category()</code> </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> Returns: <code>val_</code>. </blockquote> <pre><code>const error_category & category() const noexcept;</code></pre> <blockquote> Returns: <code>*cat_</code>. </blockquote> <pre>error_condition default_error_condition() const noexcept;</pre> <blockquote> Returns:  <code>category().default_error_condition( value())</code>. </blockquote> <pre><code>string message() const;</code></pre> <blockquote> Returns:  <code>category().message( value())</code>. Throws: Nothing. </blockquote> <pre>operator unspecified-bool-type() const;</pre> <blockquote> Returns: 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>. Throws: nothing. [Note: 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. --end note ] </blockquote> <h2><a name="Class-error_condition">Class <code>error_condition</code></a></h2> The class <code>error_condition</code> describes an object used to hold values identifying error conditions. [ Note: <code>error_condition</code> values are portable abstractions, while <code>error_code</code> values are implementation specific. --end note ] <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_; // exposition only const error_category * cat_; // exposition only }; } }</pre> </blockquote> <h3><a name="Class-error_condition-constructors">Class <code>error_condition</code> constructors</a></h3> <pre>error_condition() noexcept; </pre> <blockquote> Effects: Constructs an object of type <code>error_condition</code>. Postconditions: <code>val_ == 0 and cat_ == &generic_category()</code>. </blockquote> <pre>error_condition( int val, const error_category & cat ) noexcept;</pre> <blockquote> Effects: Constructs an object of type error_condition. Postconditions: <code>val_ == val and cat_ == &cat</code>. </blockquote> <pre>template <class ErrorConditionEnum> error_condition( ErrorConditionEnum e ) noexcept;</pre> <blockquote> Effects: Constructs an object of type <code>error_condition</code>. Postconditions: <code>*this == make_error_condition(e)</code>. Remarks: This constructor shall not participate in overload resolution unless <code>is_error_condition_enum<ErrorConditionEnum>::value</code> is <code>true</code>. </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> Postconditions: <code>val_ == val and cat_ == &cat</code>. </blockquote> <pre>template<typename ErrorConditionEnum> error_condition & operator=( ErrorConditionEnum e ) noexcept;</pre> <blockquote> Postconditions: <code>*this == make_error_condition( e )</code>. Returns: <code>*this</code>. Remarks: This operator shall not participate in overload resolution unless <code>is_error_condition_enum<ErrorConditionEnum>::value</code> is <code>true</code>. </blockquote> <pre>void clear() noexcept;</pre> <blockquote> Postcondition: <code>value() == 0 && category() == generic_category()</code> </blockquote> <h3><a name="Class-error_condition-observers">Class <code>error_condition</code> observers</a></h3> <pre>int value() const noexcept;</pre> <blockquote> Returns: <code>val_</code>. </blockquote> <pre>const error_category & category() const noexcept;</pre> <blockquote> Returns: <code>*cat_</code>. </blockquote> <pre>string message() const;</pre> <blockquote> Returns: <code>category().message( value() )</code>. </blockquote> <pre>operator unspecified-bool-type () const;</pre> <blockquote> Returns: 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>. Throws: Nothing.  [ Note: 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. --end note ] </blockquote> <h2><a name="throws-object"><code>throws</code> object</a></h2> <pre>extern error_code throws;</pre> The predefined <code>error_code</code> object <code>throws</code> is supplied for use as a "throw on error" tag. <h2><a name="Semantics-of-throws">Semantics of <code>throws</code></a> object</h2> Functions that specify an argument in the form <code>error_code& ec=throws</code>, with appropriate namespace qualifiers, have the following error handling semantics: <blockquote> Postconditions: <blockquote> If <code>&ec != &throws</code> and an error occurred: <ul> <li> <code>ec.value()</code> returns the implementation specific error number for the particular error that occurred.</li> <li><code>ec.category()</code> returns the <code> <a href="#Class-error_category">error_category</a></code> for <code>ec.value()</code>.</li> </ul> if <code>&ec != &throws</code> and an error did not occur, <code>ec.clear()</code>. </blockquote> Throws: <blockquote> If an error occurs and <code>&ec == &throws</code>, throws an exception of type <code><a href="#Class-system_error">system_error</a></code> or of a type derived from <code><a href="#Class-system_error">system_error</a></code>. The exception's <code>code()</code> member function returns a reference to an <code>error_code</code> object with the behavior specified in Postconditions. </blockquote> </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> Returns: <code>lhs.category() == rhs.category() && lhs.value() == rhs.value()</code>. </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> Returns: <code>code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() )</code>. </blockquote> <pre>bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre> <blockquote> Returns: <code>lhs.category() == rhs.category() && lhs.value() == rhs.value()</code>. </blockquote> <pre>bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept;</pre> <blockquote> Returns: <code>!(lhs == rhs )</code>. </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> Returns:<code> !( code ==  condition )</code>. </blockquote> <pre>bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre> <blockquote> Returns: <code>!(lhs == rhs )</code>. </blockquote> <pre>bool operator<( const error_code & lhs, const error_code & rhs ) noexcept;</pre> <blockquote> Returns: <code>lhs.category() < rhs.category()   || (lhs.category() == rhs.category() && lhs.value() < rhs.value())</code>. </blockquote> <pre>bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre> <blockquote> Returns: <code>lhs.category() < rhs.category()   || (lhs.category() == rhs.category() && lhs.value() < rhs.value())</code>. </blockquote> <pre>error_code make_error_code( errc::errc_t e ) noexcept;</pre> <blockquote> Returns: <code>error_code( e, generic_category())</code>. </blockquote> <pre>error_condition make_error_condition( errc::errc_t e ) noexcept;</pre> <blockquote> Returns: <code>error_condition( static_cast<int>( e ), generic_category())</code>. </blockquote> <pre>template <class charT, class traits> std::basic_ostream<charT,traits>& operator<<( basic_ostream<charT,traits>& os, const error_code & ec );</pre> <blockquote> Effects: <code>os << ec.category().name() << ':' << ec.value()</code>. Returns: <code>os</code>. </blockquote> <pre>size_t <a name="hash_value">hash_value</a>( const error_code & ec );</pre> <blockquote> Returns:  A hash value representing <code>ec</code>. </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> 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. <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> Effects: Constructs an object of class <code>system_error</code>. Postcondition: <code>code() == ec   && std::strcmp( this->runtime_error::what(), "" ) == 0</code> </blockquote> <pre>system_error( error_code ec, const char * what_arg );</pre> <blockquote> Effects: Constructs an object of class <code>system_error</code>. Postcondition: <code>code() == ec   && std::strcmp( this->runtime_error::what(), what_arg ) == 0</code> </blockquote> <pre>system_error( error_code ec, const std::string & what_arg );</pre> <blockquote> Effects: Constructs an object of class <code>system_error</code>. Postcondition: <code>code() == ec   && std::strcmp( this->runtime_error::what(), what_arg.c_str() ) == 0</code> </blockquote> <pre>system_error( int ev, const error_category & ecat, const char * what_arg );</pre> <blockquote> Effects: Constructs an object of class <code>system_error</code>. Postcondition: <code>code() == error_code( ev, ecat )   && std::strcmp( this->runtime_error::what(), what_arg ) == 0</code> </blockquote> <pre>system_error( int ev, const error_category & ecat, const std::string & what_arg );</pre> <blockquote> Effects: Constructs an object of class <code>system_error</code>. Postcondition: <code>code() == error_code( ev, ecat )   && std::strcmp( this->runtime_error::what(), what_arg.c_str() ) == 0</code> </blockquote> <pre>system_error( int ev, const error_category & ecat );</pre> <blockquote> Effects: Constructs an object of class <code>system_error</code>. Postcondition: <code>code() == error_code( ev, ecat )   && std::strcmp( this->runtime_error::what(), "" ) == 0</code> </blockquote> <pre>const error_code & code() const;</pre> <blockquote> Returns: <code>ec</code> or <code>error_code( ev, ecat )</code>, from the constructor, as appropriate. </blockquote> <pre>const char * what() const;</pre> <blockquote> Returns: A string incorporating <code> this->runtime_error::what()</code> and <code> code.message()</code>. </blockquote> <hr> Revised January 06, 2014 � Copyright Beman Dawes, 2006, 2007, 2008, 2013 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> </body> </html>