This commit was manufactured by cvs2svn to create branch

'array_wrapper'.

[SVN r31998]

include/boost/none.hpp

@@ -1,31 +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@hotmail.com
-//
-#ifndef BOOST_NONE_17SEP2003_HPP
-#define BOOST_NONE_17SEP2003_HPP
-
-#include "boost/none_t.hpp"
-
-// NOTE: Borland users have to include this header outside any precompiled headers
-// (bcc<=5.64 cannot include instance data in a precompiled header)
-
-namespace boost {
-
-namespace {
-
-none_t const none = ((none_t)0) ;
-
-}
-
-} // namespace boost
-
-#endif
-

include/boost/none_t.hpp

@@ -1,24 +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@hotmail.com
-//
-#ifndef BOOST_NONE_T_17SEP2003_HPP
-#define BOOST_NONE_T_17SEP2003_HPP
-
-namespace boost {
-
-namespace detail { struct none_helper{}; }
-
-typedef int detail::none_helper::*none_t ;
-
-} // namespace boost
-
-#endif
-

include/boost/optional.hpp

@@ -1,18 +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@hotmail.com
-//
-#ifndef BOOST_OPTIONAL_FLC_19NOV2002_HPP
-#define BOOST_OPTIONAL_FLC_19NOV2002_HPP
-
-#include "boost/optional/optional.hpp"
-
-#endif
-

include/boost/optional/optional.hpp

@@ -1,749 +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@hotmail.com
-//
-#ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
-#define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
-
-#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/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_t.hpp"
-#include "boost/utility/compare_pointees.hpp"
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// VC6.0 has the following bug:
-//   When a templated assignment operator exist, an implicit conversion
-//   constructing an optional<T> is used when assigment of the form:
-//     optional<T> opt ; opt = T(...);
-//   is compiled.
-//   However, optional's ctor is _explicit_ and the assignemt shouldn't compile.
-//   Therefore, for VC6.0 templated assignment is disabled.
-//
-#define BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-// VC7.0 has the following bug:
-//   When both a non-template and a template copy-ctor exist
-//   and the templated version is made 'explicit', the explicit is also
-//   given to the non-templated version, making the class non-implicitely-copyable.
-//
-#define BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700)
-// AFAICT only VC7.1 correctly resolves the overload set
-// that includes the in-place factory taking functions,
-// so for the other VC versions, in-place factory support
-// is disabled
-#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#endif
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551)
-// BCB (5.5.1) cannot parse the nested template struct in an inplace factory.
-#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#endif
-
-#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) \
-    && BOOST_WORKAROUND(__BORLANDC__, <= 0x564)
-// BCB (up to 5.64) has the following bug:
-//   If there is a member function/operator template of the form
-//     template<class Expr> mfunc( Expr expr ) ;
-//   some calls are resolved to this even if there are other better matches.
-//   The effect of this bug is that calls to converting ctors and assignments
-//   are incrorrectly sink to this general catch-all member function template as shown above.
-#define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
-#endif
-
-
-namespace boost {
-
-class in_place_factory_base ;
-class typed_in_place_factory_base ;
-
-namespace optional_detail {
-
-// This local class is used instead of that in "aligned_storage.hpp"
-// because I've found the 'official' class to ICE BCB5.5
-// when some types are used with optional<>
-// (due to sizeof() passed down as a non-type template parameter)
-template <class T>
-class aligned_storage
-{
-    // Borland ICEs if unnamed unions are used for this!
-    union dummy_u
-    {
-        char data[ sizeof(T) ];
-        BOOST_DEDUCED_TYPENAME type_with_alignment<
-          ::boost::alignment_of<T>::value >::type aligner_;
-    } dummy_ ;
-
-  public:
-
-    void const* address() const { return &dummy_.data[0]; }
-    void      * address()       { return &dummy_.data[0]; }
-} ;
-
-template<class T>
-struct types_when_isnt_ref
-{
-  typedef T const& reference_const_type ;
-  typedef T &      reference_type ;
-  typedef T const* pointer_const_type ;
-  typedef T *      pointer_type ;
-  typedef T const& argument_type ;
-} ;
-template<class T>
-struct types_when_is_ref
-{
-  typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type raw_type ;
-
-  typedef raw_type& reference_const_type ;
-  typedef raw_type& reference_type ;
-  typedef raw_type* pointer_const_type ;
-  typedef raw_type* pointer_type ;
-  typedef raw_type& argument_type ;
-} ;
-
-struct optional_tag {} ;
-
-template<class T>
-class optional_base : public optional_tag
-{
-  private :
-
-    typedef BOOST_DEDUCED_TYPENAME detail::make_reference_content<T>::type internal_type ;
-
-    typedef aligned_storage<internal_type> storage_type ;
-
-    typedef types_when_isnt_ref<T> types_when_not_ref ;
-    typedef types_when_is_ref<T>   types_when_ref   ;
-
-    typedef optional_base<T> this_type ;
-
-  protected :
-
-    typedef T value_type ;
-
-    typedef mpl::true_  is_reference_tag ;
-    typedef mpl::false_ is_not_reference_tag ;
-
-    typedef BOOST_DEDUCED_TYPENAME is_reference<T>::type is_reference_predicate ;
-
-    typedef BOOST_DEDUCED_TYPENAME mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;
-
-    typedef bool (this_type::*unspecified_bool_type)() const;
-
-    typedef BOOST_DEDUCED_TYPENAME types::reference_type       reference_type ;
-    typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ;
-    typedef BOOST_DEDUCED_TYPENAME types::pointer_type         pointer_type ;
-    typedef BOOST_DEDUCED_TYPENAME types::pointer_const_type   pointer_const_type ;
-    typedef BOOST_DEDUCED_TYPENAME types::argument_type        argument_type ;
-
-    // Creates an optional<T> uninitialized.
-    // No-throw
-    optional_base()
-      :
-      m_initialized(false) {}
-
-    // Creates an optional<T> uninitialized.
-    // No-throw
-    optional_base ( none_t const& )
-      :
-      m_initialized(false) {}
-
-    // Creates an optional<T> initialized with 'val'.
-    // Can throw if T::T(T const&) does
-    optional_base ( argument_type val )
-      :
-      m_initialized(false)
-    {
-      construct(val);
-    }
-
-    // Creates a deep copy of another optional<T>
-    // Can throw if T::T(T const&) does
-    optional_base ( optional_base const& rhs )
-      :
-      m_initialized(false)
-    {
-      if ( rhs.is_initialized() )
-        construct(rhs.get_impl());
-    }
-
-
-    // This is used for both converting and in-place constructions.
-    // Derived classes use the 'tag' to select the appropriate
-    // implementation (the correct 'construct()' overload)
-    template<class Expr>
-    explicit optional_base ( Expr const& expr, Expr const* tag )
-      :
-      m_initialized(false)
-    {
-      construct(expr,tag);
-    }
-
-
-
-    // No-throw (assuming T::~T() doesn't)
-    ~optional_base() { destroy() ; }
-
-    // Assigns from another optional<T> (deep-copies the rhs value)
-    void assign ( optional_base const& rhs )
-    {
-      if (is_initialized())
-      {
-        if ( rhs.is_initialized() )
-             assign_value(rhs.get_impl(), is_reference_predicate() );
-        else destroy();
-      }
-      else
-      {
-        if ( rhs.is_initialized() )
-          construct(rhs.get_impl());
-      }
-    }
-
-    // Assigns from a T (deep-copies the rhs value)
-    void assign ( argument_type val )
-    {
-      if (is_initialized())
-           assign_value(val, is_reference_predicate() );
-      else construct(val);
-    }
-
-    // Assigns from "none", destroying the current value, if any, leaving this UNINITIALIZED
-    // No-throw (assuming T::~T() doesn't)
-    void assign ( none_t const& ) { destroy(); }
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-    template<class Expr>
-    void assign_expr ( Expr const& expr, Expr const* tag )
-      {
-        if (is_initialized())
-             assign_expr_to_initialized(expr,tag);
-        else construct(expr,tag);
-      }
-#endif
-
-  public :
-
-    // Destroys the current value, if any, leaving this UNINITIALIZED
-    // No-throw (assuming T::~T() doesn't)
-    void reset() { destroy(); }
-
-    // Replaces the current value -if any- with 'val'
-    void reset ( argument_type val ) { assign(val); }
-
-    // Returns a pointer to the value if this is initialized, otherwise,
-    // returns NULL.
-    // No-throw
-    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
-    pointer_type       get_ptr()       { return m_initialized ? get_ptr_impl() : 0 ; }
-
-    bool is_initialized() const { return m_initialized ; }
-
-  protected :
-
-    void construct ( argument_type val )
-     {
-       new (m_storage.address()) internal_type(val) ;
-       m_initialized = true ;
-     }
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-    // Constructs in-place using the given factory
-    template<class Expr>
-    void construct ( Expr const& factory, in_place_factory_base const* )
-     {
-       BOOST_STATIC_ASSERT ( ::boost::mpl::not_<is_reference_predicate>::value ) ;
-       factory.BOOST_NESTED_TEMPLATE apply<value_type>(m_storage.address()) ;
-       m_initialized = true ;
-     }
-
-    // Constructs in-place using the given typed factory
-    template<class Expr>
-    void construct ( Expr const& factory, typed_in_place_factory_base const* )
-     {
-       BOOST_STATIC_ASSERT ( ::boost::mpl::not_<is_reference_predicate>::value ) ;
-       factory.apply(m_storage.address()) ;
-       m_initialized = true ;
-     }
-
-    template<class Expr>
-    void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag )
-     {
-       destroy();
-       construct(factory,tag);
-     }
-
-    // Constructs in-place using the given typed factory
-    template<class Expr>
-    void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag )
-     {
-       destroy();
-       construct(factory,tag);
-     }
-#endif
-
-    // Constructs using any expression implicitely convertible to the single argument
-    // of a one-argument T constructor.
-    // Converting constructions of optional<T> from optional<U> uses this function with
-    // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
-    template<class Expr>
-    void construct ( Expr const& expr, void const* )
-     {
-       new (m_storage.address()) internal_type(expr) ;
-       m_initialized = true ;
-     }
-
-    // Assigns using a form any expression implicitely convertible to the single argument
-    // of a T's assignment operator.
-    // Converting assignments of optional<T> from optional<U> uses this function with
-    // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
-    template<class Expr>
-    void assign_expr_to_initialized ( Expr const& expr, void const* )
-     {
-       assign_value(expr, is_reference_predicate());
-     }
-
-#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
-    // BCB5.64 (and probably lower versions) workaround.
-    //   The in-place factories are supported by means of catch-all constructors
-    //   and assignment operators (the functions are parameterized in terms of
-    //   an arbitrary 'Expr' type)
-    //   This compiler incorrectly resolves the overload set and sinks optional<T> and optional<U>
-    //   to the 'Expr'-taking functions even though explicit overloads are present for them.
-    //   Thus, the following overload is needed to properly handle the case when the 'lhs'
-    //   is another optional.
-    //
-    // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
-    // instead of choosing the wrong overload
-    //
-    // Notice that 'Expr' will be optional<T> or optional<U> (but not optional_base<..>)
-    template<class Expr>
-    void construct ( Expr const& expr, optional_tag const* )
-     {
-       if ( expr.is_initialized() )
-       {
-         // An exception can be thrown here.
-         // It it happens, THIS will be left uninitialized.
-         new (m_storage.address()) internal_type(expr.get()) ;
-         m_initialized = true ;
-       }
-     }
-#endif
-
-    void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; }
-    void assign_value ( argument_type val, is_reference_tag     ) { construct(val); }
-
-    void destroy()
-    {
-      if ( m_initialized )
-        destroy_impl(is_reference_predicate()) ;
-    }
-
-    unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; }
-
-    reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; }
-    reference_type       get_impl()       { return dereference(get_object(), is_reference_predicate() ) ; }
-
-    pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; }
-    pointer_type       get_ptr_impl()       { return cast_ptr(get_object(), is_reference_predicate() ) ; }
-
-  private :
-
-    // internal_type can be either T or reference_content<T>
-    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()); }
-
-    // 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 ; }
-    reference_type       dereference( internal_type*       p, is_not_reference_tag )       { return *p ; }
-    reference_const_type dereference( internal_type const* p, is_reference_tag     ) const { return p->get() ; }
-    reference_type       dereference( internal_type*       p, is_reference_tag     )       { return p->get() ; }
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x564)
-    void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; }
-#else
-    void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->T::~T() ; m_initialized = false ; }
-#endif
-
-    void destroy_impl ( is_reference_tag     ) { m_initialized = false ; }
-
-    // If T is of reference type, trying to get a pointer to the held value must result in a compile-time error.
-    // Decent compilers should disallow conversions from reference_content<T>* to T*, but just in case,
-    // the following olverloads are used to filter out the case and guarantee an error in case of T being a reference.
-    pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; }
-    pointer_type       cast_ptr( internal_type *      p, is_not_reference_tag )       { return p ; }
-
-    bool m_initialized ;
-    storage_type m_storage ;
-} ;
-
-} // namespace optional_detail
-
-template<class T>
-class optional : public optional_detail::optional_base<T>
-{
-    typedef optional_detail::optional_base<T> base ;
-
-    typedef BOOST_DEDUCED_TYPENAME base::unspecified_bool_type  unspecified_bool_type ;
-
-  public :
-
-    typedef optional<T> this_type ;
-
-    typedef BOOST_DEDUCED_TYPENAME base::value_type           value_type ;
-    typedef BOOST_DEDUCED_TYPENAME base::reference_type       reference_type ;
-    typedef BOOST_DEDUCED_TYPENAME base::reference_const_type reference_const_type ;
-    typedef BOOST_DEDUCED_TYPENAME base::pointer_type         pointer_type ;
-    typedef BOOST_DEDUCED_TYPENAME base::pointer_const_type   pointer_const_type ;
-    typedef BOOST_DEDUCED_TYPENAME base::argument_type        argument_type ;
-
-    // Creates an optional<T> uninitialized.
-    // No-throw
-    optional() : base() {}
-
-    // Creates an optional<T> uninitialized.
-    // No-throw
-    optional( none_t const& none_ ) : base(none_) {}
-
-    // Creates an optional<T> initialized with 'val'.
-    // Can throw if T::T(T const&) does
-    optional ( argument_type val ) : base(val) {}
-
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
-    // NOTE: MSVC needs templated versions first
-
-    // Creates a deep copy of another convertible optional<U>
-    // Requires a valid conversion from U to T.
-    // Can throw if T::T(U const&) does
-    template<class U>
-    explicit optional ( optional<U> const& rhs )
-      :
-      base()
-    {
-      if ( rhs.is_initialized() )
-        this->construct(rhs.get());
-    }
-#endif
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-    // Creates an optional<T> with an expression which can be either
-    //  (a) An instance of InPlaceFactory (i.e. in_place(a,b,...,n);
-    //  (b) An instance of TypedInPlaceFactory ( i.e. in_place<T>(a,b,...,n);
-    //  (c) Any expression implicitely convertible to the single type
-    //      of a one-argument T's constructor.
-    //  (d*) Weak compilers (BCB) might also resolved Expr as optional<T> and optional<U>
-    //       even though explicit overloads are present for these.
-    // 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,&expr) {}
-#endif
-
-    // Creates a deep copy of another optional<T>
-    // Can throw if T::T(T const&) does
-    optional ( optional const& rhs ) : base(rhs) {}
-
-   // No-throw (assuming T::~T() doesn't)
-    ~optional() {}
-
-#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION)
-    // 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 expr )
-      {
-        this->assign_expr(expr,&expr);
-        return *this ;
-      }
-#endif
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
-    // Assigns from another convertible optional<U> (converts && deep-copies the rhs value)
-    // Requires a valid conversion from U to T.
-    // Basic Guarantee: If T::T( U const& ) throws, this is left UNINITIALIZED
-    template<class U>
-    optional& operator= ( optional<U> const& rhs )
-      {
-        this->assign(rhs.get());
-        return *this ;
-      }
-#endif
-
-    // Assigns from another optional<T> (deep-copies the rhs value)
-    // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED
-    //  (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw)
-    optional& operator= ( optional const& rhs )
-      {
-        this->assign( rhs ) ;
-        return *this ;
-      }
-
-    // Assigns from a T (deep-copies the rhs value)
-    // Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED
-    optional& operator= ( argument_type val )
-      {
-        this->assign( val ) ;
-        return *this ;
-      }
-
-    // Assigns from a "none"
-    // Which destroys the current value, if any, leaving this UNINITIALIZED
-    // No-throw (assuming T::~T() doesn't)
-    optional& operator= ( none_t const& none_ )
-      {
-        this->assign( none_ ) ;
-        return *this ;
-      }
-
-    // Returns a reference to the value if this is initialized, otherwise,
-    // the behaviour is UNDEFINED
-    // No-throw
-    reference_const_type get() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); }
-    reference_type       get()       { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); }
-
-    // Returns a pointer to the value if this is initialized, otherwise,
-    // the behaviour is UNDEFINED
-    // No-throw
-    pointer_const_type operator->() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; }
-    pointer_type       operator->()       { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; }
-
-    // Returns a reference to the value if this is initialized, otherwise,
-    // the behaviour is UNDEFINED
-    // No-throw
-    reference_const_type operator *() const { return this->get() ; }
-    reference_type       operator *()       { return this->get() ; }
-
-    // implicit conversion to "bool"
-    // 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() ; }
-} ;
-
-// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED.
-// No-throw
-template<class T>
-inline
-BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type
-get ( optional<T> const& opt )
-{
-  return opt.get() ;
-}
-
-template<class T>
-inline
-BOOST_DEDUCED_TYPENAME optional<T>::reference_type
-get ( optional<T>& opt )
-{
-  return opt.get() ;
-}
-
-// Returns a pointer to the value if this is initialized, otherwise, returns NULL.
-// No-throw
-template<class T>
-inline
-BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type
-get ( optional<T> const* opt )
-{
-  return opt->get_ptr() ;
-}
-
-template<class T>
-inline
-BOOST_DEDUCED_TYPENAME optional<T>::pointer_type
-get ( optional<T>* opt )
-{
-  return opt->get_ptr() ;
-}
-
-// Returns a pointer to the value if this is initialized, otherwise, returns NULL.
-// No-throw
-template<class T>
-inline
-BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type
-get_pointer ( optional<T> const& opt )
-{
-  return opt.get_ptr() ;
-}
-
-template<class T>
-inline
-BOOST_DEDUCED_TYPENAME optional<T>::pointer_type
-get_pointer ( optional<T>& opt )
-{
-  return opt.get_ptr() ;
-}
-
-// optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values).
-// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead.
-
-template<class T>
-inline
-bool operator == ( optional<T> const& x, optional<T> const& y )
-{ return equal_pointees(x,y); }
-
-template<class T>
-inline
-bool operator < ( optional<T> const& x, optional<T> const& y )
-{ return less_pointees(x,y); }
-
-template<class T>
-inline
-bool operator != ( optional<T> const& x, optional<T> const& y )
-{ return !( x == y ) ; }
-
-template<class T>
-inline
-bool operator > ( optional<T> const& x, optional<T> const& y )
-{ return y < x ; }
-
-template<class T>
-inline
-bool operator <= ( optional<T> const& x, optional<T> const& y )
-{ return !( y < x ) ; }
-
-template<class T>
-inline
-bool operator >= ( optional<T> const& x, optional<T> const& y )
-{ return !( x < y ) ; }
-
-template<class T>
-inline
-bool operator == ( optional<T> const& x, none_t const& )
-{ return equal_pointees(x, optional<T>() ); }
-
-template<class T>
-inline
-bool operator < ( optional<T> const& x, none_t const& )
-{ return less_pointees(x,optional<T>() ); }
-
-template<class T>
-inline
-bool operator != ( optional<T> const& x, none_t const& y )
-{ return !( x == y ) ; }
-
-template<class T>
-inline
-bool operator > ( optional<T> const& x, none_t const& y )
-{ return y < x ; }
-
-template<class T>
-inline
-bool operator <= ( optional<T> const& x, none_t const& y )
-{ return !( y < x ) ; }
-
-template<class T>
-inline
-bool operator >= ( optional<T> const& x, none_t const& y )
-{ return !( x < y ) ; }
-
-template<class T>
-inline
-bool operator == ( none_t const& x, optional<T> const& y )
-{ return equal_pointees(optional<T>() ,y); }
-
-template<class T>
-inline
-bool operator < ( none_t const& x, optional<T> const& y )
-{ return less_pointees(optional<T>() ,y); }
-
-template<class T>
-inline
-bool operator != ( none_t const& x, optional<T> const& y )
-{ return !( x == y ) ; }
-
-template<class T>
-inline
-bool operator > ( none_t const& x, optional<T> const& y )
-{ return y < x ; }
-
-template<class T>
-inline
-bool operator <= ( none_t const& x, optional<T> const& y )
-{ return !( y < x ) ; }
-
-template<class T>
-inline
-bool operator >= ( none_t const& 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 {
-
-// 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
-
-// optional's swap:
-// If both are initialized, calls swap(T&, T&). If this swap throws, both will remain initialized but their values are now unspecified.
-// If only one is initialized, calls U.reset(*I), THEN I.reset().
-// If U.reset(*I) throws, both are left UNCHANGED (U is kept uinitialized and I is never reset)
-// If both are uninitialized, do nothing (no-throw)
-template<class T>
-inline
-void optional_swap ( optional<T>& x, optional<T>& y )
-{
-  if ( !x && !!y )
-  {
-    x.reset(*y);
-    y.reset();
-  }
-  else if ( !!x && !y )
-  {
-    y.reset(*x);
-    x.reset();
-  }
-  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
-
-template<class T> inline void swap ( optional<T>& x, optional<T>& y )
-{
-  optional_detail::optional_swap(x,y);
-}
-
-} // namespace boost
-
-#endif
-

include/boost/optional/optional_fwd.hpp

@@ -1,22 +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@hotmail.com
-//
-#ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
-#define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
-
-namespace boost {
-
-template<class T> class optional ;
-
-} // namespace boost
-
-#endif
-

index.html

@@ -1,9 +0,0 @@
-<html>
-<head>
-<meta http-equiv="refresh" content="0; URL=doc/optional.html">
-</head>
-<body>
-Automatic redirection failed, please go to
-<a href="doc/optional.html">doc/optional.html</a>.
-</body>
-</html>

test/.cvsignore

@@ -1 +0,0 @@
-bin

test/Jamfile

@@ -1,36 +0,0 @@
-# Boost.Optional Library test Jamfile
-#
-# 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)
-#
-
-subproject libs/optional/test ;
-
-# bring in rules for testing
-SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
-include testing.jam ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-  test-suite optional :
-    [ run optional_test.cpp ]
-    [ run optional_test_tie.cpp ]
-    [ run optional_test_ref.cpp ]
-    [ run optional_test_inplace.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 ]
-    [ compile-fail optional_test_inplace_fail2.cpp ]
-  ;
-}

test/Jamfile.v2

@@ -1,34 +0,0 @@
-#  Boost.Optional Library test Jamfile
-#
-#  Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-#
-#  This material is provided "as is", with absolutely no warranty expressed
-#  or implied. Any use is at your own risk.
-#
-#  Permission to use or copy this software for any purpose is hereby granted
-#  without fee, provided the above notices are retained on all copies.
-#  Permission to modify the code and to distribute modified code is granted,
-#  provided the above notices are retained, and a notice that the code was
-#  modified is included with the above copyright notice.
-#
-
-import testing ;
-
-{
-  test-suite optional :
-    [ run optional_test.cpp ]
-    [ run optional_test_tie.cpp ]
-    [ run optional_test_ref.cpp ]
-    [ run optional_test_inplace.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 ]
-    [ compile-fail optional_test_inplace_fail2.cpp ]
-  ;
-}

test/optional_test.cpp

@@ -1,809 +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@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional.hpp"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/none.hpp"
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-void test_implicit_construction ( optional<double> opt, double v, double z )
-{
-  check_value(opt,v,z);
-}
-
-void test_implicit_construction ( optional<X> opt, X const& v, X const& z )
-{
-  check_value(opt,v,z);
-}
-
-void test_default_implicit_construction ( double, optional<double> opt )
-{
-  BOOST_CHECK(!opt);
-}
-
-void test_default_implicit_construction ( X const&, optional<X> opt )
-{
-  BOOST_CHECK(!opt);
-}
-
-//
-// Basic test.
-// Check ordinary functionality:
-//   Initialization, assignment, comparison and value-accessing.
-//
-template<class T>
-void test_basics( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION  );
-
-  T z(0);
-
-  T a(1);
-
-  // Default construction.
-  // 'def' state is Uninitialized.
-  // T::T() is not called (and it is not even defined)
-  optional<T> def ;
-  check_uninitialized(def);
-
-  // Implicit construction
-  // The first parameter is implicitely converted to optional<T>(a);
-  test_implicit_construction(a,a,z);
-
-  // Direct initialization.
-  // 'oa' state is Initialized with 'a'
-  // T::T( T const& x ) is used.
-  set_pending_copy( ARG(T) ) ;
-  optional<T> oa ( a ) ;
-  check_is_not_pending_copy( ARG(T) );
-  check_initialized(oa);
-  check_value(oa,a,z);
-
-  T b(2);
-
-  optional<T> ob ;
-
-  // Value-Assignment upon Uninitialized optional.
-  // T::T( T const& x ) is used.
-  set_pending_copy( ARG(T) ) ;
-  ob = a ;
-  check_is_not_pending_copy( ARG(T) ) ;
-  check_initialized(ob);
-  check_value(ob,a,z);
-
-  // Value-Assignment upon Initialized optional.
-  // T::operator=( T const& x ) is used
-  set_pending_assign( ARG(T) ) ;
-  set_pending_copy  ( ARG(T) ) ;
-  set_pending_dtor  ( ARG(T) ) ;
-  ob = b ;
-  check_is_not_pending_assign( ARG(T) ) ;
-  check_is_pending_copy      ( ARG(T) ) ;
-  check_is_pending_dtor      ( ARG(T) ) ;
-  check_initialized(ob);
-  check_value(ob,b,z);
-
-  // Assignment initialization.
-  // T::T ( T const& x ) is used to copy new value.
-  set_pending_copy( ARG(T) ) ;
-  optional<T> const oa2 ( oa ) ;
-  check_is_not_pending_copy( ARG(T) ) ;
-  check_initialized_const(oa2);
-  check_value_const(oa2,a,z);
-
-  // Assignment
-  // T::operator= ( T const& x ) is used to copy new value.
-  set_pending_assign( ARG(T) ) ;
-  set_pending_copy  ( ARG(T) ) ;
-  set_pending_dtor  ( ARG(T) ) ;
-  oa = ob ;
-  check_is_not_pending_assign( ARG(T) ) ;
-  check_is_pending_copy      ( ARG(T) ) ;
-  check_is_pending_dtor      ( ARG(T) ) ;
-  check_initialized(oa);
-  check_value(oa,b,z);
-
-  // Uninitializing Assignment upon Initialized Optional
-  // T::~T() is used to destroy previous value in oa.
-  set_pending_dtor( ARG(T) ) ;
-  set_pending_copy( ARG(T) ) ;
-  oa = def ;
-  check_is_not_pending_dtor( ARG(T) ) ;
-  check_is_pending_copy    ( ARG(T) ) ;
-  check_uninitialized(oa);
-
-  // Uninitializing Assignment upon Uninitialized Optional
-  // (Dtor is not called this time)
-  set_pending_dtor( ARG(T) ) ;
-  set_pending_copy( ARG(T) ) ;
-  oa = def ;
-  check_is_pending_dtor( ARG(T) ) ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_uninitialized(oa);
-
-  // Deinitialization of Initialized Optional
-  // T::~T() is used to destroy previous value in ob.
-  set_pending_dtor( ARG(T) ) ;
-  ob.reset();
-  check_is_not_pending_dtor( ARG(T) ) ;
-  check_uninitialized(ob);
-
-  // Deinitialization of Uninitialized Optional
-  // (Dtor is not called this time)
-  set_pending_dtor( ARG(T) ) ;
-  ob.reset();
-  check_is_pending_dtor( ARG(T) ) ;
-  check_uninitialized(ob);
-}
-
-//
-// Test Direct Value Manipulation
-//
-template<class T>
-void test_direct_value_manip( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T x(3);
-
-  optional<T> const c_opt0(x) ;
-  optional<T>         opt0(x);
-
-  BOOST_CHECK( c_opt0.get().V() == x.V() ) ;
-  BOOST_CHECK(   opt0.get().V() == x.V() ) ;
-
-  BOOST_CHECK( c_opt0->V() == x.V() ) ;
-  BOOST_CHECK(   opt0->V() == x.V() ) ;
-
-  BOOST_CHECK( (*c_opt0).V() == x.V() ) ;
-  BOOST_CHECK( (*  opt0).V() == x.V() ) ;
-
-  T y(4);
-  opt0 = y ;
-  BOOST_CHECK( get(opt0).V() == y.V() ) ;
-}
-
-//
-// Test Uninitialized access assert
-//
-template<class T>
-void test_uninitialized_access( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  optional<T> def ;
-
-  bool passed = false ;
-  try
-  {
-    // This should throw because 'def' is uninitialized
-    T const& n = def.get() ;
-    unused_variable(n);
-    passed = true ;
-  }
-  catch (...) {}
-  BOOST_CHECK(!passed);
-
-  passed = false ;
-  try
-  {
-    // This should throw because 'def' is uninitialized
-    T const& n = *def ;
-    unused_variable(n);
-    passed = true ;
-  }
-  catch (...) {}
-  BOOST_CHECK(!passed);
-
-  passed = false ;
-  try
-  {
-    T v(5) ;
-    unused_variable(v);
-    // This should throw because 'def' is uninitialized
-    *def = v ;
-    passed = true ;
-  }
-  catch (...) {}
-  BOOST_CHECK(!passed);
-
-  passed = false ;
-  try
-  {
-    // This should throw because 'def' is uninitialized
-    T v = *(def.operator->()) ;
-    unused_variable(v);
-    passed = true ;
-  }
-  catch (...) {}
-  BOOST_CHECK(!passed);
-}
-
-#if BOOST_WORKAROUND( BOOST_INTEL_CXX_VERSION, <= 700) // Intel C++ 7.0
-void prevent_buggy_optimization( bool v ) {}
-#endif
-
-//
-// Test Direct Initialization of optional for a T with throwing copy-ctor.
-//
-template<class T>
-void test_throwing_direct_init( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T a(6);
-
-  int count = get_instance_count( ARG(T) ) ;
-
-  set_throw_on_copy( ARG(T) ) ;
-
-  bool passed = false ;
-  try
-  {
-    // This should:
-    //   Attempt to copy construct 'a' and throw.
-    // 'opt' won't be constructed.
-    set_pending_copy( ARG(T) ) ;
-
-#if BOOST_WORKAROUND( BOOST_INTEL_CXX_VERSION, <= 700) // Intel C++ 7.0
-    // Intel C++ 7.0 specific:
-    //    For some reason, when "check_is_not_pending_copy",
-    //    after the exception block is reached,
-    //    X::pending_copy==true even though X's copy ctor set it to false.
-    //    I guessed there is some sort of optimization bug,
-    //    and it seems to be the since the following additional line just
-    //    solves the problem (!?)
-    prevent_buggy_optimization(X::pending_copy);
-#endif
-
-    optional<T> opt(a) ;
-    passed = true ;
-  }
-  catch ( ... ){}
-
-  BOOST_CHECK(!passed);
-  check_is_not_pending_copy( ARG(T) );
-  check_instance_count(count, ARG(T) );
-
-  reset_throw_on_copy( ARG(T) ) ;
-
-}
-
-//
-// Test Value Assignment to an Uninitialized optional for a T with a throwing copy-ctor
-//
-template<class T>
-void test_throwing_val_assign_on_uninitialized( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T a(7);
-
-  int count = get_instance_count( ARG(T) ) ;
-
-  set_throw_on_copy( ARG(T) ) ;
-
-  optional<T> opt ;
-
-  bool passed = false ;
-  try
-  {
-    // This should:
-    //   Attempt to copy construct 'a' and throw.
-    //   opt should be left uninitialized.
-    set_pending_copy( ARG(T) ) ;
-    opt.reset( a );
-    passed = true ;
-  }
-  catch ( ... ) {}
-
-  BOOST_CHECK(!passed);
-
-  check_is_not_pending_copy( ARG(T) );
-  check_instance_count(count, ARG(T) );
-  check_uninitialized(opt);
-
-  reset_throw_on_copy( ARG(T) ) ;
-}
-
-//
-// Test Value Reset on an Initialized optional for a T with a throwing copy-ctor
-//
-template<class T>
-void test_throwing_val_assign_on_initialized( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T z(0);
-  T a(8);
-  T b(9);
-  T x(-1);
-
-  int count = get_instance_count( ARG(T) ) ;
-
-  optional<T> opt ( b ) ;
-  ++ count ;
-
-  check_instance_count(count, ARG(T) );
-
-  check_value(opt,b,z);
-
-  set_throw_on_assign( ARG(T) ) ;
-
-  bool passed = false ;
-  try
-  {
-    // This should:
-    //   Attempt to assign 'a' and throw.
-    //   opt is kept initialized but its value not neccesarily fully assigned
-    //   (in this test, incompletely assigned is flaged with the value -1 being set)
-    set_pending_assign( ARG(T) ) ;
-    opt.reset ( a ) ;
-    passed = true ;
-  }
-  catch ( ... ) {}
-
-  BOOST_CHECK(!passed);
-
-  check_is_not_pending_assign( ARG(T) );
-  check_instance_count(count, ARG(T) );
-  check_initialized(opt);
-  check_value(opt,x,z);
-
-  reset_throw_on_assign ( ARG(T) ) ;
-}
-
-//
-// Test Copy Initialization from an Initialized optional for a T with a throwing copy-ctor
-//
-template<class T>
-void test_throwing_copy_initialization( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T z(0);
-  T a(10);
-
-  optional<T> opt (a);
-
-  int count = get_instance_count( ARG(T) ) ;
-
-  set_throw_on_copy( ARG(T) ) ;
-
-  bool passed = false ;
-  try
-  {
-    // This should:
-    //   Attempt to copy construct 'opt' and throw.
-    //   opt1 won't be constructed.
-    set_pending_copy( ARG(T) ) ;
-    optional<T> opt1 = opt ;
-    passed = true ;
-  }
-  catch ( ... ) {}
-
-  BOOST_CHECK(!passed);
-
-  check_is_not_pending_copy( ARG(T) );
-  check_instance_count(count, ARG(T) );
-
-  // Nothing should have happened to the source optional.
-  check_initialized(opt);
-  check_value(opt,a,z);
-
-  reset_throw_on_copy( ARG(T) ) ;
-}
-
-//
-// Test Assignment to an Uninitialized optional from an Initialized optional
-// for a T with a throwing copy-ctor
-//
-template<class T>
-void test_throwing_assign_to_uninitialized( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T z(0);
-  T a(11);
-
-  optional<T> opt0 ;
-  optional<T> opt1(a) ;
-
-  int count = get_instance_count( ARG(T) ) ;
-
-  set_throw_on_copy( ARG(T) ) ;
-
-  bool passed = false ;
-  try
-  {
-    // This should:
-    //   Attempt to copy construct 'opt1.value()' into opt0 and throw.
-    //   opt0 should be left uninitialized.
-    set_pending_copy( ARG(T) ) ;
-    opt0 = opt1 ;
-    passed = true ;
-  }
-  catch ( ... ) {}
-
-  BOOST_CHECK(!passed);
-
-  check_is_not_pending_copy( ARG(T) );
-  check_instance_count(count, ARG(T) );
-  check_uninitialized(opt0);
-
-  reset_throw_on_copy( ARG(T) ) ;
-}
-
-//
-// Test Assignment to an Initialized optional from an Initialized optional
-// for a T with a throwing copy-ctor
-//
-template<class T>
-void test_throwing_assign_to_initialized( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T z(0);
-  T a(12);
-  T b(13);
-  T x(-1);
-
-  optional<T> opt0(a) ;
-  optional<T> opt1(b) ;
-
-  int count = get_instance_count( ARG(T) ) ;
-
-  set_throw_on_assign( ARG(T) ) ;
-
-  bool passed = false ;
-  try
-  {
-    // This should:
-    //   Attempt to copy construct 'opt1.value()' into opt0 and throw.
-    //   opt0 is kept initialized but its value not neccesarily fully assigned
-    //   (in this test, incompletely assigned is flaged with the value -1 being set)
-    set_pending_assign( ARG(T) ) ;
-    opt0 = opt1 ;
-    passed = true ;
-  }
-  catch ( ... ) {}
-
-  BOOST_CHECK(!passed);
-
-  // opt0 was left uninitialized
-  check_is_not_pending_assign( ARG(T) );
-  check_instance_count(count, ARG(T) );
-  check_initialized(opt0);
-  check_value(opt0,x,z);
-
-  reset_throw_on_assign( ARG(T) ) ;
-}
-
-//
-// Test swap in a no-throwing case
-//
-template<class T>
-void test_no_throwing_swap( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T z(0);
-  T a(14);
-  T b(15);
-
-  optional<T> def0 ;
-  optional<T> def1 ;
-  optional<T> opt0(a) ;
-  optional<T> opt1(b) ;
-
-  int count = get_instance_count( ARG(T) ) ;
-
-  swap(def0,def1);
-  check_uninitialized(def0);
-  check_uninitialized(def1);
-
-  swap(def0,opt0);
-  check_uninitialized(opt0);
-  check_initialized(def0);
-  check_value(def0,a,z);
-
-  // restore def0 and opt0
-  swap(def0,opt0);
-
-  swap(opt0,opt1);
-  check_instance_count(count, ARG(T) );
-  check_initialized(opt0);
-  check_initialized(opt1);
-  check_value(opt0,b,z);
-  check_value(opt1,a,z);
-}
-
-//
-// Test swap in a throwing case
-//
-template<class T>
-void test_throwing_swap( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T a(16);
-  T b(17);
-  T x(-1);
-
-  optional<T> opt0(a) ;
-  optional<T> opt1(b) ;
-
-  set_throw_on_assign( ARG(T) ) ;
-
-  //
-  // Case 1: Both Initialized.
-  //
-  bool passed = false ;
-  try
-  {
-    // This should attempt to swap optionals and fail at swap(X&,X&).
-    swap(opt0,opt1);
-
-    passed = true ;
-  }
-  catch ( ... ) {}
-
-  BOOST_CHECK(!passed);
-
-  // optional's swap doesn't affect the initialized states of the arguments. Therefore,
-  // the following must hold:
-  check_initialized(opt0);
-  check_initialized(opt1);
-  check_value(opt0,x,a);
-  check_value(opt1,b,x);
-
-
-  //
-  // Case 2: Only one Initialized.
-  //
-  reset_throw_on_assign( ARG(T) ) ;
-
-  opt0.reset();
-  opt1.reset(a);
-
-  set_throw_on_copy( ARG(T) ) ;
-
-  passed = false ;
-  try
-  {
-    // This should attempt to swap optionals and fail at opt0.reset(*opt1)
-    // Both opt0 and op1 are left unchanged (unswaped)
-    swap(opt0,opt1);
-
-    passed = true ;
-  }
-  catch ( ... ) {}
-
-  BOOST_CHECK(!passed);
-
-  check_uninitialized(opt0);
-  check_initialized(opt1);
-  check_value(opt1,a,x);
-
-  reset_throw_on_copy( ARG(T) ) ;
-}
-
-//
-// This verifies relational operators.
-//
-template<class T>
-void test_relops( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  T v0(18);
-  T v1(19);
-  T v2(19);
-
-  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 ) ;
-  BOOST_CHECK ( !(def0 != def0) ) ;
-  BOOST_CHECK ( !(opt0 != opt0) ) ;
-
-  // Check when both are uininitalized.
-  BOOST_CHECK (   def0 == def1  ) ; // both uninitialized compare equal
-  BOOST_CHECK ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
-  BOOST_CHECK ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
-  BOOST_CHECK ( !(def0 != def1) ) ;
-  BOOST_CHECK (   def0 <= def1  ) ;
-  BOOST_CHECK (   def0 >= def1  ) ;
-
-  // Check when only lhs is uninitialized.
-  BOOST_CHECK (   def0 != opt0  ) ; // uninitialized is never equal to initialized
-  BOOST_CHECK ( !(def0 == opt0) ) ;
-  BOOST_CHECK (   def0 <  opt0  ) ; // uninitialized is always less than initialized
-  BOOST_CHECK ( !(def0 >  opt0) ) ;
-  BOOST_CHECK (   def0 <= opt0  ) ;
-  BOOST_CHECK ( !(def0 >= opt0) ) ;
-
-  // Check when only rhs is uninitialized.
-  BOOST_CHECK (   opt0 != def0  ) ; // initialized is never equal to uninitialized
-  BOOST_CHECK ( !(opt0 == def0) ) ;
-  BOOST_CHECK ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
-  BOOST_CHECK (   opt0 >  def0  ) ;
-  BOOST_CHECK ( !(opt0 <= def0) ) ;
-  BOOST_CHECK (   opt0 >= opt0  ) ;
-
-  // If both are initialized, values are compared
-  BOOST_CHECK ( opt0 != opt1 ) ;
-  BOOST_CHECK ( opt1 == opt2 ) ;
-  BOOST_CHECK ( opt0 <  opt1 ) ;
-  BOOST_CHECK ( opt1 >  opt0 ) ;
-  BOOST_CHECK ( opt1 <= opt2 ) ;
-  BOOST_CHECK ( opt1 >= opt0 ) ;
-}
-
-template<class T>
-void test_none( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  using boost::none ;
-
-  optional<T> def0 ;
-  optional<T> def1(none) ;
-  optional<T> non_def( T(1234) ) ;
-
-  BOOST_CHECK ( def0    == none ) ;
-  BOOST_CHECK ( non_def != none ) ;
-  BOOST_CHECK ( !def1           ) ;
-
-  non_def = none ;
-  BOOST_CHECK ( !non_def ) ;
-
-  test_default_implicit_construction(T(1),none);
-}
-
-void test_with_builtin_types()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  test_basics( ARG(double) );
-  test_uninitialized_access( ARG(double) );
-  test_no_throwing_swap( ARG(double) );
-  test_relops( ARG(double) ) ;
-  test_none( ARG(double) ) ;
-}
-
-void test_with_class_type()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  test_basics( ARG(X) );
-  test_direct_value_manip( ARG(X) );
-  test_uninitialized_access( ARG(X) );
-  test_throwing_direct_init( ARG(X) );
-  test_throwing_val_assign_on_uninitialized( ARG(X) );
-  test_throwing_val_assign_on_initialized( ARG(X) );
-  test_throwing_copy_initialization( ARG(X) );
-  test_throwing_assign_to_uninitialized( ARG(X) );
-  test_throwing_assign_to_initialized( ARG(X) );
-  test_no_throwing_swap( ARG(X) );
-  test_throwing_swap( ARG(X) );
-  test_relops( ARG(X) ) ;
-  test_none( ARG(X) ) ;
-  BOOST_CHECK ( X::count == 0 ) ;
-}
-
-int eat ( bool ) { return 1 ; }
-int eat ( char ) { return 1 ; }
-int eat ( int  ) { return 1 ; }
-int eat ( void const* ) { return 1 ; }
-
-template<class T> int eat ( T ) { return 0 ; }
-
-//
-// This verifies that operator safe_bool() behaves properly.
-//
-template<class T>
-void test_no_implicit_conversions_impl( T const& )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  optional<T> def ;
-  BOOST_CHECK ( eat(def) == 0 ) ;
-}
-
-void test_no_implicit_conversions()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  bool b = false ;
-  char c = 0 ;
-  int i = 0 ;
-  void const* p = 0 ;
-
-  test_no_implicit_conversions_impl(b);
-  test_no_implicit_conversions_impl(c);
-  test_no_implicit_conversions_impl(i);
-  test_no_implicit_conversions_impl(p);
-}
-
-struct A {} ;
-void test_conversions1()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION );
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
-  char c = 20 ;
-  optional<char> opt0(c);
-  optional<int> opt1(opt0);
-  BOOST_CHECK(*opt1 == static_cast<int>(c));
-#endif
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
-  float f = 21.22f ;
-  double d = f ;
-  optional<float> opt2(f) ;
-  optional<double> opt3 ;
-  opt3 = opt2 ;
-  BOOST_CHECK(*opt3 == d);
-#endif
-}
-
-void test_conversions2()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION );
-
-  char c = 20 ;
-  optional<int> opt(c);
-  BOOST_CHECK( get(opt) == static_cast<int>(c));
-
-  float f = 21.22f ;
-  optional<double> opt1;
-  opt1 = f ;
-  BOOST_CHECK(*get(&opt1) == static_cast<double>(f));
-}
-
-int test_main( int, char* [] )
-{
-  try
-  {
-    test_with_class_type();
-    test_with_builtin_types();
-    test_no_implicit_conversions();
-    test_conversions1();
-    test_conversions2();
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
-
-  return 0;
-}
-
-

test/optional_test_common.cpp

@@ -1,267 +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@hotmail.com
-//
-#ifdef ENABLE_TRACE
-#define TRACE(msg) std::cout << msg << std::endl ;
-#else
-#define TRACE(msg)
-#endif
-
-namespace boost {
-
-void assertion_failed (char const * expr, char const * func, char const * file, long )
-{
-  using std::string ;
-  string msg =  string("Boost assertion failure for \"")
-               + string(expr)
-               + string("\" at file \"")
-               + string(file)
-               + string("\" function \"")
-               + string(func)
-               + string("\"") ;
-
-  TRACE(msg);
-
-  throw std::logic_error(msg);
-}
-
-}
-
-using boost::optional ;
-
-template<class T> inline void unused_variable ( T ) {}
-
-#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-using boost::swap ;
-using boost::get ;
-using boost::get_pointer ;
-#endif
-
-// MSVC6.0 does not support comparisons of optional against a literal null pointer value (0)
-// via the safe_bool operator.
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1300) ) // 1300 == VC++ 7.1
-#define BOOST_OPTIONAL_NO_NULL_COMPARE
-#endif
-
-#define ARG(T) (static_cast< T const* >(0))
-
-//
-// Helper class used to verify the lifetime managment of the values held by optional
-//
-class X
-{
-  public :
-
-    X ( int av ) : v(av)
-    {
-      ++ count ;
-
-      TRACE ( "X::X(" << av << "). this=" << this ) ;
-    }
-
-    X ( X const& rhs ) : v(rhs.v)
-    {
-       pending_copy = false ;
-
-       TRACE ( "X::X( X const& rhs). this=" << this << " rhs.v=" << rhs.v ) ;
-
-       if ( throw_on_copy )
-       {
-         TRACE ( "throwing exception in X's copy ctor" ) ;
-         throw 0 ;
-       }
-
-       ++ count ;
-    }
-
-    ~X()
-    {
-      pending_dtor = false ;
-
-      -- count ;
-
-      TRACE ( "X::~X(). v=" << v << "  this=" << this );
-    }
-
-    X& operator= ( X const& rhs )
-      {
-        pending_assign = false ;
-
-        if ( throw_on_assign )
-        {
-          TRACE ( "throwing exception in X's assignment" ) ;
-
-          v = -1 ;
-
-          throw 0 ;
-        }
-        else
-        {
-          v = rhs.v ;
-
-          TRACE ( "X::operator =( X const& rhs). this=" << this << " rhs.v=" << rhs.v ) ;
-        }
-        return *this ;
-      }
-
-    friend bool operator == ( X const& a, X const& b )
-      { return a.v == b.v ; }
-
-    friend bool operator != ( X const& a, X const& b )
-      { return a.v != b.v ; }
-
-    friend bool operator < ( X const& a, X const& b )
-      { return a.v < b.v ; }
-
-    int  V() const { return v ; }
-    int& V()       { return v ; }
-
-    static int  count ;
-    static bool pending_copy   ;
-    static bool pending_dtor   ;
-    static bool pending_assign ;
-    static bool throw_on_copy ;
-    static bool throw_on_assign ;
-
-  private :
-
-    int  v ;
-
-  private :
-
-    X() ;
-} ;
-
-
-int  X::count           = 0 ;
-bool X::pending_copy    = false ;
-bool X::pending_dtor    = false ;
-bool X::pending_assign  = false ;
-bool X::throw_on_copy   = false ;
-bool X::throw_on_assign = false ;
-
-inline void set_pending_copy           ( X const* x ) { X::pending_copy  = true  ; }
-inline void set_pending_dtor           ( X const* x ) { X::pending_dtor  = true  ; }
-inline void set_pending_assign         ( X const* x ) { X::pending_assign = true  ; }
-inline void set_throw_on_copy          ( X const* x ) { X::throw_on_copy = true  ; }
-inline void set_throw_on_assign        ( X const* x ) { X::throw_on_assign = true  ; }
-inline void reset_throw_on_copy        ( X const* x ) { X::throw_on_copy = false ; }
-inline void reset_throw_on_assign      ( X const* x ) { X::throw_on_assign = false ; }
-inline void check_is_pending_copy      ( X const* x ) { BOOST_CHECK( X::pending_copy ) ; }
-inline void check_is_pending_dtor      ( X const* x ) { BOOST_CHECK( X::pending_dtor ) ; }
-inline void check_is_pending_assign    ( X const* x ) { BOOST_CHECK( X::pending_assign ) ; }
-inline void check_is_not_pending_copy  ( X const* x ) { BOOST_CHECK( !X::pending_copy ) ; }
-inline void check_is_not_pending_dtor  ( X const* x ) { BOOST_CHECK( !X::pending_dtor ) ; }
-inline void check_is_not_pending_assign( X const* x ) { BOOST_CHECK( !X::pending_assign ) ; }
-inline void check_instance_count       ( int c, X const* x ) { BOOST_CHECK( X::count == c ) ; }
-inline int  get_instance_count         ( X const* x ) { return X::count ; }
-
-inline void set_pending_copy           (...) {}
-inline void set_pending_dtor           (...) {}
-inline void set_pending_assign         (...) {}
-inline void set_throw_on_copy          (...) {}
-inline void set_throw_on_assign        (...) {}
-inline void reset_throw_on_copy        (...) {}
-inline void reset_throw_on_assign      (...) {}
-inline void check_is_pending_copy      (...) {}
-inline void check_is_pending_dtor      (...) {}
-inline void check_is_pending_assign    (...) {}
-inline void check_is_not_pending_copy  (...) {}
-inline void check_is_not_pending_dtor  (...) {}
-inline void check_is_not_pending_assign(...) {}
-inline void check_instance_count       (...) {}
-inline int  get_instance_count         (...) { return 0 ; }
-
-
-template<class T>
-inline void check_uninitialized_const ( optional<T> const& opt )
-{
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
-#endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
-}
-template<class T>
-inline void check_uninitialized ( optional<T>& opt )
-{
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
-#endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
-
-  check_uninitialized_const(opt);
-}
-
-template<class T>
-inline void check_initialized_const ( optional<T> const& opt )
-{
-  BOOST_CHECK( opt ) ;
-
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
-#endif
-
-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
-}
-
-template<class T>
-inline void check_initialized ( optional<T>& opt )
-{
-  BOOST_CHECK( opt ) ;
-
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
-#endif
-
-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
-
-  check_initialized_const(opt);
-}
-
-template<class T>
-inline void check_value_const ( optional<T> const& opt, T const& v, T const& z )
-{
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
-}
-
-template<class T>
-inline void check_value ( optional<T>& opt, T const& v, T const& z )
-{
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) // 1200 == VC++ 6.0
-  // For some reason, VC6.0 is creating a temporary while evaluating (*opt == v),
-  // so we need to turn throw on copy off first.
-  reset_throw_on_copy( ARG(T) ) ;
-#endif
-
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
-
-  check_value_const(opt,v,z);
-}
-
-

test/optional_test_fail1.cpp

@@ -1,25 +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@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void test_deep_constantness()
-{
-  boost::optional<int> opt ;
-  boost::optional<int> const copt ;
-
-  *copt = opt ; // Cannot assign to "int const&"
-}
-
-

test/optional_test_fail2.cpp

@@ -1,26 +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@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void test_no_implicit_conversion()
-{
-  boost::optional<int> opt(1) ;
-
-  // You can compare against 0 or against another optional<>,
-  // but not against another value
-  if ( opt == 1 ) ;
-}
-
-

test/optional_test_fail3.cpp

@@ -1,33 +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@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-#if BOOST_WORKAROUND( BOOST_INTEL_CXX_VERSION, <= 700) // Intel C++ 7.0
-// Interl C++ 7.0 incorrectly accepts the initialization "boost::optional<int> opt = 3"
-// even though the ctor is explicit (c.f. 12.3.1.2), so the test uses another form of
-// copy-initialization: argument-passing (8.5.12)
-void helper ( boost::optional<int> ) ;
-void test_explicit_constructor()
-{
-  helper(3) ; // ERROR: Ctor is explicit.
-}
-#else
-void test_explicit_constructor()
-{
-  boost::optional<int> opt = 3 ; // ERROR: Ctor is explicit.
-}
-#endif
-
-

test/optional_test_fail3a.cpp

@@ -1,25 +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@hotmail.com
-//
-#include<string>
-
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void test_no_unsupported_conversion()
-{
-  boost::optional<int> opt1(1) ;
-  boost::optional< std::string > opt2( opt1 ) ; // Cannot convert from "int" to "std::string"
-}
-
-

test/optional_test_fail3b.cpp

@@ -1,26 +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@hotmail.com
-//
-#include<string>
-
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void test_no_unsupported_conversion()
-{
-  boost::optional<int> opt1(1) ;
-  boost::optional< std::string > opt2 ;
-  opt2 = opt1 ; // Cannot convert from "int" to "std::string"
-}
-
-

test/optional_test_inplace.cpp

@@ -1,84 +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@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional/optional.hpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#include "boost/utility/in_place_factory.hpp"
-#include "boost/utility/typed_in_place_factory.hpp"
-#endif
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-struct A
-{
-  A ( double a0, std::string a1 ) : m_a0(a0), m_a1(a1) {}
-
-  friend bool operator == ( A const& x, A const& y )
-    { return x.m_a0 == y.m_a0 && x.m_a1 == y.m_a1 ; }
-
-  double      m_a0 ;
-  std::string m_a1 ;
-} ;
-
-int test_main( int, char* [] )
-{
-  double a00 = 3.14, a10 = 6.02e-23;
-  std::string a01("pi"), a11("mol");
-
-  A a0(a00,a01);
-  A a1(a10,a11);
-
-  boost::optional<A> opt1(a0);
-
-  boost::optional<A> opt2 ( boost::in_place(a00,a01) ) ;
-
-  boost::optional<A> opt3 ( boost::in_place<A>(a00,a01) ) ;
-
-  BOOST_CHECK( opt1 == opt2 ) ;
-  BOOST_CHECK( opt2 == opt2 ) ;
-  BOOST_CHECK( *opt2 == a0 ) ;
-
-#ifndef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
-
-  opt2 = boost::in_place(a10,a11);
-  BOOST_CHECK( *opt2 == a1 ) ;
-
-  opt3 = boost::in_place<A>(a10,a11);
-  BOOST_CHECK( *opt3 == a1 ) ;
-
-#endif
-
-  return 0;
-}
-#else
-int test_main( int, char* [] )
-{
-  // If in-place factories are not supported there is nothing to test
-  return 0 ;
-}
-#endif
-
-
-

test/optional_test_inplace_fail.cpp

@@ -1,60 +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@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional/optional.hpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#include "boost/utility/in_place_factory.hpp"
-#endif
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-struct A
-{
-  A ( double a0, std::string a1 ) : m_a0(a0), m_a1(a1) {}
-
-  friend bool operator == ( A const& x, A const& y )
-    { return x.m_a0 == y.m_a0 && x.m_a1 == y.m_a1 ; }
-
-  double      m_a0 ;
-  std::string m_a1 ;
-} ;
-
-int test_main( int, char* [] )
-{
-  int invalid_extra_parameter ;
-  boost::optional<A> opt2 ( boost::in_place(3.14,"pi",invalid_extra_parameter) ) ;
-
-  return 0;
-}
-#else
-int test_main( int, char* [] )
-{
-  int invalid_extra_parameter ;
-  boost::optional<A> opt2 ( A(3.14,"pi",invalid_extra_parameter) ) ;
-
-  return 0;
-}
-#endif
-

test/optional_test_inplace_fail2.cpp

@@ -1,62 +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@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional/optional.hpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-#include "boost/utility/typed_in_place_factory.hpp"
-#endif
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
-struct A
-{
-  A ( double a0, std::string a1 ) : m_a0(a0), m_a1(a1) {}
-
-  friend bool operator == ( A const& x, A const& y )
-    { return x.m_a0 == y.m_a0 && x.m_a1 == y.m_a1 ; }
-
-  double      m_a0 ;
-  std::string m_a1 ;
-} ;
-
-int test_main( int, char* [] )
-{
-  // This must fail to compile.
-  // The first template argument to in_place<> is the target-type,
-  // not the first constructor parameter type.
-  boost::optional<A> opt2 ( boost::in_place<int>(3.14,"pi") ) ;
-
-  return 0;
-}
-#else
-int test_main( int, char* [] )
-{
-  boost::optional<A> opt2 ( int(3.14) ) ;
-
-  return 0;
-}
-#endif
-
-

test/optional_test_ref.cpp

@@ -1,337 +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@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional.hpp"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/none.hpp"
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-template<class T>
-inline void check_ref_uninitialized_const ( optional<T&> const& opt )
-{
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
-#endif
-  BOOST_CHECK( !opt ) ;
-}
-template<class T>
-inline void check_ref_uninitialized ( optional<T&>& opt )
-{
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
-#endif
-  BOOST_CHECK( !opt ) ;
-
-  check_ref_uninitialized_const(opt);
-}
-
-template<class T>
-inline void check_ref_initialized_const ( optional<T&> const& opt )
-{
-  BOOST_CHECK( opt ) ;
-
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
-#endif
-
-  BOOST_CHECK ( !!opt ) ;
-}
-
-template<class T>
-inline void check_ref_initialized ( optional<T&>& opt )
-{
-  BOOST_CHECK( opt ) ;
-
-#ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
-#endif
-
-  BOOST_CHECK ( !!opt ) ;
-
-  check_ref_initialized_const(opt);
-}
-
-template<class T>
-inline void check_ref_value_const ( optional<T&> const& opt, T const& v, T const& z )
-{
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-}
-
-template<class T>
-inline void check_ref_value ( optional<T&>& opt, T const& v, T const& z )
-{
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-
-  check_ref_value_const(opt,v,z);
-}
-
-//
-// Basic test.
-// Check ordinary functionality:
-//   Initialization, assignment, comparison and value-accessing.
-//
-template<class T>
-void test_basics( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION  );
-
-  T z(0);
-
-  T original_a(1);
-
-  T a(1);
-
-  T b(2);
-
-  T c(10);
-
-  T& aref = a ;
-  T& bref = b ;
-
-  // Default construction.
-  // 'def' state is Uninitialized.
-  // T::T() is not called
-  optional<T&> def ;
-  check_ref_uninitialized(def);
-
-  // Direct initialization.
-  // 'oa' state is Initialized and binds to 'a'
-  // T::T( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  optional<T&> oa ( aref ) ;
-  check_is_pending_copy( ARG(T) );
-  check_ref_initialized(oa);
-  check_ref_value(oa,a,z);
-  *oa = b ; // changes the value of 'a' through the reference
-  BOOST_CHECK( a == b ) ;
-
-
-  // Copy initialization.
-  // T::T ( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  optional<T&>  const oa2 ( oa ) ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_initialized_const(oa2);
-  check_ref_value_const(oa2,a,z);
-  *oa2 = original_a ; // restores the value of 'a' through the reference
-  BOOST_CHECK( a == original_a ) ;
-
-  optional<T&> ob ;
-
-  // Value-Assignment upon Uninitialized optional.
-  // T::T ( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  ob = a ; // Binds ob to a temporary non-const refererence to 'a'
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_initialized(ob);
-  check_ref_value(ob,a,z);
-  a = c;
-  check_ref_value(ob,a,z);
-
-  // Value-Assignment upon Initialized optional.
-  // T::operator= ( T const& x ) is used.
-  set_pending_assign( ARG(T) ) ;
-  ob = b ; // Rebinds 'ob' to 'b' (without changing 'a')
-  check_is_pending_assign( ARG(T) ) ;
-  check_ref_initialized(ob);
-  check_ref_value(ob,b,z);
-  BOOST_CHECK(a == c); // From a=c in previous test
-  b = c;
-  check_ref_value(ob,b,z);
-
-
-  // Assignment initialization.
-  // T::T ( T const& x ) is NOT used becasue the optional holds a reference.
-  set_pending_copy( ARG(T) ) ;
-  optional<T&> const oa3 = b ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_initialized_const(oa3);
-  check_ref_value_const(oa3,b,z);
-
-
-  // Assignment
-  // T::operator=( T const& x ) is used.
-  set_pending_assign( ARG(T) ) ;
-  oa = ob ; // Rebinds 'a' to 'b'
-  check_is_pending_assign( ARG(T) ) ;
-  check_ref_initialized(oa);
-  a = original_a ;
-  check_ref_value(oa,b,z);
-
-  // Uninitializing Assignment upon Initialized Optional
-  // T::~T() is NOT used becasue the optional holds a reference.
-  set_pending_dtor( ARG(T) ) ;
-  set_pending_copy( ARG(T) ) ;
-  oa = def ;
-  check_is_pending_dtor( ARG(T) ) ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_uninitialized(oa);
-
-  // Uninitializing Assignment upon Uninitialized Optional
-  // (Dtor is not called this time)
-  set_pending_dtor( ARG(T) ) ;
-  set_pending_copy( ARG(T) ) ;
-  oa = def ;
-  check_is_pending_dtor( ARG(T) ) ;
-  check_is_pending_copy( ARG(T) ) ;
-  check_ref_uninitialized(oa);
-
-
-  // Deinitialization of Initialized Optional
-  // T::~T() is NOT used becasue the optional holds a reference.
-  set_pending_dtor( ARG(T) ) ;
-  ob.reset();
-  check_is_pending_dtor( ARG(T) ) ;
-  check_ref_uninitialized(ob);
-
-  // Deinitialization of Uninitialized Optional
-  // T::~T() is not called this time
-  set_pending_dtor( ARG(T) ) ;
-  ob.reset();
-  check_is_pending_dtor( ARG(T) ) ;
-  check_ref_uninitialized(ob);
-}
-
-//
-// This verifies relational operators.
-//
-template<class T>
-void test_relops( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  reset_throw_on_copy( ARG(T) ) ;
-
-  T v0(18);
-  T v1(19);
-  T v2(19);
-
-  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 ) ;
-  BOOST_CHECK ( !(def0 != def0) ) ;
-  BOOST_CHECK ( !(opt0 != opt0) ) ;
-
-  // Check when both are uininitalized.
-  BOOST_CHECK (   def0 == def1  ) ; // both uninitialized compare equal
-  BOOST_CHECK ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
-  BOOST_CHECK ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
-  BOOST_CHECK ( !(def0 != def1) ) ;
-  BOOST_CHECK (   def0 <= def1  ) ;
-  BOOST_CHECK (   def0 >= def1  ) ;
-
-  // Check when only lhs is uninitialized.
-  BOOST_CHECK (   def0 != opt0  ) ; // uninitialized is never equal to initialized
-  BOOST_CHECK ( !(def0 == opt0) ) ;
-  BOOST_CHECK (   def0 <  opt0  ) ; // uninitialized is always less than initialized
-  BOOST_CHECK ( !(def0 >  opt0) ) ;
-  BOOST_CHECK (   def0 <= opt0  ) ;
-  BOOST_CHECK ( !(def0 >= opt0) ) ;
-
-  // Check when only rhs is uninitialized.
-  BOOST_CHECK (   opt0 != def0  ) ; // initialized is never equal to uninitialized
-  BOOST_CHECK ( !(opt0 == def0) ) ;
-  BOOST_CHECK ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
-  BOOST_CHECK (   opt0 >  def0  ) ;
-  BOOST_CHECK ( !(opt0 <= def0) ) ;
-  BOOST_CHECK (   opt0 >= opt0  ) ;
-
-  // If both are initialized, values are compared
-  BOOST_CHECK ( opt0 != opt1 ) ;
-  BOOST_CHECK ( opt1 == opt2 ) ;
-  BOOST_CHECK ( opt0 <  opt1 ) ;
-  BOOST_CHECK ( opt1 >  opt0 ) ;
-  BOOST_CHECK ( opt1 <= opt2 ) ;
-  BOOST_CHECK ( opt1 >= opt0 ) ;
-}
-
-template<class T>
-void test_none( T const* )
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  using boost::none ;
-
-  T a(1234);
-
-  optional<T&> def0 ;
-  optional<T&> def1(none) ;
-  optional<T&> non_def(a) ;
-
-  BOOST_CHECK ( def0    == none ) ;
-  BOOST_CHECK ( non_def != none ) ;
-  BOOST_CHECK ( !def1           ) ;
-
-  non_def = none ;
-  BOOST_CHECK ( !non_def ) ;
-}
-
-void test_with_builtin_types()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  test_basics( ARG(double) );
-  test_relops( ARG(double) ) ;
-  test_none  ( ARG(double) ) ;
-}
-
-void test_with_class_type()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
-
-  test_basics( ARG(X) );
-  test_relops( ARG(X) ) ;
-  test_none  ( ARG(X) ) ;
-
-  BOOST_CHECK ( X::count == 0 ) ;
-}
-
-int test_main( int, char* [] )
-{
-  try
-  {
-    test_with_class_type();
-    test_with_builtin_types();
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
-
-  return 0;
-}
-
-

test/optional_test_ref_fail1.cpp

@@ -1,25 +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@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void optional_reference__test_no_converting_assignment()
-{
-  boost::optional<int&> opt ;
-  double v = 1 ;
-  double& r = v ;
-  opt = r ;
-}
-
-

test/optional_test_ref_fail2.cpp

@@ -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@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void optional_reference__test_no_ptr_access()
-{
-  boost::optional<int&> opt ;
-  opt.get_ptr();
-}
-
-

test/optional_test_ref_fail3.cpp

@@ -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@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void optional_reference__test_no_converting_ctor()
-{
-  boost::optional<short&> opt1 ;
-  boost::optional<int&> opt2 = opt1 ;
-}
-
-

test/optional_test_ref_fail4.cpp

@@ -1,24 +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@hotmail.com
-//
-#include "boost/optional.hpp"
-
-//
-// THIS TEST SHOULD FAIL TO COMPILE
-//
-void optional_reference__test_no_converting_initialization()
-{
-  short v = 1 ;
-  short& r = v;
-  boost::optional<int&> opt(r) ;
-}
-
-

test/optional_test_tie.cpp

@@ -1,64 +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@hotmail.com
-//
-#include<iostream>
-#include<stdexcept>
-#include<string>
-
-#define BOOST_ENABLE_ASSERT_HANDLER
-
-#include "boost/optional.hpp"
-#include "boost/tuple/tuple.hpp"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-#include "optional_test_common.cpp"
-
-// Test boost::tie() interoperabiliy.
-int test_main( int, char* [] )
-{
-  typedef X T ;
-          
-  try
-  {
-    TRACE( std::endl << BOOST_CURRENT_FUNCTION  );
-  
-    T z(0);
-    T a(1);
-    T b(2);
-  
-    optional<T> oa, ob ;
-  
-    // T::T( T const& x ) is used
-    set_pending_dtor( ARG(T) ) ;
-    set_pending_copy( ARG(T) ) ;
-    boost::tie(oa,ob) = std::make_pair(a,b) ;
-    check_is_not_pending_dtor( ARG(T) ) ;
-    check_is_not_pending_copy( ARG(T) ) ;
-    check_initialized(oa);
-    check_initialized(ob);
-    check_value(oa,a,z);
-    check_value(ob,b,z);
-    
-  }
-  catch ( ... )
-  {
-    BOOST_ERROR("Unexpected Exception caught!");
-  }
-
-  return 0;
-}
-
-