Boost-Commit :

Date view	Thread view	Subject view	Author view

From: fernando.cacciola_at_[hidden]
Date: 2007-11-02 18:55:50

Next message: fernando.cacciola_at_[hidden]: "[Boost-commit] svn:boost r40705 - trunk/boost/optional"
Previous message: fmhess_at_[hidden]: "[Boost-commit] svn:boost r40703 - trunk/tools/boostbook/xsl"

Author: fcacciola
Date: 2007-11-02 18:55:49 EDT (Fri, 02 Nov 2007)
New Revision: 40704
URL: http://svn.boost.org/trac/boost/changeset/40704

Log:
Merged changests from RC_1_34_0 - base rev 33417
Removed:
   trunk/libs/optional/test/optional_test_ref_fail2.cpp
Text files modified:
   trunk/libs/optional/doc/optional.html | 453 +++++++++++++++++++++++++--------------
   trunk/libs/optional/test/Jamfile.v2 | 2
   trunk/libs/optional/test/optional_test.cpp | 58 ++++
   trunk/libs/optional/test/optional_test_ref.cpp | 18 +
   4 files changed, 362 insertions(+), 169 deletions(-)

Modified: trunk/libs/optional/doc/optional.html
==============================================================================
--- trunk/libs/optional/doc/optional.html (original)
+++ trunk/libs/optional/doc/optional.html 2007-11-02 18:55:49 EDT (Fri, 02 Nov 2007)
@@ -3,6 +3,7 @@
<HTML>

<HEAD>
+<meta http-equiv="Content-Language" content="en-us">
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
@@ -23,6 +24,7 @@
 <DT>Examples</DT>
 <DT>Optional references</DT>
 <DT>Rebinding semantics for assignment of optional references</DT>
+ <DT>none_t and none</DT>
 <DT>In-Place Factories</DT>
 <DT>A note about optional<bool></DT>
 <DT>Exception Safety Guarantees</DT>
@@ -138,7 +140,7 @@
purpose of optional<T> suggests
an alternative model: a container that either has a value of T or nothing.

-As of this writing I don't know of any precedence for a variable-size fixed-capacity (of 1)
+As of this writing I don't know of any precedent for a variable-size fixed-capacity (of 1)
stack-based container model for optional values, yet I believe this is the consequence of
the lack of practical implementations of such a container rather than an inherent shortcoming
of the container model.
@@ -348,7 +350,7 @@
 T const& get() const ;
 T& get() ;

- T const& get_value_or( T const& default ) const ; [new in 1.34]
+ T const& get_value_or( T const& default ) const ; [new in 1.34]

 T const* operator ->() const ;
 T* operator ->() ;
@@ -383,11 +385,59 @@

template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ;

+template<class T> inline bool operator == ( optional<T> const& x, T const& n ) ; [new in 1.34]
+
+template<class T> inline bool operator != ( optional<T> const& x, T const& n ) ; [new in 1.34]
+
+template<class T> inline bool operator < ( optional<T> const& x, T const& n ) ; [new in 1.34]
+
+template<class T> inline bool operator > ( optional<T> const& x, T const& n ) ; [new in 1.34]
+
+template<class T> inline bool operator <= ( optional<T> const& x, T const& n ) ; [new in 1.34]
+
+template<class T> inline bool operator >= ( optional<T> const& x, T const& n ) ; [new in 1.34]
+
+template<class T> inline bool operator == ( T const& n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator != ( T const& n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator < ( T const& n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator > ( T const& n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator <= ( T const& n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator >= ( T const& n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator == ( optional<T> const& x, none_t n ) ; [new in 1.34]
+
+template<class T> inline bool operator != ( optional<T> const& x, none_t n ) ; [new in 1.34]
+
+template<class T> inline bool operator < ( optional<T> const& x, none_t n ) ; [new in 1.34]
+
+template<class T> inline bool operator > ( optional<T> const& x, none_t n ) ; [new in 1.34]
+
+template<class T> inline bool operator <= ( optional<T> const& x, none_t n ) ; [new in 1.34]
+
+template<class T> inline bool operator >= ( optional<T> const& x, none_t n ) ; [new in 1.34]
+
+template<class T> inline bool operator == ( none_t n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator != ( none_t n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator < ( none_t n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator > ( none_t n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator <= ( none_t n, optional<T> const& y ) ; [new in 1.34]
+
+template<class T> inline bool operator >= ( none_t n, optional<T> const& y ) ; [new in 1.34]
+
template<class T> inline optional<T> make_optional ( T const& v ) ; [new in 1.34]

template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; [new in 1.34]

-template<class T> inline T const& get_optional_value_or ( optional<T> const& opt, T const& default ) ; [new in 1.34]
+template<class T> inline T const& get_optional_value_or ( optional<T> const& opt, T const& default ) ; [new in 1.34]

template<class T> inline T const& get ( optional<T> const& opt ) ;

@@ -457,9 +507,11 @@
</blockquote>
Example:
 <blockquote>
- <pre>#include <boost/none.hpp></pre>
- <pre>optional<T> n(none) ;
-assert ( !n ) ;</pre>
+<pre>
+#include <boost/none.hpp>
+optional<int> n(boost::none) ;
+assert ( !n ) ;
+</pre>
</blockquote>
</blockquote>

@@ -476,9 +528,11 @@

Example:
<blockquote>
-<pre>T v;
+<pre>
+T v;
optional<T> opt(v);
-assert ( *opt == v ) ;</pre>
+assert ( *opt == v ) ;
+</pre>
</blockquote>
</blockquote>

@@ -492,29 +546,32 @@
Throws: Nothing.
Example:
<blockquote>
-<pre>T v;
+<pre>
+T v;
T& vref = v ;
optional<T&> opt(vref);
assert ( *opt == v ) ;
++ v ; // mutate referee
-assert (*opt == v); </pre>
+assert (*opt == v);
+</pre>
</blockquote>
</blockquote>

<HR>

<pre>optional<T (not a ref)>::optional( bool condition, T const& v ) ;
-optional<T&> ::optional( bool condition, T& v ) ;
+optional<T&> ::optional( bool condition, T& v ) ;
</pre>

<blockquote>
If condition is <code>true</code>, same as:
<pre>optional<T (not a ref)>::optional( T const& v )
-optional<T&> ::optional( T& v )
+optional<T&> ::optional( T& v )
</pre>
otherwise, same as:
-<pre>optional<T (not a ref)>::optional()
-optional<T&> ::optional()
+<pre>
+optional<T (not a ref)>::optional()
+optional<T&> ::optional()
</pre>
</blockquote>

@@ -533,7 +590,8 @@

Example:
<blockquote>
- <pre>optional<T> uninit ;
+<pre>
+optional<T> uninit ;
assert (!uninit);

optional<T> uinit2 ( uninit ) ;
@@ -562,7 +620,8 @@
reefer to the same object (they alias).
Example:
<blockquote>
- <pre>optional<T&> uninit ;
+<pre>
+optional<T&> uninit ;
assert (!uninit);

optional<T&> uinit2 ( uninit ) ;
@@ -605,7 +664,8 @@
Example:
<blockquote>

-<pre>optional<double> x(123.4);
+<pre>
+optional<double> x(123.4);
assert ( *x == 123.4 ) ;

optional<int> y(x) ;
@@ -633,7 +693,8 @@
Example:
<blockquote>

-<pre>class C { C ( char, double, std::string ) ; } ;
+<pre>
+class C { C ( char, double, std::string ) ; } ;

C v('A',123.4,"hello");

@@ -649,6 +710,27 @@

<HR>

+<pre>optional& optional<T>::operator= ( none_t n ) ;</pre>
+<blockquote>
+Effect: Same as opeator=(optional const& rhs), when rhs is default-constructed (uninitialized).
+Postconditions: *this is uninitialized
+Example:
+<blockquote>
+<pre>
+#include <boost/none.hpp>
+
+optional<int> def ;
+optional<int> opt(123) ;
+
+opt = boost::none ;
+
+assert ( opt == def ) ;
+</pre>
+</blockquote>
+</blockquote>
+
+<HR>
+
<pre>optional& optional<T (not a ref)>::operator= ( T const& rhs ) ;</pre>
<blockquote>
Effect: Assigns the value 'rhs' to an optional.
@@ -664,7 +746,8 @@
properly uninitialized]
Example:
<blockquote>
- <pre>T x;
+<pre>
+T x;
optional<T> def ;
optional<T> opt(x) ;

@@ -687,7 +770,8 @@
new object. See here for details on this behavior.
Example:
<blockquote>
- <pre>int a = 1 ;
+<pre>
+int a = 1 ;
int b = 2 ;
T& ra = a ;
T& rb = b ;
@@ -817,7 +901,7 @@
<HR>
<pre>void optional<T>::reset() ;</pre>
<blockquote>
-Deprecated: Same as operator=( detail::none_t );
+Deprecated: Same as operator=( none_t n);
</blockquote>

<HR>
@@ -852,32 +936,6 @@

<HR>

-<pre>T const& optional<T (not a ref)>::get_value_or( T const& default) const ;
-T& optional<T (not a ref)>::get_value_or( T& default ) ;
-
-inline T const& get_optional_value_or ( optional<T (not a ref)> const& o, T const& default ) ;
-inline T& get_optional_value_or ( optional<T (not a ref)>& o, T& default ) ;
-</pre>
-<blockquote>
-Returns: A reference to the contained value, if any, or <code>default</code>
-Throws: Nothing.
-Example:
-<blockquote>
- <pre>T v, z ;
-optional<T> def;
-T const& y = def.get_value_or(z);
-assert ( y == z ) ;
-
-optional<T> opt ( v );
-T const& u = get_optional_value_or(opt,z);
-assert ( u == v ) ;
-assert ( u != z ) ;
-</pre>
- </blockquote>
- <pre></pre>
-</blockquote>
-<HR>
-

<pre>T const& optional<T&>::operator*() const ;
T & optional<T&>::operator*();</pre>
@@ -907,29 +965,66 @@

<HR>

-<pre>T const* optional<T (not a ref)>::get_ptr() const ;
-T* optional<T (not a ref)>::get_ptr() ;
+<pre>T const& optional<T>::get_value_or( T const& default) const ;
+T& optional<T>::get_value_or( T& default ) ;
+
+inline T const& get_optional_value_or ( optional<T> const& o, T const& default ) ;
+inline T& get_optional_value_or ( optional<T>& o, T& default ) ;
+</pre>
+<blockquote>
+Returns: A reference to the contained value (which can be itself a reference), if any, or <code>default</code>
+Throws: Nothing.
+Example:
+<blockquote>
+ <pre>T v, z ;
+optional<T> def;
+T const& y = def.get_value_or(z);
+assert ( y == z ) ;
+
+optional<T> opt ( v );
+T const& u = get_optional_value_or(opt,z);
+assert ( u == v ) ;
+assert ( u != z ) ;
+</pre>
+ </blockquote>
+ <pre></pre>
+</blockquote>
+
+<HR>
+
+<pre>T const* optional<T>::get_ptr() const ;
+T* optional<T>::get_ptr() ;

-inline T const* get_pointer ( optional<T (not a ref)> const& ) ;
-inline T* get_pointer ( optional<T (not a ref)> &) ;
+inline T const* get_pointer ( optional<T> const& ) ;
+inline T* get_pointer ( optional<T> &) ;
</pre>
<blockquote>
Returns: If *this is initialized, a pointer to the contained
value; else 0 (null).

Throws: Nothing.
+Notes: If T is a reference type, the pointer is to the referenced object
Notes: The contained value is permanently stored within *this, so
-you should not hold nor delete this pointer
+you should not hold nor delete this pointer.

Example:
<blockquote>
- <pre>T v;
-optional<T> opt(v);
-optional<T> const copt(v);
-T* p = opt.get_ptr() ;
-T const* cp = copt.get_ptr();
+ <pre>int v=123;
+optional<int> opt(v);
+optional<int> const copt(v);
+int* p = opt.get_ptr() ;
+int const* cp = copt.get_ptr();
assert ( p == get_pointer(opt) );
assert ( cp == get_pointer(copt) ) ;
+
+int& rv = v ;
+optional<int&> optr(rv);
+
+*(optr.get_ptr()) = 456 ;
+
+assert ( v == 456 );
+
+
</pre>
</blockquote>
</blockquote>
@@ -938,13 +1033,14 @@
<HR>

-<pre>T const* optional<T (not a ref)>::operator ->() const ;
-T* optional<T (not a ref)>::operator ->() ;
+<pre>T const* optional<T>::operator ->() const ;
+T* optional<T>::operator ->() ;
</pre>
<blockquote>
Requirements: *this is initialized.
Returns: A pointer to the contained value.
Throws: Nothing.
+Notes: If T is a reference type, the pointer is to the referenced object
Notes: The requirement is asserted via BOOST_ASSERT().
Example:
<blockquote>
@@ -952,6 +1048,14 @@
X x ;
optional<X> opt (x);
opt->mdata = 2 ;
+
+X& rx = x ;
+
+optional<X&> optr (rx);
+optr->mdata = 4 ;
+
+assert ( x.mdata = 4 )
+
</pre>
</blockquote>
</blockquote>
@@ -1155,12 +1259,49 @@
</blockquote>

<HR>
+<pre>
+bool operator == ( optional<T> const& x, T const& n );
+bool operator != ( optional<T> const& x, T const& n );
+bool operator < ( optional<T> const& x, T const& n );
+bool operator > ( optional<T> const& x, T const& n );
+bool operator <= ( optional<T> const& x, T const& n );
+bool operator >= ( optional<T> const& x, T const& n );
+bool operator == ( T const& n, optional<T> const& y );
+bool operator != ( T const& n, optional<T> const& y );
+bool operator < ( T const& n, optional<T> const& y );
+bool operator > ( T const& n, optional<T> const& y );
+bool operator <= ( T const& n, optional<T> const& y );
+bool operator >= ( T const& n, optional<T> const& y );
+</pre>
+<blockquote>
+ Returns: The result obtained by replacing the argument 'n' by optional<T>(n).
+</blockquote>
+
+<HR>
+<pre>
+bool operator == ( optional<T> const& x, none_t n );
+bool operator != ( optional<T> const& x, none_t n );
+bool operator < ( optional<T> const& x, none_t n );
+bool operator > ( optional<T> const& x, none_t n );
+bool operator <= ( optional<T> const& x, none_t n );
+bool operator >= ( optional<T> const& x, none_t n );
+bool operator == ( none_t n, optional<T> const& y );
+bool operator != ( none_t n, optional<T> const& y );
+bool operator < ( none_t n, optional<T> const& y );
+bool operator > ( none_t n, optional<T> const& y );
+bool operator <= ( none_t n, optional<T> const& y );
+bool operator >= ( none_t n, optional<T> const& y );
+</pre>
+<blockquote>
+ Returns: The result obtained by replacing the argument 'n' by optional<T>().
+</blockquote>
+<HR>

<pre>void swap ( optional<T>&amp x, optional<T&gt&amp y );</pre>

<blockquote>
Effect: If both x and y are initialized, calls <code>swap(*x,*y)</code> using std::swap. 
-If only one is initialized, say x, calls: <code>y.reset(*x); x.reset();</code> 
+If only one is initialized, say x, calls: <code>y = *x; x = boost:none;</code> 
If none is initialized, does nothing. 
Postconditions: The states of x and y interchanged.
Throws: If both are initialized, whatever swap(T&,T&) throws.
@@ -1169,7 +1310,7 @@
If only one is initialized, T::~T() and T::T( T const& ) is called. 
Exception Safety: If both are initialized, this operation has the exception
safety guarantees of swap(T&,T&). 
-If only one is initialized, it has the same basic guarantee as optional<T>::reset( T const& ). 
+If only one is initialized, it has the same basic guarantee as optional<T>::operator=( T const& ). 
Example:
<blockquote>
 <pre>T x(12);
@@ -1219,12 +1360,12 @@
<pre>optional<string> name ;
if ( database.open() )
{
-  name.reset ( database.lookup(employer_name) ) ;
+  name = database.lookup(employer_name) ;
}
else
{
  if ( can_ask_user )
-    name.reset ( user.ask(employer_name) ) ;
+    name = user.ask(employer_name) ;
}

if ( name )
@@ -1245,7 +1386,7 @@
    void clip_in_rect ( rect const& rect )
      {
         ....
-         m_clipping_rect.reset ( rect ) ; // initialized here.
+         m_clipping_rect = rect ; // initialized here.
      }

    void draw ( canvas& cvs )
@@ -1289,16 +1430,17 @@
 <li>Converting assignment</li>
 <li>InPlace construction</li>
 <li>InPlace assignment</li>
- <li>Value-access via pointer</li>
</ul>
Also, even though optional<T&> treats it wrapped pseudo-object much as a real
-value, a true real reference is stored so aliasing will ocurr: 
+value, a true real reference is stored, thus aliasing can ocurr: 

<ul>
- <li>Copies of optional<T&> will copy the references but all these references
+ <li>Copies of optional<T&> copies the reference, but all copied references
 will nonetheless reefer to the same object.</li>
- <li>Value-access will actually provide access to the referenced object rather
+ <li>Value-access provides access to the referenced object rather
 than the reference itself.</li>
+ <li>Pointer-access provides a pointer to the referenced object rather
+ than a pointer to the reference itself.</li>
</ul>

<HR>
@@ -1309,7 +1451,7 @@
<pre>int x = 1 ;
int& rx = x ;
optional<int&> ora ;
-optional<int&> orb(x) ;
+optional<int&> orb(rx) ;
ora = orb ; // now 'ora' is bound to 'x' through 'rx'
*ora = 2 ; // Changes value of 'x' through 'ora'
assert(x==2);
@@ -1320,7 +1462,7 @@
int& ra = a ;
int b = 2 ;
int& rb = b ;
-ra = rb ; // Changes the value of 'a' to 'b'
+ra = rb ; // Changes the VALUE of 'a' to that of 'b'
assert(a==b);
b = 3 ;
assert(ra!=b); // 'ra' is not rebound to 'b'
@@ -1346,38 +1488,68 @@
It is true that optional strives to behave as much as possible as U does
whenever it is initialized; but in the case when U is T&, doing so would result
in inconsistent behavior w.r.t to the lvalue initialization state.
-Imagine optional<T&> forwarding assignment to the referenced object (thus
-changing the referenced object value but not rebinding), and consider the
-following code :
-<pre>  optional<int&> a = get();
-  int x = 1 ;
-  int& rx = x ;
-  optional<int&> b(rx);
-  a = b ;
-</pre>
-What does the assignment do? 
-If 'a' is uninitialized, the answer is clear: it binds to 'x' (we now have
-another reference to 'x'). 
-But what if 'a' is already initialized? it would change the value of the
-referenced object (whatever that is); which is inconsistent with the other
-possible case.
-If optional<T&> would assign just like T& does, you would never be able to
-use Optional's assignment without explicitly handling the previous
-initialization state unless your code is capable of functioning whether after
-the assignment, 'a'
-aliases the same object as 'b' or not.
-That is, you would have to discriminate in order to be consistency. 
- 
-If in your code rebinding to another object is not an option, then is very
-likely that binding for the fist time isn't either. In such case, assignment to
-an uninitialized optional<T&> shall be prohibited. It is quite
-possible that in such scenario the precondition that the lvalue must be already
-initialized exist. If it doesn't, then binding for the first time is OK while
-rebinding is not which is IMO
-very unlikely. 
-In such scenario, you can assign the value itself directly, as in:
-<pre>assert(!!opt);
-*opt=value; </pre>
+Consider the following code :
+<pre>
+int x = 1 ;
+int& rx = x ;
+void foo ( optional<int&> & outer )
+{
+ optional<int&> b(rx);
+ outer = b ;
+}
+</pre>
+What should the assignment to 'outer' do? 
+If 'outer' is uninitialized, the answer is clear: it should bind to 'x' (so we now have
+a second reference to 'x'). 
+But what if 'outer' is already initialized? 
+The assignment could change the value of the
+referenced object (whatever that is), but doing that would be inconsistent with the uninitialized case
+and then you wouldn't be able to reason at compile time about all the references to x since
+the appearance of a new reference to it would depend on wheter the lvalue ('outer')
+is initialized or not.
+Arguably, if rebinding the reference to another object is wrong for your code, then is
+likely that binding it for the fist time via assignment instead of intialization is also wrong.
+In that case, you can always just assign the value to the referenced object directly via
+the access operator <code>*opt=value</code>.
+If rebinding is wrong but first-time binding
+isn't (via assignment), you can always work around the rebinding semantics using a discriminator:
+<pre>
+if ( !opt )
+ opt = value ; // first-time binding
+else *opt = value ; // assign to referee without rebinding
+</pre>
+
+<HR>
+
+<H2><A NAME="none">none_t and none</A></H2>
+optional<T> supports uninitialized states with a convenient syntax via a constant of
+the implementation-defined type <code>boost::none_t</code>, identified as <code>boost::none</code>.
+Starting with Boost version 1.34.0, both <code>boost::none_t</code> and <code>boost::none</code> are
+included in <code>boost/none.hpp</code>, which is automatically included by <code>boost/optional/optional.hpp</code>
+
+This contant is similar in purpose to NULL, except that is not a null pointer value. You can use it to initialize
+an optional<T> instance, which has the same effect of a default constructor, and you can assign it which has the
+effect of reseting the optional<T> instance. You can also use it in relational operators to make the predicate expression
+more clear.
+Here are some typical examples:
+<pre>
+#include "boost/optional/optional.hpp" // boost/none.hpp is included automatically
+
+boost::optional<int> foo ( int a )
+{
+ return some_condition(a) ? boost::make_optional(a) : boost::none ;
+
+ // NOTE: in real code you can just use this: make_optional(some_condition(a), a )
+}
+
+boost::optional<int> opt = boost::none ;
+
+if ( opt == boost::none )
+ opt = foo(123);
+
+opt = boost::none ;
+
+</pre>

<HR>

@@ -1506,9 +1678,8 @@
the maybe state represents a valid value, unlike the corresponding state
of an uninitialized optional<bool>. 
It should be carefully considered if an optional<bool> instead of a tribool is really needed
-Second, optional<> provides an implicit conversion to bool. This conversion
- refers to the initialization state and not to the contained value. 
-Using optional<bool> can lead to subtle errors due to the implicit bool conversion:
+Second, optional<> provides a simple way to test initialization state: an implicit conversion to a type that evaluates as a 'bool' in a boolean context. 
+Using optional<bool> can lead to subtle errors due to this implicit conversion:
<pre>void foo ( bool v ) ;
void bar()
{
@@ -1524,7 +1695,9 @@
integral promotions don't apply (i.e. if foo() takes an 'int' instead, it won't compile). <HR>

<H2><A NAME="exsafety">Exception Safety Guarantees</A></H2>
-<H3>Assignment and Reset:</H3>
+
+<H3>Assignment:</H3>
+IMPORTANT NOTE: This changed in 1.33.1 with respect to previous versions
Because of the current implementation (see Implementation Notes), all
of the assignment methods:
<ul>
@@ -1537,60 +1710,17 @@
 InPlaceFactory const& ) </code></li>
 <li> <code>template<class TypedInPlaceFactory> optional<T>::operator= (
 TypedInPlaceFactory const& ) </code></li>
- <li> <code>optional<T>:::reset ( T const&)</code></li>
</ul>
-Can only guarantee the basic exception safety: The lvalue optional is left uninitialized if an exception is thrown (any previous value is first destroyed using T::~T())
+cannot offer any exception safety guarantee beyond that provided by <code>T::operator=( T const& )</code>
On the other hand, the uninitializing methods:
<ul>
 <li><code>optional<T>::operator= ( detail::none_t ) </code></li>
- <li><code>optional<T>::reset()</code></li>
</ul>
-Provide the no-throw guarantee (assuming a no-throw T::~T())
-However, since <code>optional&lt&gt</code> itself doesn't throw any exceptions,
-the only source for exceptions here are T's constructor, so if you know the exception guarantees
-for T::T ( T const& ), you know that optional's assignment and reset has the same guarantees.
-<pre>//
-// Case 1: Exception thrown during assignment.
-//
-T v0(123);
-optional&ltT&gt opt0(v0);
-try
-{
-  T v1(456);
-  optional&ltT&gt opt1(v1);
-  opt0 = opt1 ;
-
-  // If no exception was thrown, assignment succeeded.
-  assert( *opt0 == v1 ) ;
-}
-catch(...)
-{
-  // If any exception was thrown, 'opt0' is reset to uninitialized.
-  assert( !opt0 ) ;
-}
-
-//
-// Case 2: Exception thrown during reset(v)
-//
-T v0(123);
-optional&ltT&gt opt(v0);
-try
-{
-  T v1(456);
-  opt.reset ( v1 ) ;
+Provides the no-throw guarantee (assuming a no-throw T::~T()) becuse it only destroys the stored object.

-  // If no exception was thrown, reset succeeded.
-  assert( *opt == v1 ) ;
-}
-catch(...)
-{
-  // If any exception was thrown, 'opt' is reset to uninitialized.
-  assert( !opt ) ;
-}
-</pre>
<H3>Swap:</H3>
<code>void swap( optional<T>&, optional<T>& )</code> has the same exception guarantee as <code>swap(T&,T&)</code> when both optionals are initialized. 
-If only one of the optionals is initialized, it gives the same basic exception guarantee as <code>optional<T>::reset( T const& )</code> (since <code>optional<T>::reset()</code> doesn't throw). 
+If only one of the optionals is initialized, it gives the same exception guarantee as <code>T::operator=( T const& )</code> (since <code>optional<T>::operator=( none_t )</code> doesn't throw). 
If none of the optionals is initialized, it has no-throw guarantee since it is a no-op. 

<HR>
@@ -1604,14 +1734,11 @@

<H2><A NAME="impl">Implementation Notes</A></H2>
optional<T> is currently implemented
- using a custom aligned storage facility built from <code>alignment_of</code> and <code>type_with_alignment</code> (both from Type Traits).
- It uses a separate boolean flag to indicate the initialization state. 
- Placement new with T's copy constructor and T's destructor
- are explicitly used to initialize,copy and destroy optional values. 
- As a result, T's default constructor is effectively by-passed, but the exception
- guarantees are basic. 
- It is planned to replace the current implementation with another with
- stronger exception safety, such as a future boost::variant<T,nil_t>. 
+ using a custom aligned storage facility built from <code>alignment_of</code> and <code>type_with_alignment</code> (both from Type Traits).
+ It uses a separate boolean flag to indicate the initialization state.
+Placement new with T's copy constructor and T's destructor
+ is explicitly used to initialize and destroy optional values. This allows T's default constructor to be effectively by-passed.
+If assignment is used and the lvalue optional is uninitialized, T's copy constructor is used. However, if it is already initialized, T's assignment operator is used. This prevents optional from offering any exception guarantee stronger than the one offered by the type T itself

<HR>

@@ -1665,12 +1792,12 @@
</blockquote>
<HR>

-Revised April 21, 2005
-© Copyright Fernando Luis Cacciola Carballal, 2003,2004,2005
+Revised March 27, 2007
+© Copyright Fernando Luis Cacciola Carballal, 2003-2007
 Use, modification, and distribution are subject to the Boost Software
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at www.boost.org/LICENSE_1_0.txt)
Developed by <A HREF="mailto:fernando_cacciola_at_[hidden]">Fernando Cacciola</A>,
the latest version of this file can be found at <A
HREF="http://www.boost.org">www.boost.org</A>, and the boost discussion lists
</pre></BODY>
-</HTML>
+</HTML>
\ No newline at end of file

Modified: trunk/libs/optional/test/Jamfile.v2
==============================================================================
--- trunk/libs/optional/test/Jamfile.v2 (original)
+++ trunk/libs/optional/test/Jamfile.v2 2007-11-02 18:55:49 EDT (Fri, 02 Nov 2007)
@@ -22,11 +22,9 @@
     [ run optional_test_inplace.cpp ]
     [ run optional_test_io.cpp ]
     [ compile-fail optional_test_fail1.cpp ]
- [ compile-fail optional_test_fail2.cpp ]
     [ compile-fail optional_test_fail3a.cpp ]
     [ compile-fail optional_test_fail3b.cpp ]
     [ compile-fail optional_test_ref_fail1.cpp ]
- [ compile-fail optional_test_ref_fail2.cpp ]
     [ compile-fail optional_test_ref_fail3.cpp ]
     [ compile-fail optional_test_ref_fail4.cpp ]
     [ compile-fail optional_test_inplace_fail.cpp ]

Modified: trunk/libs/optional/test/optional_test.cpp
==============================================================================
--- trunk/libs/optional/test/optional_test.cpp (original)
+++ trunk/libs/optional/test/optional_test.cpp 2007-11-02 18:55:49 EDT (Fri, 02 Nov 2007)
@@ -704,16 +704,16 @@
{
 TRACE( std::endl << BOOST_CURRENT_FUNCTION );

- T v0(18);
- T v1(19);
- T v2(19);
+ T v0(0);
+ T v1(1);
+ T v2(1);

 optional<T> def0 ;
 optional<T> def1 ;
 optional<T> opt0(v0);
 optional<T> opt1(v1);
 optional<T> opt2(v2);
-
+
 // Check identity
 BOOST_CHECK ( def0 == def0 ) ;
 BOOST_CHECK ( opt0 == opt0 ) ;
@@ -751,6 +751,33 @@
 BOOST_CHECK ( opt1 > opt0 ) ;
 BOOST_CHECK ( opt1 <= opt2 ) ;
 BOOST_CHECK ( opt1 >= opt0 ) ;
+
+ // Compare against a value directly
+ BOOST_CHECK ( opt0 == v0 ) ;
+ BOOST_CHECK ( opt0 != v1 ) ;
+ BOOST_CHECK ( opt1 == v2 ) ;
+ BOOST_CHECK ( opt0 < v1 ) ;
+ BOOST_CHECK ( opt1 > v0 ) ;
+ BOOST_CHECK ( opt1 <= v2 ) ;
+ BOOST_CHECK ( opt1 >= v0 ) ;
+ BOOST_CHECK ( v0 != opt1 ) ;
+ BOOST_CHECK ( v1 == opt2 ) ;
+ BOOST_CHECK ( v0 < opt1 ) ;
+ BOOST_CHECK ( v1 > opt0 ) ;
+ BOOST_CHECK ( v1 <= opt2 ) ;
+ BOOST_CHECK ( v1 >= opt0 ) ;
+ BOOST_CHECK ( def0 != v0 ) ;
+ BOOST_CHECK ( !(def0 == v0) ) ;
+ BOOST_CHECK ( def0 < v0 ) ;
+ BOOST_CHECK ( !(def0 > v0) ) ;
+ BOOST_CHECK ( def0 <= v0 ) ;
+ BOOST_CHECK ( !(def0 >= v0) ) ;
+ BOOST_CHECK ( v0 != def0 ) ;
+ BOOST_CHECK ( !(v0 == def0) ) ;
+ BOOST_CHECK ( !(v0 < def0) ) ;
+ BOOST_CHECK ( v0 > def0 ) ;
+ BOOST_CHECK ( !(v0 <= def0) ) ;
+ BOOST_CHECK ( v0 >= opt0 ) ;
}

template<class T>
@@ -767,6 +794,10 @@
 BOOST_CHECK ( def0 == none ) ;
 BOOST_CHECK ( non_def != none ) ;
 BOOST_CHECK ( !def1 ) ;
+ BOOST_CHECK ( !(non_def < none) ) ;
+ BOOST_CHECK ( non_def > none ) ;
+ BOOST_CHECK ( !(non_def <= none) ) ;
+ BOOST_CHECK ( non_def >= none ) ;

 non_def = none ;
 BOOST_CHECK ( !non_def ) ;
@@ -774,6 +805,24 @@
 test_default_implicit_construction(T(1),none);
}

+template<class T>
+void test_arrow( T const* )
+{
+ TRACE( std::endl << BOOST_CURRENT_FUNCTION );
+
+ T a(1234);
+
+ optional<T> oa(a) ;
+ optional<T> const coa(a) ;
+
+ BOOST_CHECK ( coa->V() == 1234 ) ;
+
+ oa->V() = 4321 ;
+
+ BOOST_CHECK ( a.V() = 1234 ) ;
+ BOOST_CHECK ( (*oa).V() = 4321 ) ;
+}
+
void test_with_builtin_types()
{
 TRACE( std::endl << BOOST_CURRENT_FUNCTION );
@@ -804,6 +853,7 @@
 test_throwing_swap( ARG(X) );
 test_relops( ARG(X) ) ;
 test_none( ARG(X) ) ;
+ test_arrow( ARG(X) ) ;
 BOOST_CHECK ( X::count == 0 ) ;
}

Modified: trunk/libs/optional/test/optional_test_ref.cpp
==============================================================================
--- trunk/libs/optional/test/optional_test_ref.cpp (original)
+++ trunk/libs/optional/test/optional_test_ref.cpp 2007-11-02 18:55:49 EDT (Fri, 02 Nov 2007)
@@ -299,6 +299,23 @@
 BOOST_CHECK ( !non_def ) ;
}

+template<class T>
+void test_arrow( T const* )
+{
+ TRACE( std::endl << BOOST_CURRENT_FUNCTION );
+
+ T a(1234);
+
+ optional<T&> oa(a) ;
+ optional<T&> const coa(a) ;
+
+ BOOST_CHECK ( coa->V() == 1234 ) ;
+
+ oa->V() = 4321 ;
+
+ BOOST_CHECK ( a.V() = 4321 ) ;
+}
+
void test_with_builtin_types()
{
 TRACE( std::endl << BOOST_CURRENT_FUNCTION );
@@ -315,6 +332,7 @@
 test_basics( ARG(X) );
 test_relops( ARG(X) ) ;
 test_none ( ARG(X) ) ;
+ test_arrow ( ARG(X) ) ;

 BOOST_CHECK ( X::count == 0 ) ;
}

Deleted: trunk/libs/optional/test/optional_test_ref_fail2.cpp
==============================================================================
--- trunk/libs/optional/test/optional_test_ref_fail2.cpp 2007-11-02 18:55:49 EDT (Fri, 02 Nov 2007)
+++ (empty file)
@@ -1,23 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/lib/optional for documentation.
-//
-// You are welcome to contact the author at:
-// fernando_cacciola_at_[hidden]
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void optional_reference__test_no_ptr_access()
-{
- boost::optional<int&> opt ;
- opt.get_ptr();
-}
-
-

Next message: fernando.cacciola_at_[hidden]: "[Boost-commit] svn:boost r40705 - trunk/boost/optional"
Previous message: fmhess_at_[hidden]: "[Boost-commit] svn:boost r40703 - trunk/tools/boostbook/xsl"

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