mirror of
https://github.com/boostorg/system.git
synced 2025-07-29 20:17:13 +02:00
Compare commits
4 Commits
boost-1.41
...
boost-1.44
| Author | SHA1 | Date | |
|---|---|---|---|
| ef7d9df03b | |||
| 7ffc036bc2 | |||
| 6888c0c7b8 | |||
| eeb5844852 |
@ -6,7 +6,7 @@
|
||||
<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/html/minimal.css">
|
||||
<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
@ -93,6 +93,18 @@ supports both error reporting by exception and by error code.</p>
|
||||
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 will become part of the C++0x 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="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
|
||||
@ -133,7 +145,7 @@ 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 -->February 23, 2008<!--webbot bot="Timestamp" endspan i-checksum="41408" --> </font>
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->May 28, 2010<!--webbot bot="Timestamp" endspan i-checksum="11241" --> </font>
|
||||
</p>
|
||||
|
||||
<p><EFBFBD> Copyright Beman Dawes, 1999</p>
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
<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/html/minimal.css">
|
||||
<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
@ -40,6 +40,7 @@
|
||||
<a href="#Introduction">Introduction</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>
|
||||
@ -53,7 +54,7 @@
|
||||
<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</code>">Class <code>error_condition</code></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>
|
||||
@ -77,55 +78,50 @@ errno</code>.</p>
|
||||
<h2><a name="Macros">Macros</a></h2>
|
||||
<p>Users may defined 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">
|
||||
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" height="368">
|
||||
<tr>
|
||||
<td><b><i>Macro Name</i></b></td>
|
||||
<td><b><i>Default</i></b></td>
|
||||
<td><b><i>Effect if defined</i></b></td>
|
||||
<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"><code>BOOST_WINDOWS_API</code></td>
|
||||
<td valign="top">Defined if Windows is detected by Boost.System's automatic configuration
|
||||
code, otherwise not defined.</td>
|
||||
<td valign="top">Implementation uses the Microsoft Windows native
|
||||
application program interface (API).</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>BOOST_POSIX_API</code></td>
|
||||
<td valign="top">Defined if Windows is not detected by Boost.System's automatic configuration
|
||||
code.</td>
|
||||
<td valign="top">Implementation uses the POSIX native
|
||||
application program interface (API).</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>BOOST_SYSTEM_DYN_LINK</code></td>
|
||||
<td valign="top">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined,
|
||||
<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">Boost.System library is dynamically linked. If not defined,
|
||||
<td valign="top" height="64">Boost.System library is dynamically linked. If not defined,
|
||||
static linking is assumed.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>BOOST_SYSTEM_NO_LIB</code></td>
|
||||
<td valign="top">Defined if <code>BOOST_ALL_NO_LIB</code> is defined,
|
||||
<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">Boost.System library does not use the Boost auto-link
|
||||
<td valign="top" height="47">Boost.System library does not use the Boost auto-link
|
||||
facility.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>BOOST_SYSTEM_NO_DEPRECATED</code></td>
|
||||
<td valign="top">Not defined.</td>
|
||||
<td valign="top">Deprecated features are excluded.</td>
|
||||
<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>
|
||||
</table>
|
||||
<h2><a name="Deprecated-names">Deprecated names</a></h2>
|
||||
<p>In the process of adding Boost.System to C++0x standard library, some of the
|
||||
names are being changed. To ease transition, Boost.System deprecates the old
|
||||
<p>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.</p>
|
||||
<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
|
||||
<tr>
|
||||
<td><b><i>Old name, now deprecated</i></b></td>
|
||||
<td><b><i>New name</i></b></td>
|
||||
<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>
|
||||
@ -141,21 +137,39 @@ is defined.</p>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>get_posix_category()</code></td>
|
||||
<td><code>get_generic_category()</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>posix_category</code></td>
|
||||
<td><code>generic_category</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>errno_ecat</code></td>
|
||||
<td><code>generic_category</code></td>
|
||||
<td><code>generic_category()</code></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><code>native_ecat</code></td>
|
||||
<td><code>system_category</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>
|
||||
@ -265,9 +279,6 @@ is defined.</p>
|
||||
template<> struct is_error_condition_enum<posix::posix_errno><errc::errc_t>
|
||||
{ static const bool value = true; };
|
||||
|
||||
// predefined error_code object used as "throw on error" tag
|
||||
extern error_code <a href="#throws-object">throws</a>;
|
||||
|
||||
// <a href="#Non-member-functions">non-member functions</a>
|
||||
|
||||
bool operator==( const error_code & lhs, const error_code & rhs );
|
||||
@ -336,11 +347,8 @@ types should create a single object of each such type. <i>
|
||||
bool operator< ( const error_category & rhs ) const;
|
||||
};
|
||||
|
||||
const error_category & get_system_category();
|
||||
const error_category & get_generic_category();
|
||||
|
||||
static const error_category & system_category = get_system_category();
|
||||
static const error_category & generic_category = get_generic_category();
|
||||
const error_category & system_category();
|
||||
const error_category & generic_category();
|
||||
}
|
||||
}</pre>
|
||||
</blockquote>
|
||||
@ -362,8 +370,8 @@ this subclause.</p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_condition( ev, *this )</code>.</p>
|
||||
<blockquote>
|
||||
<p> [<i>--Note:</i> Derived classes will typically convert <code>ev</code>
|
||||
to some portable <code>error_category</code>, such as <code>generic_category</code>,
|
||||
<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>
|
||||
@ -402,22 +410,18 @@ const;</code></p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_category-non-member-functions">Class <code>error_category</code>
|
||||
non-member functions</a></h3>
|
||||
<pre>const error_category & get_system_category();</pre>
|
||||
<pre>const error_category & system_category();</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A reference to a <code>error_category</code> object
|
||||
identifying errors originating from the operating system.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>const error_category & get_generic_category();</pre>
|
||||
<pre>const error_category & generic_category();</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A reference to a <code>error_category</code> object
|
||||
identifying portable error conditions.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_category-predefined-objects">Class <code>error_category</code>
|
||||
predefined objects</a></h3>
|
||||
<p>Predefined objects <code>system_category</code>
|
||||
and <code>generic_category</code> identify system specific error codes and portable error conditions, respectively.</p>
|
||||
<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
|
||||
@ -439,14 +443,12 @@ error_code</code> synopsis</a></h3>
|
||||
error_code();
|
||||
error_code( val, const error_category & cat );
|
||||
template <class <code>ErrorCodeEnum</code>>
|
||||
error_code(<code> ErrorCodeEnum</code> e,
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>> >::type* = 0);
|
||||
error_code(<code> ErrorCodeEnum</code> e );
|
||||
|
||||
// modifiers:
|
||||
void assign( int val, const error_category & cat );
|
||||
template<typename <code>ErrorCodeEnum</code>>
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>>, error_code>::type &
|
||||
operator=( <code>ErrorCodeEnum</code> val );;
|
||||
error_code & operator=( <code>ErrorCodeEnum</code> val );;
|
||||
void clear();
|
||||
|
||||
// observers:
|
||||
@ -468,7 +470,7 @@ error_code</code> constructors</a></h3>
|
||||
<pre>error_code();</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>
|
||||
<p><i>Postconditions:</i> <code>val_ == 0 && cat_ == &system_category()</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>error_code( int val, const error_category & cat );</pre>
|
||||
@ -478,12 +480,14 @@ error_code</code> constructors</a></h3>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template <class <code>ErrorCodeEnum</code>>
|
||||
error_code(<code> errorCodeEnum</code> val,
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>> >::type* = 0);</pre>
|
||||
error_code(<code> ErrorCodeEnum</code> val );</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>Throws:</i> Nothing.</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>
|
||||
@ -493,15 +497,17 @@ error_code</code> modifiers</a></h3>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename <code>ErrorCodeEnum</code>>
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>>, error_code>::type &
|
||||
operator=( <code>ErrorCodeEnum</code> val );</pre>
|
||||
error_code & operator=( <code>ErrorCodeEnum</code> val );</pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_code( val )</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</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>
|
||||
<p><code>void clear();</code></p>
|
||||
<blockquote>
|
||||
<p><i>postcondition:</i> <code>value() == 0 && category() == generic_category</code></p>
|
||||
<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>
|
||||
@ -557,14 +563,12 @@ implementation specific. <i>--end note ]</i></p>
|
||||
error_condition();
|
||||
error_condition( int val, const error_category & cat );
|
||||
template <class ErrorConditionEnum>
|
||||
error_condition( errorConditionEnum val,
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0 );
|
||||
error_condition( errorConditionEnum val );
|
||||
|
||||
// modifiers:
|
||||
void assign( int val, const error_category & cat );
|
||||
template<typename ErrorConditionEnum>
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::type &
|
||||
operator=( ErrorConditionEnum val );
|
||||
error_condition & operator=( ErrorConditionEnum val );
|
||||
void clear();
|
||||
|
||||
// observers:
|
||||
@ -585,7 +589,7 @@ constructors</a></h3>
|
||||
<pre>error_condition(); </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>
|
||||
<p><i>Postconditions:</i> <code>val_ == 0 and cat_ == &generic_category()</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition( int val, const error_category & cat );</pre>
|
||||
@ -595,12 +599,14 @@ constructors</a></h3>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template <class ErrorConditionEnum>
|
||||
error_condition( errorConditionEnum val,
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0 );</pre>
|
||||
error_condition( ErrorConditionEnum e );</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( val )</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_condition(e)</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</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>
|
||||
@ -610,15 +616,18 @@ modifiers</a></h3>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename ErrorConditionEnum>
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::type &
|
||||
operator=( ErrorConditionEnum val );</pre>
|
||||
error_condition & operator=( ErrorConditionEnum e );</pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_condition( val )</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_condition( e )</code>.</p>
|
||||
<p><i>Returns:</i> <code>*this</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</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>
|
||||
<p><code>void clear();</code></p>
|
||||
<blockquote>
|
||||
<p><i>postcondition:</i> <code>value() == 0 && category() == generic_category</code></p>
|
||||
<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>
|
||||
@ -730,11 +739,11 @@ bool operator!=( const error_condition & condition, const error_code & c
|
||||
</blockquote>
|
||||
<pre>error_code make_error_code( errc::errc_t e );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_code( e, generic_category)</code>.</p>
|
||||
<p><i>Returns:</i> <code>error_code( e, generic_category())</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition make_error_condition( errc::errc_t e );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_condition( static_cast<int>( e ), generic_category)</code>.</p>
|
||||
<p><i>Returns:</i> <code>error_condition( static_cast<int>( e ), generic_category())</code>.</p>
|
||||
</blockquote>
|
||||
|
||||
<pre>template <class charT, class traits>
|
||||
@ -831,7 +840,7 @@ application program interfaces.</p>
|
||||
<hr>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->October 11, 2008<!--webbot bot="Timestamp" endspan i-checksum="30976" --> </font>
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->June 29, 2010<!--webbot bot="Timestamp" endspan i-checksum="14432" --> </font>
|
||||
</p>
|
||||
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2006, 2007, 2008</p>
|
||||
|
||||
42
include/boost/system/api_config.hpp
Normal file
42
include/boost/system/api_config.hpp
Normal file
@ -0,0 +1,42 @@
|
||||
// boost/system/api_config.hpp -------------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2003, 2006, 2010
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// See http://www.boost.org/libs/system for documentation.
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// Boost.System calls operating system API functions to implement system error category
|
||||
// functions. Usually there is no question as to which API is to be used.
|
||||
//
|
||||
// In the case of MinGW or Cygwin/MinGW, however, both POSIX and Windows API's are
|
||||
// available. Chaos ensues if other code thinks one is in use when Boost.System was
|
||||
// actually built with the other. This header centralizes the API choice and prevents
|
||||
// user definition of API macros, thus elminating the possibility of mismatches and the
|
||||
// need to test configurations with little or no practical value.
|
||||
//
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_SYSTEM_API_CONFIG_HPP
|
||||
#define BOOST_SYSTEM_API_CONFIG_HPP
|
||||
|
||||
# if defined(BOOST_POSIX_API) || defined(BOOST_WINDOWS_API)
|
||||
# error user defined BOOST_POSIX_API or BOOST_WINDOWS_API not supported
|
||||
# endif
|
||||
|
||||
// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use
|
||||
// Cygwin/MinGW does not predefine _WIN32.
|
||||
// Standalone MinGW and all other known Windows compilers do predefine _WIN32
|
||||
// Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too.
|
||||
|
||||
# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
|
||||
# define BOOST_WINDOWS_API
|
||||
# else
|
||||
# define BOOST_POSIX_API
|
||||
# endif
|
||||
|
||||
#endif // BOOST_SYSTEM_API_CONFIG_HPP
|
||||
@ -1,4 +1,4 @@
|
||||
// boost/system/config.hpp -------------------------------------------------//
|
||||
// boost/system/config.hpp -----------------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2003, 2006
|
||||
|
||||
@ -11,47 +11,24 @@
|
||||
#define BOOST_SYSTEM_CONFIG_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/system/api_config.hpp> // for BOOST_POSIX_API or BOOST_WINDOWS_API
|
||||
|
||||
// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use.
|
||||
// If not specified, a sensible default will be applied.
|
||||
// This header implements separate compilation features as described in
|
||||
// http://www.boost.org/more/separate_compilation.html
|
||||
|
||||
# if defined( BOOST_WINDOWS_API ) && defined( BOOST_POSIX_API )
|
||||
# error both BOOST_WINDOWS_API and BOOST_POSIX_API are defined
|
||||
# elif !defined( BOOST_WINDOWS_API ) && !defined( BOOST_POSIX_API )
|
||||
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__)
|
||||
# define BOOST_WINDOWS_API
|
||||
# else
|
||||
# define BOOST_POSIX_API
|
||||
# endif
|
||||
# endif
|
||||
// enable dynamic or static linking as requested --------------------------------------//
|
||||
|
||||
// enable dynamic linking on Windows ---------------------------------------//
|
||||
|
||||
//# if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__)
|
||||
//# error Dynamic linking Boost.System does not work for Borland; use static linking instead
|
||||
//# endif
|
||||
|
||||
#ifdef BOOST_HAS_DECLSPEC // defined in config system
|
||||
// we need to import/export our code only if the user has specifically
|
||||
// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
|
||||
// libraries to be dynamically linked, or BOOST_SYSTEM_DYN_LINK
|
||||
// if they want just this one to be dynamically liked:
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
|
||||
// export if this is our own source, otherwise import:
|
||||
#ifdef BOOST_SYSTEM_SOURCE
|
||||
# define BOOST_SYSTEM_DECL __declspec(dllexport)
|
||||
# if defined(BOOST_SYSTEM_SOURCE)
|
||||
# define BOOST_SYSTEM_DECL BOOST_SYMBOL_EXPORT
|
||||
# else
|
||||
# define BOOST_SYSTEM_DECL BOOST_SYMBOL_IMPORT
|
||||
# endif
|
||||
#else
|
||||
# define BOOST_SYSTEM_DECL __declspec(dllimport)
|
||||
#endif // BOOST_SYSTEM_SOURCE
|
||||
#endif // DYN_LINK
|
||||
#endif // BOOST_HAS_DECLSPEC
|
||||
//
|
||||
// if BOOST_SYSTEM_DECL isn't defined yet define it now:
|
||||
#ifndef BOOST_SYSTEM_DECL
|
||||
#define BOOST_SYSTEM_DECL
|
||||
# define BOOST_SYSTEM_DECL
|
||||
#endif
|
||||
|
||||
// enable automatic library variant selection ------------------------------//
|
||||
// enable automatic library variant selection ----------------------------------------//
|
||||
|
||||
#if !defined(BOOST_SYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SYSTEM_NO_LIB)
|
||||
//
|
||||
|
||||
@ -23,7 +23,7 @@ namespace boost
|
||||
{
|
||||
// To construct an error_code after a API error:
|
||||
//
|
||||
// error_code( errno, system_category )
|
||||
// error_code( errno, system_category() )
|
||||
|
||||
// User code should use the portable "posix" enums for POSIX errors; this
|
||||
// allows such code to be portable to non-POSIX systems. For the non-POSIX
|
||||
@ -46,7 +46,7 @@ namespace boost
|
||||
namespace cygwin_error
|
||||
{
|
||||
inline error_code make_error_code( cygwin_errno e )
|
||||
{ return error_code( e, get_system_category() ); }
|
||||
{ return error_code( e, system_category() ); }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -202,18 +202,18 @@ namespace boost
|
||||
|
||||
// predefined error categories -----------------------------------------//
|
||||
|
||||
BOOST_SYSTEM_DECL const error_category & get_system_category();
|
||||
BOOST_SYSTEM_DECL const error_category & get_generic_category();
|
||||
BOOST_SYSTEM_DECL const error_category & system_category();
|
||||
BOOST_SYSTEM_DECL const error_category & generic_category();
|
||||
|
||||
// deprecated synonyms --------------------------------------------------//
|
||||
|
||||
static const error_category & system_category = get_system_category();
|
||||
static const error_category & generic_category = get_generic_category();
|
||||
|
||||
# ifndef BOOST_SYSTEM_NO_DEPRECATED
|
||||
// deprecated synonyms
|
||||
inline const error_category & get_posix_category() { return get_generic_category(); }
|
||||
static const error_category & posix_category = get_generic_category();
|
||||
static const error_category & errno_ecat = get_generic_category();
|
||||
static const error_category & native_ecat = get_system_category();
|
||||
inline const error_category & get_system_category() { return system_category(); }
|
||||
inline const error_category & get_generic_category() { return generic_category(); }
|
||||
inline const error_category & get_posix_category() { return generic_category(); }
|
||||
static const error_category & posix_category = generic_category();
|
||||
static const error_category & errno_ecat = generic_category();
|
||||
static const error_category & native_ecat = system_category();
|
||||
# endif
|
||||
|
||||
// class error_condition -----------------------------------------------//
|
||||
@ -225,7 +225,7 @@ namespace boost
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_condition() : m_val(0), m_cat(&get_generic_category()) {}
|
||||
error_condition() : m_val(0), m_cat(&generic_category()) {}
|
||||
error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
|
||||
|
||||
template <class ErrorConditionEnum>
|
||||
@ -254,7 +254,7 @@ namespace boost
|
||||
void clear()
|
||||
{
|
||||
m_val = 0;
|
||||
m_cat = &get_generic_category();
|
||||
m_cat = &generic_category();
|
||||
}
|
||||
|
||||
// observers:
|
||||
@ -312,7 +312,7 @@ namespace boost
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_code() : m_val(0), m_cat(&get_system_category()) {}
|
||||
error_code() : m_val(0), m_cat(&system_category()) {}
|
||||
error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
|
||||
|
||||
template <class ErrorCodeEnum>
|
||||
@ -340,7 +340,7 @@ namespace boost
|
||||
void clear()
|
||||
{
|
||||
m_val = 0;
|
||||
m_cat = &get_system_category();
|
||||
m_cat = &system_category();
|
||||
}
|
||||
|
||||
// observers:
|
||||
@ -473,11 +473,11 @@ namespace boost
|
||||
{
|
||||
// explicit conversion:
|
||||
inline error_code make_error_code( errc_t e )
|
||||
{ return error_code( e, get_generic_category() ); }
|
||||
{ return error_code( e, generic_category() ); }
|
||||
|
||||
// implicit conversion:
|
||||
inline error_condition make_error_condition( errc_t e )
|
||||
{ return error_condition( e, get_generic_category() ); }
|
||||
{ return error_condition( e, generic_category() ); }
|
||||
}
|
||||
|
||||
// error_category default implementation -------------------------------//
|
||||
|
||||
@ -23,7 +23,7 @@ namespace boost
|
||||
{
|
||||
// To construct an error_code after a API error:
|
||||
//
|
||||
// error_code( errno, system_category )
|
||||
// error_code( errno, system_category() )
|
||||
|
||||
// User code should use the portable "posix" enums for POSIX errors; this
|
||||
// allows such code to be portable to non-POSIX systems. For the non-POSIX
|
||||
@ -99,7 +99,7 @@ namespace boost
|
||||
namespace linux_error
|
||||
{
|
||||
inline error_code make_error_code( linux_errno e )
|
||||
{ return error_code( e, get_system_category() ); }
|
||||
{ return error_code( e, system_category() ); }
|
||||
}
|
||||
|
||||
} // namespace system
|
||||
|
||||
@ -17,9 +17,11 @@ namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
// class system_error --------------------------------------------------//
|
||||
// class system_error ------------------------------------------------------------//
|
||||
|
||||
class system_error : public std::runtime_error
|
||||
class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error
|
||||
// BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared
|
||||
// library can be caught. See svn.boost.org/trac/boost/ticket/3697
|
||||
{
|
||||
public:
|
||||
system_error( error_code ec )
|
||||
@ -62,11 +64,8 @@ namespace boost
|
||||
try
|
||||
{
|
||||
m_what = this->std::runtime_error::what();
|
||||
if ( m_error_code )
|
||||
{
|
||||
if ( !m_what.empty() ) m_what += ": ";
|
||||
m_what += m_error_code.message();
|
||||
}
|
||||
if ( !m_what.empty() ) m_what += ": ";
|
||||
m_what += m_error_code.message();
|
||||
}
|
||||
catch (...) { return std::runtime_error::what(); }
|
||||
}
|
||||
|
||||
@ -29,7 +29,7 @@ namespace boost
|
||||
|
||||
// To construct an error_code after a API error:
|
||||
//
|
||||
// error_code( ::GetLastError(), system_category )
|
||||
// error_code( ::GetLastError(), system_category() )
|
||||
|
||||
namespace windows_error
|
||||
{
|
||||
@ -107,7 +107,7 @@ namespace boost
|
||||
namespace windows_error
|
||||
{
|
||||
inline error_code make_error_code( windows_error_code e )
|
||||
{ return error_code( e, get_system_category() ); }
|
||||
{ return error_code( e, system_category() ); }
|
||||
}
|
||||
|
||||
} // namespace system
|
||||
|
||||
@ -29,8 +29,9 @@ using namespace boost::system::errc;
|
||||
|
||||
# if defined( BOOST_WINDOWS_API )
|
||||
# include <windows.h>
|
||||
# include "local_free_on_destruction.hpp"
|
||||
# ifndef ERROR_INCORRECT_SIZE
|
||||
# define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
|
||||
# define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
|
||||
# endif
|
||||
# endif
|
||||
|
||||
@ -159,7 +160,7 @@ namespace
|
||||
switch ( ev )
|
||||
{
|
||||
case 0: return make_error_condition( success );
|
||||
# if defined(BOOST_POSIX_API)
|
||||
# if defined(BOOST_POSIX_API)
|
||||
// POSIX-like O/S -> posix_errno decode table ---------------------------//
|
||||
case E2BIG: return make_error_condition( argument_list_too_long );
|
||||
case EACCES: return make_error_condition( permission_denied );
|
||||
@ -221,7 +222,9 @@ namespace
|
||||
# if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value
|
||||
case ENOTEMPTY: return make_error_condition( directory_not_empty );
|
||||
# endif // ENOTEMPTY != EEXIST
|
||||
case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable );
|
||||
# if ENOTRECOVERABLE != ECONNRESET // the same on some Broadcom chips
|
||||
case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable );
|
||||
# endif // ENOTRECOVERABLE != ECONNRESET
|
||||
case ENOTSOCK: return make_error_condition( not_a_socket );
|
||||
case ENOTSUP: return make_error_condition( not_supported );
|
||||
case ENOTTY: return make_error_condition( inappropriate_io_control_operation );
|
||||
@ -230,7 +233,9 @@ namespace
|
||||
case EOPNOTSUPP: return make_error_condition( operation_not_supported );
|
||||
# endif // EOPNOTSUPP != ENOTSUP
|
||||
case EOVERFLOW: return make_error_condition( value_too_large );
|
||||
case EOWNERDEAD: return make_error_condition( owner_dead );
|
||||
# if EOWNERDEAD != ECONNABORTED // the same on some Broadcom chips
|
||||
case EOWNERDEAD: return make_error_condition( owner_dead );
|
||||
# endif // EOWNERDEAD != ECONNABORTED
|
||||
case EPERM: return make_error_condition( operation_not_permitted );
|
||||
case EPIPE: return make_error_condition( broken_pipe );
|
||||
case EPROTO: return make_error_condition( protocol_error );
|
||||
@ -325,7 +330,7 @@ namespace
|
||||
case WSAETIMEDOUT: return make_error_condition( timed_out );
|
||||
case WSAEWOULDBLOCK: return make_error_condition( operation_would_block );
|
||||
#endif
|
||||
default: return error_condition( ev, system_category );
|
||||
default: return error_condition( ev, system_category() );
|
||||
}
|
||||
}
|
||||
|
||||
@ -333,28 +338,14 @@ namespace
|
||||
|
||||
std::string system_error_category::message( int ev ) const
|
||||
{
|
||||
return generic_category.message( ev );
|
||||
return generic_category().message( ev );
|
||||
}
|
||||
# else
|
||||
// TODO:
|
||||
|
||||
//Some quick notes on the implementation (sorry for the noise if
|
||||
//someone has already mentioned them):
|
||||
//
|
||||
//- The ::LocalFree() usage isn't exception safe.
|
||||
//
|
||||
//See:
|
||||
//
|
||||
//<http://boost.cvs.sourceforge.net/boost/boost/boost/asio/system_exception.hpp?revision=1.1&view=markup>
|
||||
//
|
||||
//in the implementation of what() for an example.
|
||||
//
|
||||
//Cheers,
|
||||
//Chris
|
||||
|
||||
std::string system_error_category::message( int ev ) const
|
||||
{
|
||||
# ifndef BOOST_NO_ANSI_APIS
|
||||
LPVOID lpMsgBuf;
|
||||
LPVOID lpMsgBuf = 0;
|
||||
DWORD retval = ::FormatMessageA(
|
||||
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||||
FORMAT_MESSAGE_FROM_SYSTEM |
|
||||
@ -366,13 +357,13 @@ namespace
|
||||
0,
|
||||
NULL
|
||||
);
|
||||
detail::local_free_on_destruction lfod(lpMsgBuf);
|
||||
if (retval == 0)
|
||||
return std::string("Unknown error");
|
||||
|
||||
std::string str( static_cast<LPCSTR>(lpMsgBuf) );
|
||||
::LocalFree( lpMsgBuf ); // free the buffer
|
||||
# else // WinCE workaround
|
||||
LPVOID lpMsgBuf;
|
||||
LPVOID lpMsgBuf = 0;
|
||||
DWORD retval = ::FormatMessageW(
|
||||
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||||
FORMAT_MESSAGE_FROM_SYSTEM |
|
||||
@ -384,6 +375,7 @@ namespace
|
||||
0,
|
||||
NULL
|
||||
);
|
||||
detail::local_free_on_destruction lfod(lpMsgBuf);
|
||||
if (retval == 0)
|
||||
return std::string("Unknown error");
|
||||
|
||||
@ -393,7 +385,6 @@ namespace
|
||||
return std::string("Unknown error");
|
||||
|
||||
std::string str( narrow_buffer );
|
||||
::LocalFree( lpMsgBuf ); // free the buffer
|
||||
# endif
|
||||
while ( str.size()
|
||||
&& (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
|
||||
@ -419,13 +410,13 @@ namespace boost
|
||||
// address for comparison purposes
|
||||
# endif
|
||||
|
||||
BOOST_SYSTEM_DECL const error_category & get_system_category()
|
||||
BOOST_SYSTEM_DECL const error_category & system_category()
|
||||
{
|
||||
static const system_error_category system_category_const;
|
||||
return system_category_const;
|
||||
}
|
||||
|
||||
BOOST_SYSTEM_DECL const error_category & get_generic_category()
|
||||
BOOST_SYSTEM_DECL const error_category & generic_category()
|
||||
{
|
||||
static const generic_error_category generic_category_const;
|
||||
return generic_category_const;
|
||||
|
||||
40
src/local_free_on_destruction.hpp
Normal file
40
src/local_free_on_destruction.hpp
Normal file
@ -0,0 +1,40 @@
|
||||
// local_free_on_exit.hpp ------------------------------------------------------------//
|
||||
|
||||
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
// Copyright (c) 2010 Beman Dawes
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// This is derived from boost/asio/detail/local_free_on_block_exit.hpp to avoid
|
||||
// a dependency on asio. Thanks to Chris Kohlhoff for pointing it out.
|
||||
|
||||
#ifndef BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
|
||||
#define BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace system {
|
||||
namespace detail {
|
||||
|
||||
class local_free_on_destruction
|
||||
{
|
||||
public:
|
||||
explicit local_free_on_destruction(void* p)
|
||||
: p_(p) {}
|
||||
|
||||
~local_free_on_destruction()
|
||||
{
|
||||
::LocalFree(p_);
|
||||
}
|
||||
|
||||
private:
|
||||
void* p_;
|
||||
local_free_on_destruction(const local_free_on_destruction&); // = deleted
|
||||
local_free_on_destruction& operator=(const local_free_on_destruction&); // = deleted
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
|
||||
@ -12,6 +12,12 @@ project
|
||||
<library>/boost/system//boost_system
|
||||
<toolset>msvc:<asynch-exceptions>on
|
||||
;
|
||||
|
||||
lib throw_test
|
||||
: throw_test.cpp
|
||||
: <link>shared:<define>BOOST_SYSTEM_DYN_LINK=1
|
||||
;
|
||||
|
||||
|
||||
test-suite "system"
|
||||
: [ run error_code_test.cpp
|
||||
@ -21,21 +27,25 @@ project
|
||||
<link>static
|
||||
]
|
||||
[ run error_code_test.cpp
|
||||
: : : : error_code_test_dll
|
||||
: : : <link>shared : error_code_test_shared
|
||||
]
|
||||
[ run error_code_user_test.cpp
|
||||
: : : <link>static
|
||||
]
|
||||
[ run error_code_user_test.cpp
|
||||
: : : : error_code_user_test_dll
|
||||
: : : <link>shared : error_code_user_test_shared
|
||||
]
|
||||
[ run system_error_test.cpp
|
||||
: : : <link>static
|
||||
]
|
||||
[ run system_error_test.cpp
|
||||
: : : : system_error_test_dll
|
||||
: : : <link>shared : system_error_test_shared
|
||||
]
|
||||
[ run dynamic_link_test.cpp throw_test
|
||||
: : : <link>shared : throw_test_shared
|
||||
]
|
||||
[ run initialization_test.cpp
|
||||
: : : <link>shared : initialization_test_shared
|
||||
]
|
||||
[ run header_only_test.cpp
|
||||
: : : <link>static
|
||||
|
||||
55
test/dynamic_link_test.cpp
Normal file
55
test/dynamic_link_test.cpp
Normal file
@ -0,0 +1,55 @@
|
||||
// dynamic_link_test.cpp -------------------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2010
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// Library home page is www.boost.org/libs/system
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// Dynamic link libraries (DLL's), also know as dynamic shared objects (DSO's),
|
||||
// can cause symbol visability problems unless carefully configured. One of the
|
||||
// manifestations, particularly with GCC, is that a system_error exception thrown from
|
||||
// a DLL or DSO is not caught.
|
||||
//
|
||||
// The purpose of this program is to test for that error.
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
#include <boost/system/system_error.hpp>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
BOOST_SYSTEM_DECL void throw_test();
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
try
|
||||
{
|
||||
boost::system::throw_test();
|
||||
}
|
||||
catch (const boost::system::system_error& ex)
|
||||
{
|
||||
std::cout << " caught boost::system::system_error as expected\n";
|
||||
std::cout << " what() reports " << ex.what() << '\n';
|
||||
return 0;
|
||||
}
|
||||
|
||||
catch (const std::runtime_error& ex)
|
||||
{
|
||||
std::cout << " error: caught std::runtime_error instead of boost::system::system_error\n";
|
||||
std::cout << " what() reports " << ex.what() << '\n';
|
||||
return 1;
|
||||
}
|
||||
|
||||
std::cout << " error: failed to catch boost::system::system_error\n";
|
||||
return 1;
|
||||
}
|
||||
@ -7,7 +7,10 @@
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// test without deprecated features
|
||||
#define BOOST_SYSTEM_NO_DEPRECATED
|
||||
|
||||
#include <boost/config/warning_disable.hpp>
|
||||
|
||||
@ -56,55 +59,61 @@ namespace
|
||||
int main( int, char ** )
|
||||
{
|
||||
|
||||
std::cout << "Conversion use cases...\n";
|
||||
error_condition x1( errc::file_exists );
|
||||
//error_code x2( errc::file_exists ); // should fail to compile
|
||||
make_error_code(errc::file_exists);
|
||||
make_error_condition(errc::file_exists);
|
||||
|
||||
std::cout << "General tests...\n";
|
||||
// unit tests:
|
||||
|
||||
BOOST_TEST( posix_category == posix_category );
|
||||
BOOST_TEST( system_category == system_category );
|
||||
BOOST_TEST( posix_category != system_category );
|
||||
BOOST_TEST( system_category != posix_category );
|
||||
BOOST_TEST( generic_category() == generic_category() );
|
||||
BOOST_TEST( system_category() == system_category() );
|
||||
BOOST_TEST( generic_category() != system_category() );
|
||||
BOOST_TEST( system_category() != generic_category() );
|
||||
|
||||
if ( std::less<const error_category*>()( &posix_category, &system_category ) )
|
||||
if ( std::less<const error_category*>()( &generic_category(), &system_category() ) )
|
||||
{
|
||||
BOOST_TEST( posix_category < system_category );
|
||||
BOOST_TEST( !(system_category < posix_category) );
|
||||
BOOST_TEST( generic_category() < system_category() );
|
||||
BOOST_TEST( !(system_category() < generic_category()) );
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_TEST( system_category < posix_category );
|
||||
BOOST_TEST( !(posix_category < system_category) );
|
||||
BOOST_TEST( system_category() < generic_category() );
|
||||
BOOST_TEST( !(generic_category() < system_category()) );
|
||||
}
|
||||
|
||||
|
||||
error_code ec;
|
||||
error_condition dec;
|
||||
error_condition econd;
|
||||
BOOST_TEST( !ec );
|
||||
BOOST_TEST( ec.value() == 0 );
|
||||
dec = ec.default_error_condition();
|
||||
BOOST_TEST( dec.value() == 0 );
|
||||
BOOST_TEST( dec.category() == posix_category );
|
||||
BOOST_TEST( ec == posix::success );
|
||||
BOOST_TEST( ec.category() == system_category );
|
||||
econd = ec.default_error_condition();
|
||||
BOOST_TEST( econd.value() == 0 );
|
||||
BOOST_TEST( econd.category() == generic_category() );
|
||||
BOOST_TEST( ec == errc::success );
|
||||
BOOST_TEST( ec.category() == system_category() );
|
||||
BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
|
||||
BOOST_TEST( !(ec < error_code( 0, system_category )) );
|
||||
BOOST_TEST( !(error_code( 0, system_category ) < ec) );
|
||||
BOOST_TEST( ec < error_code( 1, system_category ) );
|
||||
BOOST_TEST( !(error_code( 1, system_category ) < ec) );
|
||||
BOOST_TEST( !(ec < error_code( 0, system_category() )) );
|
||||
BOOST_TEST( !(error_code( 0, system_category() ) < ec) );
|
||||
BOOST_TEST( ec < error_code( 1, system_category() ) );
|
||||
BOOST_TEST( !(error_code( 1, system_category() ) < ec) );
|
||||
|
||||
error_code ec_0_system( 0, system_category );
|
||||
error_code ec_0_system( 0, system_category() );
|
||||
BOOST_TEST( !ec_0_system );
|
||||
BOOST_TEST( ec_0_system.value() == 0 );
|
||||
dec = ec_0_system.default_error_condition();
|
||||
BOOST_TEST( dec.value() == 0 );
|
||||
BOOST_TEST( dec.category() == posix_category );
|
||||
BOOST_TEST( ec_0_system == posix::success );
|
||||
BOOST_TEST( ec_0_system.category() == system_category );
|
||||
econd = ec_0_system.default_error_condition();
|
||||
BOOST_TEST( econd.value() == 0 );
|
||||
BOOST_TEST( econd.category() == generic_category() );
|
||||
BOOST_TEST( ec_0_system == errc::success );
|
||||
BOOST_TEST( ec_0_system.category() == system_category() );
|
||||
BOOST_TEST( std::strcmp( ec_0_system.category().name(), "system") == 0 );
|
||||
check_ostream( ec_0_system, "system:0" );
|
||||
|
||||
BOOST_TEST( ec_0_system == ec );
|
||||
|
||||
error_code ec_1_system( 1, system_category );
|
||||
error_code ec_1_system( 1, system_category() );
|
||||
BOOST_TEST( ec_1_system );
|
||||
BOOST_TEST( ec_1_system.value() == 1 );
|
||||
BOOST_TEST( ec_1_system.value() != 0 );
|
||||
@ -112,41 +121,43 @@ int main( int, char ** )
|
||||
BOOST_TEST( ec_0_system != ec_1_system );
|
||||
check_ostream( ec_1_system, "system:1" );
|
||||
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec.value() == BOOST_ACCESS_ERROR_MACRO );
|
||||
dec = ec.default_error_condition();
|
||||
BOOST_TEST( dec.value() == static_cast<int>(posix::permission_denied) );
|
||||
BOOST_TEST( dec.category() == posix_category );
|
||||
BOOST_TEST( dec == error_condition( posix::permission_denied, posix_category ) );
|
||||
BOOST_TEST( dec == posix::permission_denied );
|
||||
BOOST_TEST( posix::permission_denied == dec );
|
||||
BOOST_TEST( ec == posix::permission_denied );
|
||||
BOOST_TEST( ec.category() == system_category );
|
||||
econd = ec.default_error_condition();
|
||||
BOOST_TEST( econd.value() == static_cast<int>(errc::permission_denied) );
|
||||
BOOST_TEST( econd.category() == generic_category() );
|
||||
BOOST_TEST( econd == error_condition( errc::permission_denied, generic_category() ) );
|
||||
BOOST_TEST( econd == errc::permission_denied );
|
||||
BOOST_TEST( errc::permission_denied == econd );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( ec.category() == system_category() );
|
||||
BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
|
||||
|
||||
// test the explicit make_error_code conversion for posix
|
||||
ec = make_error_code( posix::bad_message );
|
||||
// test the explicit make_error_code conversion for errc
|
||||
ec = make_error_code( errc::bad_message );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == posix::bad_message );
|
||||
BOOST_TEST( posix::bad_message == ec );
|
||||
BOOST_TEST( ec != posix::permission_denied );
|
||||
BOOST_TEST( posix::permission_denied != ec );
|
||||
BOOST_TEST( ec.category() == posix_category );
|
||||
BOOST_TEST( ec == errc::bad_message );
|
||||
BOOST_TEST( errc::bad_message == ec );
|
||||
BOOST_TEST( ec != errc::permission_denied );
|
||||
BOOST_TEST( errc::permission_denied != ec );
|
||||
BOOST_TEST( ec.category() == generic_category() );
|
||||
|
||||
// test the deprecated predefined error_category synonyms
|
||||
BOOST_TEST( &system_category == &native_ecat );
|
||||
BOOST_TEST( &posix_category == &errno_ecat );
|
||||
BOOST_TEST( system_category == native_ecat );
|
||||
BOOST_TEST( posix_category == errno_ecat );
|
||||
//// test the deprecated predefined error_category synonyms
|
||||
//BOOST_TEST( &system_category() == &native_ecat );
|
||||
//BOOST_TEST( &generic_category() == &errno_ecat );
|
||||
//BOOST_TEST( system_category() == native_ecat );
|
||||
//BOOST_TEST( generic_category() == errno_ecat );
|
||||
|
||||
// test error_code and error_condition message();
|
||||
// see Boost.Filesystem operations_test for code specific message() tests
|
||||
ec = error_code( -1, system_category );
|
||||
ec = error_code( -1, system_category() );
|
||||
std::cout << "error_code message for -1 is \"" << ec.message() << "\"\n";
|
||||
std::cout << "error_code message for 0 is \"" << ec_0_system.message() << "\"\n";
|
||||
#if defined(BOOST_WINDOWS_API)
|
||||
// Borland appends newline, so just check text
|
||||
BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
|
||||
BOOST_TEST( ec_0_system.message().substr(0,36) == "The operation completed successfully" );
|
||||
#elif defined(linux) || defined(__linux) || defined(__linux__)
|
||||
// Linux appends value to message as unsigned, so it varies with # of bits
|
||||
BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
|
||||
@ -158,102 +169,105 @@ int main( int, char ** )
|
||||
BOOST_TEST( ec.message() == "error -1" );
|
||||
#endif
|
||||
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
|
||||
BOOST_TEST( ec.message() != "" );
|
||||
BOOST_TEST( ec.message().substr( 0, 13) != "Unknown error" );
|
||||
|
||||
dec = error_condition( -1, posix_category );
|
||||
std::cout << "error_condition message for -1 is \"" << dec.message() << "\"\n";
|
||||
econd = error_condition( -1, generic_category() );
|
||||
error_condition econd_ok;
|
||||
std::cout << "error_condition message for -1 is \"" << econd.message() << "\"\n";
|
||||
std::cout << "error_condition message for 0 is \"" << econd_ok.message() << "\"\n";
|
||||
#if defined(BOOST_WINDOWS_API)
|
||||
// Borland appends newline, so just check text
|
||||
BOOST_TEST( dec.message().substr(0,13) == "Unknown error" );
|
||||
BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
|
||||
BOOST_TEST( econd_ok.message().substr(0,8) == "No error" );
|
||||
#elif defined(linux) || defined(__linux) || defined(__linux__)
|
||||
// Linux appends value to message as unsigned, so it varies with # of bits
|
||||
BOOST_TEST( dec.message().substr(0,13) == "Unknown error" );
|
||||
BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
|
||||
#elif defined(__hpux)
|
||||
BOOST_TEST( dec.message() == "" );
|
||||
BOOST_TEST( econd.message() == "" );
|
||||
#elif defined(__osf__)
|
||||
BOOST_TEST( dec.message() == "Error -1 occurred." );
|
||||
BOOST_TEST( econd.message() == "Error -1 occurred." );
|
||||
#elif defined(__vms)
|
||||
BOOST_TEST( dec.message() == "error -1" );
|
||||
BOOST_TEST( econd.message() == "error -1" );
|
||||
#endif
|
||||
|
||||
dec = error_condition( BOOST_ACCESS_ERROR_MACRO, posix_category );
|
||||
BOOST_TEST( dec.message() != "" );
|
||||
BOOST_TEST( dec.message().substr( 0, 13) != "Unknown error" );
|
||||
econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category() );
|
||||
BOOST_TEST( econd.message() != "" );
|
||||
BOOST_TEST( econd.message().substr( 0, 13) != "Unknown error" );
|
||||
|
||||
#ifdef BOOST_WINDOWS_API
|
||||
std::cout << "Windows tests...\n";
|
||||
// these tests probe the Windows posix decoder
|
||||
// these tests probe the Windows errc decoder
|
||||
// test the first entry in the decoder table:
|
||||
ec = error_code( ERROR_ACCESS_DENIED, system_category );
|
||||
ec = error_code( ERROR_ACCESS_DENIED, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_ACCESS_DENIED );
|
||||
BOOST_TEST( ec == posix::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().value() == posix::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == posix_category );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
|
||||
// test the second entry in the decoder table:
|
||||
ec = error_code( ERROR_ALREADY_EXISTS, system_category );
|
||||
ec = error_code( ERROR_ALREADY_EXISTS, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_ALREADY_EXISTS );
|
||||
BOOST_TEST( ec == posix::file_exists );
|
||||
BOOST_TEST( ec.default_error_condition().value() == posix::file_exists );
|
||||
BOOST_TEST( ec.default_error_condition().category() == posix_category );
|
||||
BOOST_TEST( ec == errc::file_exists );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::file_exists );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
|
||||
// test the third entry in the decoder table:
|
||||
ec = error_code( ERROR_BAD_UNIT, system_category );
|
||||
ec = error_code( ERROR_BAD_UNIT, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_BAD_UNIT );
|
||||
BOOST_TEST( ec == posix::no_such_device );
|
||||
BOOST_TEST( ec.default_error_condition().value() == posix::no_such_device );
|
||||
BOOST_TEST( ec.default_error_condition().category() == posix_category );
|
||||
BOOST_TEST( ec == errc::no_such_device );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::no_such_device );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
|
||||
// test the last non-Winsock entry in the decoder table:
|
||||
ec = error_code( ERROR_WRITE_PROTECT, system_category );
|
||||
ec = error_code( ERROR_WRITE_PROTECT, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_WRITE_PROTECT );
|
||||
BOOST_TEST( ec == posix::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().value() == posix::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == posix_category );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
|
||||
// test the last Winsock entry in the decoder table:
|
||||
ec = error_code( WSAEWOULDBLOCK, system_category );
|
||||
ec = error_code( WSAEWOULDBLOCK, system_category() );
|
||||
BOOST_TEST( ec.value() == WSAEWOULDBLOCK );
|
||||
BOOST_TEST( ec == posix::operation_would_block );
|
||||
BOOST_TEST( ec.default_error_condition().value() == posix::operation_would_block );
|
||||
BOOST_TEST( ec.default_error_condition().category() == posix_category );
|
||||
BOOST_TEST( ec == errc::operation_would_block );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::operation_would_block );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
|
||||
// test not-in-table condition:
|
||||
ec = error_code( 1234567890, system_category );
|
||||
ec = error_code( 1234567890, system_category() );
|
||||
BOOST_TEST( ec.value() == 1234567890 );
|
||||
BOOST_TEST( ec.default_error_condition().value() == 1234567890 );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category() );
|
||||
|
||||
#else // POSIX
|
||||
|
||||
std::cout << "POSIX tests...\n";
|
||||
ec = error_code( EACCES, system_category );
|
||||
BOOST_TEST( ec == error_code( posix::permission_denied, system_category ) );
|
||||
BOOST_TEST( error_code( posix::permission_denied, system_category ) == ec );
|
||||
BOOST_TEST( ec == posix::permission_denied );
|
||||
BOOST_TEST( posix::permission_denied == ec );
|
||||
BOOST_TEST( ec.default_error_condition().value() == posix::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == posix_category );
|
||||
ec = error_code( EACCES, system_category() );
|
||||
BOOST_TEST( ec == error_code( errc::permission_denied, system_category() ) );
|
||||
BOOST_TEST( error_code( errc::permission_denied, system_category() ) == ec );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( errc::permission_denied == ec );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
|
||||
# ifdef __CYGWIN__
|
||||
|
||||
std::cout << "Cygwin tests...\n";
|
||||
ec = cygwin_error::no_package;
|
||||
BOOST_TEST( ec == cygwin_error::no_package );
|
||||
BOOST_TEST( ec == error_code( ENOPKG, system_category ) );
|
||||
BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category ) );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category );
|
||||
BOOST_TEST( ec == error_code( ENOPKG, system_category() ) );
|
||||
BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category() ) );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category() );
|
||||
|
||||
# elif defined(linux) || defined(__linux) || defined(__linux__)
|
||||
|
||||
std::cout << "Linux tests...\n";
|
||||
ec = linux_error::dot_dot_error;
|
||||
BOOST_TEST( ec == linux_error::dot_dot_error );
|
||||
BOOST_TEST( ec == error_code( EDOTDOT, system_category ) );
|
||||
BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category ) );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category );
|
||||
BOOST_TEST( ec == error_code( EDOTDOT, system_category() ) );
|
||||
BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category() ) );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category() );
|
||||
|
||||
# endif
|
||||
|
||||
|
||||
@ -14,11 +14,13 @@
|
||||
|
||||
// Motivation was a Boost posting by Christopher Kohlhoff on June 28, 2006.
|
||||
|
||||
#define BOOST_SYSTEM_NO_DEPRECATED
|
||||
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <boost/cerrno.hpp>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
#ifdef BOOST_POSIX_API
|
||||
# include <sys/stat.h>
|
||||
@ -40,7 +42,7 @@ boost::system::error_code my_mkdir( const std::string & path )
|
||||
# else
|
||||
::CreateDirectoryA( path.c_str(), 0 ) != 0 ? 0 : ::GetLastError(),
|
||||
# endif
|
||||
boost::system::system_category );
|
||||
boost::system::system_category() );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------ //
|
||||
@ -53,9 +55,9 @@ boost::system::error_code my_remove( const std::string & path )
|
||||
{
|
||||
return boost::system::error_code(
|
||||
std::remove( path.c_str() ) == 0 ? 0 : errno,
|
||||
boost::system::posix_category ); // OK for both Windows and POSIX
|
||||
// Alternatively, could use posix_category
|
||||
// on Windows and system_category on
|
||||
boost::system::generic_category() ); // OK for both Windows and POSIX
|
||||
// Alternatively, could use generic_category()
|
||||
// on Windows and system_category() on
|
||||
// POSIX-based systems.
|
||||
}
|
||||
|
||||
@ -108,6 +110,8 @@ namespace boost
|
||||
class lib3_error_category_imp : public boost::system::error_category
|
||||
{
|
||||
public:
|
||||
lib3_error_category_imp() : boost::system::error_category() { }
|
||||
|
||||
const char * name() const
|
||||
{
|
||||
return "lib3";
|
||||
@ -116,8 +120,8 @@ namespace boost
|
||||
boost::system::error_condition default_error_condition( int ev ) const
|
||||
{
|
||||
return ev == boo_boo
|
||||
? boost::system::error_condition( boost::system::posix::io_error,
|
||||
boost::system::posix_category )
|
||||
? boost::system::error_condition( boost::system::errc::io_error,
|
||||
boost::system::generic_category() )
|
||||
: boost::system::error_condition( ev,
|
||||
boost::lib3::lib3_error_category );
|
||||
}
|
||||
@ -168,6 +172,8 @@ namespace lib4
|
||||
class lib4_error_category_imp : public boost::system::error_category
|
||||
{
|
||||
public:
|
||||
lib4_error_category_imp() : boost::system::error_category() { }
|
||||
|
||||
const char * name() const
|
||||
{
|
||||
return "lib4";
|
||||
@ -176,8 +182,8 @@ namespace lib4
|
||||
boost::system::error_condition default_error_condition( int ev ) const
|
||||
{
|
||||
return ev == boo_boo.value()
|
||||
? boost::system::error_condition( boost::system::posix::io_error,
|
||||
boost::system::posix_category )
|
||||
? boost::system::error_condition( boost::system::errc::io_error,
|
||||
boost::system::generic_category() )
|
||||
: boost::system::error_condition( ev, lib4::lib4_error_category );
|
||||
}
|
||||
|
||||
@ -233,15 +239,15 @@ namespace lib4
|
||||
// switch (ev)
|
||||
// {
|
||||
// case user_success:
|
||||
// return boost::system::error_code(boost::system::posix::success, boost::system::posix_category);
|
||||
// return boost::system::error_code(boost::system::errc::success, boost::system::generic_category());
|
||||
// case user_permission_denied:
|
||||
// return boost::system::error_code(boost::system::posix::permission_denied, boost::system::posix_category);
|
||||
// return boost::system::error_code(boost::system::errc::permission_denied, boost::system::generic_category());
|
||||
// case user_out_of_memory:
|
||||
// return boost::system::error_code(boost::system::posix::not_enough_memory, boost::system::posix_category);
|
||||
// return boost::system::error_code(boost::system::errc::not_enough_memory, boost::system::generic_category());
|
||||
// default:
|
||||
// break;
|
||||
// }
|
||||
// return boost::system::error_code(boost::system::posix::no_posix_equivalent, boost::system::posix_category);
|
||||
// return boost::system::error_code(boost::system::errc::no_posix_equivalent, boost::system::generic_category());
|
||||
// }
|
||||
//
|
||||
// };
|
||||
@ -260,8 +266,8 @@ namespace lib4
|
||||
//
|
||||
// void check_success(const boost::system::error_code& ec, bool expect)
|
||||
// {
|
||||
// BOOST_CHECK( (ec == boost::system::posix::success) == expect );
|
||||
// if (ec == boost::system::posix::success)
|
||||
// BOOST_TEST( (ec == boost::system::errc::success) == expect );
|
||||
// if (ec == boost::system::errc::success)
|
||||
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
|
||||
// else
|
||||
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
|
||||
@ -269,8 +275,8 @@ namespace lib4
|
||||
//
|
||||
// void check_permission_denied(const boost::system::error_code& ec, bool expect)
|
||||
// {
|
||||
// BOOST_CHECK( (ec == boost::system::posix::permission_denied) == expect );
|
||||
// if (ec == boost::system::posix::permission_denied)
|
||||
// BOOST_TEST( (ec == boost::system::errc::permission_denied) == expect );
|
||||
// if (ec == boost::system::errc::permission_denied)
|
||||
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
|
||||
// else
|
||||
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
|
||||
@ -278,8 +284,8 @@ namespace lib4
|
||||
//
|
||||
// void check_out_of_memory(const boost::system::error_code& ec, bool expect)
|
||||
// {
|
||||
// BOOST_CHECK( (ec == boost::system::posix::not_enough_memory) == expect );
|
||||
// if (ec == boost::system::posix::not_enough_memory)
|
||||
// BOOST_TEST( (ec == boost::system::errc::not_enough_memory) == expect );
|
||||
// if (ec == boost::system::errc::not_enough_memory)
|
||||
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
|
||||
// else
|
||||
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
|
||||
@ -291,23 +297,23 @@ namespace lib4
|
||||
// printf("=====\n");
|
||||
// boost::system::error_code ec;
|
||||
// check_success(ec, true);
|
||||
// check_success(boost::system::posix::success, true);
|
||||
// check_success(boost::system::posix::permission_denied, false);
|
||||
// check_success(boost::system::posix::not_enough_memory, false);
|
||||
// check_success(boost::system::errc::success, true);
|
||||
// check_success(boost::system::errc::permission_denied, false);
|
||||
// check_success(boost::system::errc::not_enough_memory, false);
|
||||
// check_success(user_success, true);
|
||||
// check_success(user_permission_denied, false);
|
||||
// check_success(user_out_of_memory, false);
|
||||
// check_permission_denied(ec, false);
|
||||
// check_permission_denied(boost::system::posix::success, false);
|
||||
// check_permission_denied(boost::system::posix::permission_denied, true);
|
||||
// check_permission_denied(boost::system::posix::not_enough_memory, false);
|
||||
// check_permission_denied(boost::system::errc::success, false);
|
||||
// check_permission_denied(boost::system::errc::permission_denied, true);
|
||||
// check_permission_denied(boost::system::errc::not_enough_memory, false);
|
||||
// check_permission_denied(user_success, false);
|
||||
// check_permission_denied(user_permission_denied, true);
|
||||
// check_permission_denied(user_out_of_memory, false);
|
||||
// check_out_of_memory(ec, false);
|
||||
// check_out_of_memory(boost::system::posix::success, false);
|
||||
// check_out_of_memory(boost::system::posix::permission_denied, false);
|
||||
// check_out_of_memory(boost::system::posix::not_enough_memory, true);
|
||||
// check_out_of_memory(boost::system::errc::success, false);
|
||||
// check_out_of_memory(boost::system::errc::permission_denied, false);
|
||||
// check_out_of_memory(boost::system::errc::not_enough_memory, true);
|
||||
// check_out_of_memory(user_success, false);
|
||||
// check_out_of_memory(user_permission_denied, false);
|
||||
// check_out_of_memory(user_out_of_memory, true);
|
||||
@ -333,7 +339,7 @@ namespace lib4
|
||||
|
||||
// ------------------------------------------------------------------------ //
|
||||
|
||||
int test_main( int, char *[] )
|
||||
int main( int, char *[] )
|
||||
{
|
||||
boost::system::error_code ec;
|
||||
|
||||
@ -342,35 +348,35 @@ int test_main( int, char *[] )
|
||||
ec = my_mkdir( "/no-such-file-or-directory/will-not-succeed" );
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == boost::system::posix::no_such_file_or_directory );
|
||||
BOOST_CHECK( ec.category() == boost::system::system_category );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
|
||||
BOOST_TEST( ec.category() == boost::system::system_category() );
|
||||
|
||||
// Library 2 tests:
|
||||
|
||||
ec = my_remove( "/no-such-file-or-directory" );
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == boost::system::posix::no_such_file_or_directory );
|
||||
BOOST_CHECK( ec.category() == boost::system::posix_category );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
|
||||
BOOST_TEST( ec.category() == boost::system::generic_category() );
|
||||
|
||||
// Library 3 tests:
|
||||
|
||||
ec = boost::lib3::boo_boo;
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == boost::lib3::boo_boo );
|
||||
BOOST_CHECK( ec.value() == boost::lib3::boo_boo );
|
||||
BOOST_CHECK( ec.category() == boost::lib3::lib3_error_category );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == boost::lib3::boo_boo );
|
||||
BOOST_TEST( ec.value() == boost::lib3::boo_boo );
|
||||
BOOST_TEST( ec.category() == boost::lib3::lib3_error_category );
|
||||
|
||||
BOOST_CHECK( ec == boost::system::posix::io_error );
|
||||
BOOST_TEST( ec == boost::system::errc::io_error );
|
||||
|
||||
boost::system::error_code ec3( boost::lib3::boo_boo+100,
|
||||
boost::lib3::lib3_error_category );
|
||||
BOOST_CHECK( ec3.category() == boost::lib3::lib3_error_category );
|
||||
BOOST_CHECK( ec3.default_error_condition().category()
|
||||
BOOST_TEST( ec3.category() == boost::lib3::lib3_error_category );
|
||||
BOOST_TEST( ec3.default_error_condition().category()
|
||||
== boost::lib3::lib3_error_category );
|
||||
|
||||
// Library 4 tests:
|
||||
@ -378,21 +384,21 @@ int test_main( int, char *[] )
|
||||
ec = lib4::boo_boo;
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == lib4::boo_boo );
|
||||
BOOST_CHECK( ec.value() == lib4::boo_boo.value() );
|
||||
BOOST_CHECK( ec.category() == lib4::lib4_error_category );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == lib4::boo_boo );
|
||||
BOOST_TEST( ec.value() == lib4::boo_boo.value() );
|
||||
BOOST_TEST( ec.category() == lib4::lib4_error_category );
|
||||
|
||||
BOOST_CHECK( ec == boost::system::posix::io_error );
|
||||
BOOST_TEST( ec == boost::system::errc::io_error );
|
||||
|
||||
boost::system::error_code ec4( lib4::boo_boo.value()+100,
|
||||
lib4::lib4_error_category );
|
||||
BOOST_CHECK( ec4.default_error_condition().category()
|
||||
BOOST_TEST( ec4.default_error_condition().category()
|
||||
== lib4::lib4_error_category );
|
||||
|
||||
// Test 3
|
||||
|
||||
//test3::run();
|
||||
|
||||
return 0;
|
||||
return ::boost::report_errors();
|
||||
}
|
||||
|
||||
@ -13,12 +13,11 @@
|
||||
|
||||
#define BOOST_ERROR_CODE_HEADER_ONLY
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
|
||||
int test_main( int, char*[] )
|
||||
int main( int, char*[] )
|
||||
{
|
||||
boost::system::error_code ec( 0, boost::system::system_category );
|
||||
return 0;
|
||||
boost::system::error_code ec( 0, boost::system::system_category() );
|
||||
return ::boost::report_errors();
|
||||
}
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
// This test verifiies that the error_category vtable does not suffer from
|
||||
// order-of-initialization problems.
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
|
||||
struct foo
|
||||
@ -22,7 +22,7 @@ struct foo
|
||||
}
|
||||
} f;
|
||||
|
||||
int test_main( int, char ** )
|
||||
int main( int, char ** )
|
||||
{
|
||||
return 0;
|
||||
return ::boost::report_errors();
|
||||
}
|
||||
|
||||
@ -9,9 +9,12 @@
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// test without deprecated features
|
||||
#define BOOST_SYSTEM_NO_DEPRECATED
|
||||
|
||||
#include <boost/config/warning_disable.hpp>
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/system/system_error.hpp>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
@ -33,8 +36,8 @@ namespace
|
||||
int v, const char * str )
|
||||
{
|
||||
std::cout << "test " << desc << "\n what() returns \"" << ex.what() << "\"\n";
|
||||
BOOST_CHECK( ex.code().value() == v );
|
||||
BOOST_CHECK( ex.code().category() == system_category );
|
||||
BOOST_TEST( ex.code().value() == v );
|
||||
BOOST_TEST( ex.code().category() == system_category() );
|
||||
# ifdef BOOST_WINDOWS_API
|
||||
LANGID language_id;
|
||||
# if !defined(__MINGW32__) && !defined(__CYGWIN__)
|
||||
@ -45,7 +48,7 @@ namespace
|
||||
// std::cout << "GetUserDefaultUILanguage() returns " << language_id << '\n';
|
||||
if ( language_id == 0x0409 ) // English (United States)
|
||||
{
|
||||
BOOST_CHECK( std::string( ex.what() ) == str );
|
||||
BOOST_TEST( std::string( ex.what() ) == str );
|
||||
if ( std::string( ex.what() ) != str )
|
||||
std::cout << "expected \"" << str << "\", but what() returned \""
|
||||
<< ex.what() << "\"\n";
|
||||
@ -56,51 +59,51 @@ namespace
|
||||
const boost::uint_least32_t uvalue = 2u;
|
||||
}
|
||||
|
||||
int test_main( int, char *[] )
|
||||
int main( int, char *[] )
|
||||
{
|
||||
// all constructors, in the same order as they appear in the header:
|
||||
|
||||
system_error c1_0( error_code(0, system_category) );
|
||||
system_error c1_1( error_code(1, system_category) );
|
||||
system_error c1_2u( error_code(uvalue, system_category) );
|
||||
system_error c1_0( error_code(0, system_category()) );
|
||||
system_error c1_1( error_code(1, system_category()) );
|
||||
system_error c1_2u( error_code(uvalue, system_category()) );
|
||||
|
||||
system_error c2_0( error_code(0, system_category), string("c2_0") );
|
||||
system_error c2_1( error_code(1, system_category), string("c2_1") );
|
||||
system_error c2_0( error_code(0, system_category()), string("c2_0") );
|
||||
system_error c2_1( error_code(1, system_category()), string("c2_1") );
|
||||
|
||||
system_error c3_0( error_code(0, system_category), "c3_0" );
|
||||
system_error c3_1( error_code(1, system_category), "c3_1" );
|
||||
system_error c3_0( error_code(0, system_category()), "c3_0" );
|
||||
system_error c3_1( error_code(1, system_category()), "c3_1" );
|
||||
|
||||
system_error c4_0( 0, system_category );
|
||||
system_error c4_1( 1, system_category );
|
||||
system_error c4_2u( uvalue, system_category );
|
||||
system_error c4_0( 0, system_category() );
|
||||
system_error c4_1( 1, system_category() );
|
||||
system_error c4_2u( uvalue, system_category() );
|
||||
|
||||
system_error c5_0( 0, system_category, string("c5_0") );
|
||||
system_error c5_1( 1, system_category, string("c5_1") );
|
||||
system_error c5_0( 0, system_category(), string("c5_0") );
|
||||
system_error c5_1( 1, system_category(), string("c5_1") );
|
||||
|
||||
system_error c6_0( 0, system_category, "c6_0" );
|
||||
system_error c6_1( 1, system_category, "c6_1" );
|
||||
system_error c6_0( 0, system_category(), "c6_0" );
|
||||
system_error c6_1( 1, system_category(), "c6_1" );
|
||||
|
||||
TEST( c1_0, 0, "" );
|
||||
TEST( c1_0, 0, "The operation completed successfully" );
|
||||
TEST( c1_1, 1, "Incorrect function" );
|
||||
TEST( c1_2u, 2, "The system cannot find the file specified" );
|
||||
|
||||
TEST( c2_0, 0, "c2_0" );
|
||||
TEST( c2_0, 0, "c2_0: The operation completed successfully" );
|
||||
TEST( c2_1, 1, "c2_1: Incorrect function" );
|
||||
|
||||
TEST( c3_0, 0, "c3_0" );
|
||||
TEST( c3_0, 0, "c3_0: The operation completed successfully" );
|
||||
TEST( c3_1, 1, "c3_1: Incorrect function" );
|
||||
|
||||
TEST( c4_0, 0, "" );
|
||||
TEST( c4_0, 0, "The operation completed successfully" );
|
||||
TEST( c4_1, 1, "Incorrect function" );
|
||||
TEST( c4_2u, 2, "The system cannot find the file specified" );
|
||||
|
||||
TEST( c5_0, 0, "c5_0" );
|
||||
TEST( c5_0, 0, "c5_0: The operation completed successfully" );
|
||||
TEST( c5_1, 1, "c5_1: Incorrect function" );
|
||||
|
||||
TEST( c6_0, 0, "c6_0" );
|
||||
TEST( c6_0, 0, "c6_0: The operation completed successfully" );
|
||||
TEST( c6_1, 1, "c6_1: Incorrect function" );
|
||||
|
||||
return 0;
|
||||
return ::boost::report_errors();
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -7,12 +7,13 @@
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories="../../../../.."
|
||||
PreprocessorDefinitions="BOOST_ALL_NO_LIB"
|
||||
PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK"
|
||||
ExceptionHandling="2"
|
||||
WarningLevel="4"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
Description="Executing test $(TargetName).exe..."
|
||||
CommandLine=""$(TargetDir)\$(TargetName).exe" --result_code=no --report_level=no"
|
||||
Description=""
|
||||
CommandLine=""
|
||||
/>
|
||||
</VisualStudioPropertySheet>
|
||||
|
||||
@ -47,7 +47,7 @@
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="3"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
WarningLevel="4"
|
||||
DebugInformationFormat="4"
|
||||
/>
|
||||
<Tool
|
||||
@ -86,6 +86,8 @@
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
Description="Executing test $(TargetName).exe..."
|
||||
CommandLine=""$(TargetDir)\$(TargetName).exe" --result_code=no --report_level=no"
|
||||
/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
@ -120,7 +122,7 @@
|
||||
RuntimeLibrary="2"
|
||||
EnableFunctionLevelLinking="true"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
WarningLevel="4"
|
||||
DebugInformationFormat="3"
|
||||
/>
|
||||
<Tool
|
||||
@ -161,6 +163,8 @@
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
Description="Executing test $(TargetName).exe..."
|
||||
CommandLine=""$(TargetDir)\$(TargetName).exe" --result_code=no --report_level=no"
|
||||
/>
|
||||
</Configuration>
|
||||
</Configurations>
|
||||
@ -172,10 +176,6 @@
|
||||
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
|
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||
>
|
||||
<File
|
||||
RelativePath="..\..\..\src\error_code.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\..\error_code_test.cpp"
|
||||
>
|
||||
|
||||
@ -2,6 +2,27 @@
|
||||
Microsoft Visual Studio Solution File, Format Version 10.00
|
||||
# Visual C++ Express 2008
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "error_code_test", "error_code_test\error_code_test.vcproj", "{81960557-E9A9-4E81-AC96-9E11C33CB058}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system_error_test", "system_error_test\system_error_test.vcproj", "{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dynamic_link_test", "dynamic_link_test\dynamic_link_test.vcproj", "{AD186B11-9132-48A9-9F24-3522C2310B0D}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7} = {F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system_dll", "system_dll\system_dll.vcproj", "{22892211-A1F3-435B-8B97-A12E8772599E}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "throw_test_dll", "throw_test_dll\throw_test_dll.vcproj", "{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
@ -13,6 +34,22 @@ Global
|
||||
{81960557-E9A9-4E81-AC96-9E11C33CB058}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{81960557-E9A9-4E81-AC96-9E11C33CB058}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{81960557-E9A9-4E81-AC96-9E11C33CB058}.Release|Win32.Build.0 = Release|Win32
|
||||
{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Release|Win32.Build.0 = Release|Win32
|
||||
{AD186B11-9132-48A9-9F24-3522C2310B0D}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{AD186B11-9132-48A9-9F24-3522C2310B0D}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{AD186B11-9132-48A9-9F24-3522C2310B0D}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{AD186B11-9132-48A9-9F24-3522C2310B0D}.Release|Win32.Build.0 = Release|Win32
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{22892211-A1F3-435B-8B97-A12E8772599E}.Release|Win32.Build.0 = Release|Win32
|
||||
{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Release|Win32.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
|
||||
31
test/throw_test.cpp
Normal file
31
test/throw_test.cpp
Normal file
@ -0,0 +1,31 @@
|
||||
// throw_test.cpp --------------------------------------------------------===========-//
|
||||
|
||||
// Copyright Beman Dawes 2010
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// Library home page is www.boost.org/libs/system
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// See dynamic_link_test.cpp comments for use case.
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// define BOOST_SYSTEM_SOURCE so that <boost/system/config.hpp> knows
|
||||
// the library is being built (possibly exporting rather than importing code)
|
||||
#define BOOST_SYSTEM_SOURCE
|
||||
|
||||
#include <boost/system/system_error.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
BOOST_SYSTEM_DECL void throw_test()
|
||||
{
|
||||
throw system_error(9999, system_category(), "boo boo");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user