Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r83197 - in trunk: boost/system libs/system/doc
From: bdawes_at_[hidden]
Date: 2013-02-27 21:13:57

Next message: pdimov_at_[hidden]: "[Boost-commit] svn:boost r83198 - in trunk/boost/smart_ptr: . detail"
Previous message: chhenning_at_[hidden]: "[Boost-commit] svn:boost r83196 - trunk/boost/gil"

Author: bemandawes
Date: 2013-02-27 21:13:56 EST (Wed, 27 Feb 2013)
New Revision: 83197
URL: http://svn.boost.org/trac/boost/changeset/83197

Log:
Add BOOST_SYSTEM_NOEXCEPT to several functions previously missed. Update documentation to reflect use of noexcept with fallback to C++03 when C++11 feature not present.
Text files modified:
   trunk/boost/system/error_code.hpp | 10
   trunk/libs/system/doc/reference.html | 248 +++++++++++++++++----------------------
   2 files changed, 115 insertions(+), 143 deletions(-)

Modified: trunk/boost/system/error_code.hpp
==============================================================================
--- trunk/boost/system/error_code.hpp (original)
+++ trunk/boost/system/error_code.hpp 2013-02-27 21:13:56 EST (Wed, 27 Feb 2013)
@@ -388,7 +388,7 @@
 || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
 }

- private:
+ private:
 int m_val;
 const error_category * m_cat;

@@ -422,13 +422,13 @@
 // non-member functions ------------------------------------------------//

 inline bool operator!=( const error_code & lhs,
- const error_code & rhs )
+ const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
 {
 return !(lhs == rhs);
 }

 inline bool operator!=( const error_condition & lhs,
- const error_condition & rhs )
+ const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
 {
 return !(lhs == rhs);
 }
@@ -480,11 +480,11 @@
 namespace errc
 {
 // explicit conversion:
- inline error_code make_error_code( errc_t e )
+ inline error_code make_error_code( errc_t e ) BOOST_SYSTEM_NOEXCEPT
 { return error_code( e, generic_category() ); }

 // implicit conversion:
- inline error_condition make_error_condition( errc_t e )
+ inline error_condition make_error_condition( errc_t e ) BOOST_SYSTEM_NOEXCEPT
 { return error_condition( e, generic_category() ); }
 }

Modified: trunk/libs/system/doc/reference.html
==============================================================================
--- trunk/libs/system/doc/reference.html (original)
+++ trunk/libs/system/doc/reference.html 2013-02-27 21:13:56 EST (Wed, 27 Feb 2013)
@@ -38,6 +38,7 @@
 <tr>
 <td width="100%" bgcolor="#E8F5FF">
 <a href="#Introduction">Introduction</a> 
+ C++11 
 <a href="#Macros">Macros</a> 
 <a href="#Deprecated-names">Deprecated names</a> 
 <a href="#Breaking-changes">Breaking changes</a> 
@@ -70,11 +71,15 @@

<h2><a name="Introduction">Introduction</a></h2>

-This reference documentation describes components that 
-programs may use to report error conditions originating from the operating
+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.
@@ -178,6 +183,9 @@
 namespace system
 {
 class error_category;
+ const error_category & system_category() noexcept;
+ const error_category & generic_category() noexcept;
+
 class error_code;
 class error_condition;

@@ -281,21 +289,21 @@

 // non-member functions

- bool operator==( const error_code & lhs, const error_code & rhs );
- bool operator==( const error_code & code, const error_condition & condition );
- bool operator==( const error_condition & condition, const error_code & code );
- bool operator==( const error_condition & lhs, const error_condition & rhs );
-
- bool operator!=( const error_code & lhs, const error_code & rhs );
- bool operator!=( const error_code & code, const error_condition & condition );
- bool operator!=( const error_condition & condition, const error_code & code );
- bool operator!=( const error_condition & lhs, const error_condition & rhs );
+ 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 );
- bool operator<( const error_condition & lhs, const error_condition & rhs );
+ 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 );
- error_condition make_error_condition( errc::errc_t e );
+ 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>&
@@ -312,6 +320,17 @@
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.
@@ -336,37 +355,33 @@
 public:
 virtual ~error_category();

- virtual const char * name() const = 0;
+ virtual const char * name() const noexcept = 0;
 virtual string message( int ev ) const = 0;
- virtual error_condition default_error_condition( int ev ) const;
- virtual bool equivalent( int code, const error_condition & condition ) const;
- virtual bool equivalent( const error_code & code, int condition ) const;
-
- bool operator==( const error_category & rhs ) const;
- bool operator!=( const error_category & rhs ) const;
- bool operator< ( const error_category & rhs ) const;
+ 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;
 };
-
- const error_category & system_category();
- const error_category & generic_category();
 }
}</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=0;</pre>
+<pre>virtual const char * name() const noexcept =0;</pre>
<blockquote>
 Returns: a string naming the error category.
- Throws: Nothing.
</blockquote>
-<pre>virtual string message( int ev ) const=0;</pre>
+<pre>virtual string message( int ev ) const noexcept =0;</pre>
<blockquote>
 Returns: A string that describes the error denoted by
 <code>ev</code>.
- Throws: Nothing.
</blockquote>
-<code>virtual error_condition default_error_condition( int ev ) const;</code>
+<pre>virtual error_condition default_error_condition( int ev ) const noexcept;</pre>
<blockquote>
 Returns:  <code>error_condition( ev, *this )</code>.
 <blockquote>
@@ -375,52 +390,33 @@
 and return it as an <code>error_condition</code> for that category. --end
 note]
 </blockquote>
- Throws: Nothing.
-</blockquote>
-<code>virtual bool equivalent( int code, const error_condition &
-condition )
-const;</code>
+ </blockquote>
+<pre>virtual bool equivalent( int code, const error_condition & condition ) const noexcept;</pre>
<blockquote>
 Returns: <code>default_error_condition( code ) == condition</code>.
- Throws: Nothing.
-</blockquote>
-<code>virtual bool equivalent( const error_code & code, int condition ) const;</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>.
- Throws: Nothing.
-</blockquote>
+ </blockquote>
<h3><a name="Class-error_category-non-virtual-members">Class <code>error_category</code> non-virtual members</a></h3>
-<code>bool operator==( const error_category & rhs ) const;</code>
+<pre>bool operator==( const error_category & rhs ) const noexcept;</pre>
<blockquote>
Returns: <code>this == &rhs</code>.
</blockquote>
-<code>bool operator!=( const error_category & rhs ) const;</code>
+<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;</pre>
+<pre>bool operator<( const error_category & rhs ) const noexcept;</pre>
<blockquote>
- Returns: <code>std::less<const error_category*>()( this, &rhs )</code>.
+ 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>
- Throws: Nothing.
-</blockquote>
-<h3><a name="Class-error_category-non-member-functions">Class <code>error_category</code>
-non-member functions</a></h3>
-<pre>const error_category & system_category();</pre>
-<blockquote>
- Returns: A reference to a <code>error_category</code> object
- identifying errors originating from the operating system.
- Throws: Nothing.
-</blockquote>
-<pre>const error_category & generic_category();</pre>
-<blockquote>
- Returns: A reference to a <code>error_category</code> object
- identifying portable error conditions.
- Throws: Nothing.
</blockquote>
<h2><a name="Class-error_code">Class <code>
error_code</code></a></h2>
@@ -440,21 +436,21 @@
 public:

 // constructors:
- error_code();
- error_code( val, const error_category & cat );
+ error_code() noexcept;
+ error_code( val, const error_category & cat ) noexcept;
 template <class <code>ErrorCodeEnum</code>>
- error_code(<code> ErrorCodeEnum</code> e );
+ error_code(<code> ErrorCodeEnum</code> e ) noexcept;

 // modifiers:
- void assign( int val, const error_category & cat );
+ void assign( int val, const error_category & cat ) noexcept;
 template<typename <code>ErrorCodeEnum</code>>
- error_code & operator=( <code>ErrorCodeEnum</code> val );;
- void clear();
+ error_code & operator=( <code>ErrorCodeEnum</code> val ) noexcept;
+ void clear() noexcept;

 // observers:
- int value() const;
- cont error_category & category() const;
- error_condition default_error_condition() const;
+ 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;

@@ -467,71 +463,63 @@
</blockquote>
<h3><a name="Class-error_code-constructors">Class <code>
error_code</code> constructors</a></h3>
-<pre>error_code();</pre>
+<pre>error_code() noexcept;</pre>
<blockquote>
 Effects: Constructs an object of type <code>error_code</code>.
 Postconditions: <code>val_ == 0 && cat_ == &system_category()</code>.
- Throws: Nothing.
</blockquote>
-<pre>error_code( int val, const error_category & cat );</pre>
+<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>.
- Throws: Nothing.
</blockquote>
<pre>template <class <code>ErrorCodeEnum</code>>
- error_code(<code> ErrorCodeEnum</code> val );</pre>
+ 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>.
- Throws: Nothing.
 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 );</pre>
+<pre>void assign( int val, const error_category & cat ) noexcept;</pre>
<blockquote>
 Postconditions: <code>val_ == val && cat_ == &cat</code>.
- Throws: Nothing.
</blockquote>
<pre>template<typename <code>ErrorCodeEnum</code>>
- error_code & operator=( <code>ErrorCodeEnum</code> val );</pre>
+ error_code & operator=( <code>ErrorCodeEnum</code> val ) noexcept;</pre>
<blockquote>
 Postconditions: <code>*this == make_error_code( val )</code>.
- Throws: Nothing.
 Remarks: This operator shall not participate in overload resolution
 unless <code>is_error_code_enum<ErrorCodeEnum>::value</code> is <code>true</code>.
</blockquote>
-<code>void clear();</code>
+<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>
- <code>int value() const;</code>
+ <pre><code>int value() const noexcept;</code></pre>
<blockquote>
Returns: <code>val_</code>.
- Throws: Nothing.
-</blockquote>
- <code>const error_category & category() const;</code>
+ </blockquote>
+<pre><code>const error_category & category() const noexcept;</code></pre>
<blockquote>
Returns: <code>*cat_</code>.
- Throws: Nothing.
-</blockquote>
- <pre>error_condition default_error_condition() const;</pre>
+ </blockquote>
+ <pre>error_condition default_error_condition() const noexcept;</pre>
<blockquote>
Returns:  <code>category().default_error_condition( value())</code>.
- Throws: Nothing.
</blockquote>
- <code>string message() const;</code>
+ <pre><code>string message() const;</code></pre>
<blockquote>
Returns:  <code>category().message( value())</code>.
 Throws: Nothing.
</blockquote>
-<code>operator unspecified-bool-type() const;</code>
+<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
@@ -560,22 +548,22 @@
 public:

 // constructors:
- error_condition();
- error_condition( int val, const error_category & cat );
+ error_condition() noexcept;
+ error_condition( int val, const error_category & cat ) noexcept;
 template <class ErrorConditionEnum>
- error_condition( errorConditionEnum val );
+ error_condition( errorConditionEnum val ) noexcept;

 // modifiers:
- void assign( int val, const error_category & cat );
+ void assign( int val, const error_category & cat ) noexcept;
 template<typename ErrorConditionEnum>
- error_condition & operator=( ErrorConditionEnum val );
- void clear();
+ error_condition & operator=( ErrorConditionEnum val ) noexcept;
+ void clear() noexcept;

 // observers:
- int value() const;
- const error_category & category() const;
+ int value() const noexcept;
+ const error_category & category() const noexcept;
 string message() const;
- operator unspecified-bool-type () const;
+ operator unspecified-bool-type () const noexcept;

 private:
 int val_; // exposition only
@@ -586,65 +574,57 @@
</blockquote>
<h3><a name="Class-error_condition-constructors">Class <code>error_condition</code>
constructors</a></h3>
-<pre>error_condition(); </pre>
+<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>.
- Throws: Nothing.
</blockquote>
-<pre>error_condition( int val, const error_category & cat );</pre>
+<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>.
- Throws: Nothing.
</blockquote>
<pre>template <class ErrorConditionEnum>
- error_condition( ErrorConditionEnum e );</pre>
+ 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>.
- Throws: Nothing.
 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 ); </pre>
+<pre>void assign( int val, const error_category & cat ) noexcept; </pre>
<blockquote>
 Postconditions: <code>val_ == val and cat_ == &cat</code>. 
- Throws: Nothing.
</blockquote>
<pre>template<typename ErrorConditionEnum>
- error_condition & operator=( ErrorConditionEnum e );</pre>
+ error_condition & operator=( ErrorConditionEnum e ) noexcept;</pre>
<blockquote>
 Postconditions: <code>*this == make_error_condition( e )</code>.
 Returns: <code>*this</code>.
- Throws: Nothing.
 Remarks: This operator shall not participate in overload resolution
 unless <code>is_error_condition_enum<ErrorConditionEnum>::value</code> is
 <code>true</code>.
</blockquote>
-<code>void clear();</code>
+<pre>void clear() noexcept;</pre>
<blockquote>
- postcondition: <code>value() == 0 && category() == generic_category()</code>
+ 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;</pre>
+<pre>int value() const noexcept;</pre>
<blockquote>
 Returns: <code>val_</code>.
- Throws: Nothing
</blockquote>
-<pre>const error_category & category() const;</pre>
+<pre>const error_category & category() const noexcept;</pre>
<blockquote>
 Returns: <code>*cat_</code>.
- Throws: Nothing.
</blockquote>
<pre>string message() const;</pre>
<blockquote>
 Returns: <code>category().message( value() )</code>.
- Throws: Nothing.
</blockquote>
<pre>operator unspecified-bool-type () const;</pre>
<blockquote>
@@ -690,58 +670,50 @@
 </blockquote>
</blockquote>
<h2><a name="Non-member-functions">Non-member functions</a></h2>
- <pre>bool operator==( const error_code & lhs, const error_code & rhs );</pre>
+ <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>.
- Throws: Nothing.
</blockquote>
-<pre>bool operator==( const error_code & code, const error_condition & condition );
-bool operator==( const error_condition & condition, const error_code & code );</pre>
+<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>.
- Throws: Nothing.
</blockquote>
-<pre>bool operator==( const error_condition & lhs, const error_condition & rhs );</pre>
+<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>.
- Throws: Nothing.
</blockquote>
-<pre>bool operator!=( const error_code & lhs, const error_code & rhs );</pre>
+<pre>bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept;</pre>
<blockquote>
 Returns: <code>!(lhs == rhs )</code>.
- Throws: Nothing.
</blockquote>
-<pre>bool operator!=( const error_code & code, const error_condition & condition );
-bool operator!=( const error_condition & condition, const error_code & code );</pre>
+<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>.
- Throws: Nothing.
</blockquote>
-<pre>bool operator!=( const error_condition & lhs, const error_condition & rhs );</pre>
+<pre>bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre>
<blockquote>
 Returns: <code>!(lhs == rhs )</code>.
- Throws: Nothing.
</blockquote>
-<pre>bool operator<( const error_code & lhs, const error_code & rhs );</pre>
+<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>.
- Throws: Nothing.
</blockquote>
-<pre>bool operator<( const error_condition & lhs, const error_condition & rhs );</pre>
+<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>.
- Throws: Nothing.
</blockquote>
-<pre>error_code make_error_code( errc::errc_t e );</pre>
+<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 );</pre>
+<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>
@@ -840,10 +812,10 @@
<hr>

Revised
-June 29, 2010 
+February 27, 2013 


-© Copyright Beman Dawes, 2006, 2007, 2008
+© 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>

Next message: pdimov_at_[hidden]: "[Boost-commit] svn:boost r83198 - in trunk/boost/smart_ptr: . detail"
Previous message: chhenning_at_[hidden]: "[Boost-commit] svn:boost r83196 - trunk/boost/gil"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk