v2, v3, integration branch

[SVN r62649]

doc/Jamfile.v2

@@ -24,7 +24,7 @@ boostbook standalone
         optional
     :
         <xsl:param>boost.root=../../../..
-        <xsl:param>html.stylesheet=boostbook.css
+        <xsl:param>boost.libraries=../../../libraries.htm
         <xsl:param>toc.max.depth=2
         <xsl:param>toc.section.depth=2
         <xsl:param>chunk.section.depth=1

include/boost/detail/none_t.hpp

@@ -4,7 +4,7 @@
 // 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/libs/optional for documentation.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/optional/optional.hpp

@@ -4,7 +4,7 @@
 // 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/libs/optional for documentation.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
@@ -15,28 +15,26 @@
 #ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
 #define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
 
-#include <new>
-#include <algorithm>
+#include<new>
+#include<algorithm>
 
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/type.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/has_nothrow_constructor.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/detail/reference_content.hpp>
-#include <boost/none.hpp>
-#include <boost/utility/swap.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/utility/compare_pointees.hpp>
-#include <boost/utility/in_place_factory.hpp>
+#include "boost/config.hpp"
+#include "boost/assert.hpp"
+#include "boost/type.hpp"
+#include "boost/type_traits/alignment_of.hpp"
+#include "boost/type_traits/has_nothrow_constructor.hpp"
+#include "boost/type_traits/type_with_alignment.hpp"
+#include "boost/type_traits/remove_reference.hpp"
+#include "boost/type_traits/is_reference.hpp"
+#include "boost/mpl/if.hpp"
+#include "boost/mpl/bool.hpp"
+#include "boost/mpl/not.hpp"
+#include "boost/detail/reference_content.hpp"
+#include "boost/none.hpp"
+#include "boost/utility/compare_pointees.hpp"
+#include "boost/utility/in_place_factory.hpp"
 
-#include <boost/optional/optional_fwd.hpp>
+#include "boost/optional/optional_fwd.hpp"
 
 #if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 // VC6.0 has the following bug:
@@ -83,15 +81,6 @@
 #define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
 #endif
 
-#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 302 \
-    && !defined(__INTEL_COMPILER)
-// GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
-// regard to violation of the strict aliasing rules. The optional< T > storage type is marked
-// with this attribute in order to let the compiler know that it will alias objects of type T
-// and silence compilation warnings.
-#define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
-#endif
-
 // Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<>
 // member template of a factory as used in the optional<> implementation.
 // He proposed this simple fix which is to move the call to apply<> outside
@@ -99,7 +88,7 @@
 namespace boost_optional_detail
 {
   template <class T, class Factory>
-  inline void construct(Factory const& factory, void* address)
+  void construct(Factory const& factory, void* address)
   {
     factory.BOOST_NESTED_TEMPLATE apply<T>(address);
   }
@@ -111,9 +100,6 @@ namespace boost {
 class in_place_factory_base ;
 class typed_in_place_factory_base ;
 
-// This forward is needed to refer to namespace scope swap from the member swap
-template<class T> void swap ( optional<T>& x, optional<T>& y );
-
 namespace optional_detail {
 
 // This local class is used instead of that in "aligned_storage.hpp"
@@ -124,12 +110,7 @@ template <class T>
 class aligned_storage
 {
     // Borland ICEs if unnamed unions are used for this!
-    union
-    // This works around GCC warnings about breaking strict aliasing rules when casting storage address to T*
-#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
-    __attribute__((may_alias))
-#endif
-    dummy_u
+    union dummy_u
     {
         char data[ sizeof(T) ];
         BOOST_DEDUCED_TYPENAME type_with_alignment<
@@ -138,13 +119,8 @@ class aligned_storage
 
   public:
 
-#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
-    void const* address() const { return &dummy_; }
-    void      * address()       { return &dummy_; }
-#else
-    void const* address() const { return dummy_.data; }
-    void      * address()       { return dummy_.data; }
-#endif
+    void const* address() const { return &dummy_.data[0]; }
+    void      * address()       { return &dummy_.data[0]; }
 } ;
 
 template<class T>
@@ -450,22 +426,8 @@ class optional_base : public optional_tag
   private :
 
     // internal_type can be either T or reference_content<T>
-#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
-    // This workaround is supposed to silence GCC warnings about broken strict aliasing rules
-    internal_type const* get_object() const
-    {
-        union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() };
-        return caster.as_ptype;
-    }
-    internal_type *      get_object()
-    {
-        union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() };
-        return caster.as_ptype;
-    }
-#else
     internal_type const* get_object() const { return static_cast<internal_type const*>(m_storage.address()); }
     internal_type *      get_object()       { return static_cast<internal_type *>     (m_storage.address()); }
-#endif
 
     // reference_content<T> lacks an implicit conversion to T&, so the following is needed to obtain a proper reference.
     reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; }
@@ -556,7 +518,7 @@ class optional : public optional_detail::optional_base<T>
     // Depending on the above some T ctor is called.
     // Can throw is the resolved T ctor throws.
     template<class Expr>
-    explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {}
+    explicit optional ( Expr const& expr ) : base(expr,&expr) {}
 #endif
 
     // Creates a deep copy of another optional<T>
@@ -570,9 +532,9 @@ class optional : public optional_detail::optional_base<T>
     // Assigns from an expression. See corresponding constructor.
     // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED
     template<class Expr>
-    optional& operator= ( Expr const& expr )
+    optional& operator= ( Expr expr )
       {
-        this->assign_expr(expr,boost::addressof(expr));
+        this->assign_expr(expr,&expr);
         return *this ;
       }
 #endif
@@ -619,7 +581,7 @@ class optional : public optional_detail::optional_base<T>
     void swap( optional & arg )
       {
         // allow for Koenig lookup
-        using boost::swap;
+        using boost::swap ;
         swap(*this, arg);
       }
 
@@ -650,9 +612,9 @@ class optional : public optional_detail::optional_base<T>
     // No-throw
     operator unspecified_bool_type() const { return this->safe_bool() ; }
 
-    // This is provided for those compilers which don't like the conversion to bool
-    // on some contexts.
-    bool operator!() const { return !this->is_initialized() ; }
+       // This is provided for those compilers which don't like the conversion to bool
+       // on some contexts.
+       bool operator!() const { return !this->is_initialized() ; }
 } ;
 
 // Returns optional<T>(v)
@@ -918,63 +880,79 @@ inline
 bool operator >= ( none_t x, optional<T> const& y )
 { return !( x < y ) ; }
 
+//
+// The following swap implementation follows the GCC workaround as found in
+//  "boost/detail/compressed_pair.hpp"
+//
 namespace optional_detail {
 
-template<bool use_default_constructor> struct swap_selector;
+// GCC < 3.2 gets the using declaration at namespace scope (FLC, DWA)
+#if BOOST_WORKAROUND(__GNUC__, < 3)                             \
+    || BOOST_WORKAROUND(__GNUC__, == 3) && __GNUC_MINOR__ <= 2
+   using std::swap;
+#define BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
+#endif
 
-template<>
-struct swap_selector<true>
-{
+  template<bool use_default_constructor> struct swap_selector;
+
+  template<>
+  struct swap_selector<true>
+  {
     template<class T>
     static void optional_swap ( optional<T>& x, optional<T>& y )
     {
-        const bool hasX = !!x;
-        const bool hasY = !!y;
+     bool hasX = x;
+     bool hasY = y;
 
-        if ( !hasX && !hasY )
-            return;
+     if ( !hasX && !hasY )
+       return;
 
-        if( !hasX )
-            x = boost::in_place();
-        else if ( !hasY )
-            y = boost::in_place();
+     if( !hasX )
+         x = boost::in_place();
+     else if ( !hasY )
+         y = boost::in_place();
 
-        // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers
-        boost::swap(x.get(),y.get());
+   // GCC > 3.2 and all other compilers have the using declaration at function scope (FLC)
+#ifndef BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
+     // allow for Koenig lookup
+     using std::swap ;
+#endif
+     swap(*x,*y);
 
-        if( !hasX )
-            y = boost::none ;
-        else if( !hasY )
-            x = boost::none ;
+     if( !hasX )
+         y = boost::none ;
+     else if( !hasY )
+         x = boost::none ;
     }
-};
+  };
 
-template<>
-struct swap_selector<false>
-{
+  template<>
+  struct swap_selector<false>
+  {
     template<class T>
     static void optional_swap ( optional<T>& x, optional<T>& y )
     {
-        const bool hasX = !!x;
-        const bool hasY = !!y;
-
-        if ( !hasX && hasY )
-        {
-            x = y.get();
-            y = boost::none ;
-        }
-        else if ( hasX && !hasY )
-        {
-            y = x.get();
-            x = boost::none ;
-        }
-        else if ( hasX && hasY )
-        {
-            // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers
-            boost::swap(x.get(),y.get());
-        }
+      if ( !x && !!y )
+      {
+        x = *y;
+        y = boost::none ;
+      }
+      else if ( !!x && !y )
+      {
+        y = *x ;
+        x = boost::none ;
+      }
+      else if ( !!x && !!y )
+      {
+    // GCC > 3.2 and all other compilers have the using declaration at function scope (FLC)
+    #ifndef BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
+        // allow for Koenig lookup
+        using std::swap ;
+    #endif
+        swap(*x,*y);
+      }
     }
-};
+  };
 
 } // namespace optional_detail
 
@@ -983,9 +961,10 @@ struct optional_swap_should_use_default_constructor : has_nothrow_default_constr
 
 template<class T> inline void swap ( optional<T>& x, optional<T>& y )
 {
-    optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
+  optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
 }
 
 } // namespace boost
 
 #endif
+

include/boost/optional/optional_fwd.hpp

@@ -4,7 +4,7 @@
 // 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/libs/optional for documentation.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/optional/optional_io.hpp

@@ -4,7 +4,7 @@
 // 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/libs/optional for documentation.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
@@ -25,8 +25,7 @@
 #  include <ostream>
 #endif  
 
-#include <boost/none.hpp>
-#include <boost/assert.hpp>
+
 #include "boost/optional/optional.hpp"
 #include "boost/utility/value_init.hpp"
 
@@ -63,30 +62,17 @@ std::basic_istream<CharType, CharTrait>&
 operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
 #endif
 {
-  if (in.good())
+  if ( in.good() )
   {
     int d = in.get();
-    if (d == ' ')
+    if ( d == ' ' )
     {
-      T x;
+      T x ;
       in >> x;
-      v = x;
+      v = x ;
     }
     else
-    {
-      if (d == '-')
-      {
-        d = in.get();
-
-        if (d == '-')
-        {
-          v = none;
-          return in;
-        }
-      }
-
-      in.setstate( std::ios::failbit );
-    }
+      v = optional<T>() ;
   }
 
   return in;

test/optional_test.cpp

@@ -1263,33 +1263,6 @@ void test_swap_tweaking()
   BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
 }
 
-// Test for support for classes with overridden operator&
-class CustomAddressOfClass
-{
-    int n;
-
-public:
-    CustomAddressOfClass() : n(0) {}
-    CustomAddressOfClass(CustomAddressOfClass const& that) : n(that.n) {}
-    explicit CustomAddressOfClass(int m) : n(m) {}
-    int* operator& () { return &n; }
-    bool operator== (CustomAddressOfClass const& that) const { return n == that.n; }
-};
-
-void test_custom_addressof_operator()
-{
-    boost::optional< CustomAddressOfClass > o1(CustomAddressOfClass(10));
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(10));
-
-    o1 = CustomAddressOfClass(20);
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(20));
-
-    o1 = boost::none;
-    BOOST_CHECK(!o1);
-}
-
 int test_main( int, char* [] )
 {
   try
@@ -1300,7 +1273,6 @@ int test_main( int, char* [] )
     test_conversions1();
     test_conversions2();
     test_swap_tweaking();
-    test_custom_addressof_operator();
   }
   catch ( ... )
   {

test/optional_test_io.cpp

@@ -55,14 +55,10 @@ void test2( Opt o, Opt buff )
 {
   stringstream s ;
 
-  const int markv = 123 ;
-  int mark = 0 ;
-  
-  s << o << " " << markv ;
-  s >> buff >> mark ;
+  s << o ;
+  s >> buff ;
 
   BOOST_ASSERT( buff == o ) ;
-  BOOST_ASSERT( mark == markv ) ;
 }
 
 
@@ -81,6 +77,7 @@ int test_main( int, char* [] )
   {
     test(1,2);
     test(string("hello"),string("buffer"));
+    test(string(""),string("buffer"));
   }
   catch ( ... )
   {