#ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP

#define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP

#include <boost/optional/detail/optional_select_implementation.hpp>

#include <boost/optional/detail/optional_common_defs.hpp>

#ifndef BOOST_NO_IOSTREAM

#include <iosfwd>

namespace boost {

template<class CharType, class CharTrait>

std::basic_ostream<CharType, CharTrait>&

operator<<(std::basic_ostream<CharType, CharTrait>& os, optional_detail::optional_tag const&)

{

static_assert(sizeof(CharType) == 0, "If you want to output boost::optional, include header <boost/optional/optional_io.hpp>");

return os;

}

} // namespace boost

#endif // BOOST_NO_IOSTREAM

#include <boost/none.hpp>

#if defined BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION

#include <boost/optional/detail/union_optional.hpp>

#else

#include <new>

#include <boost/assert.hpp>

#include <boost/core/enable_if.hpp>

#include <boost/core/invoke_swap.hpp>

#include <boost/core/launder.hpp>

#include <boost/optional/bad_optional_access.hpp>

#include <boost/throw_exception.hpp>

#include <boost/type_traits/alignment_of.hpp>

#include <boost/type_traits/conditional.hpp>

#include <boost/type_traits/conjunction.hpp>

#include <boost/type_traits/disjunction.hpp>

#include <boost/type_traits/has_nothrow_constructor.hpp>

#include <boost/type_traits/type_with_alignment.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <boost/type_traits/remove_reference.hpp>

#include <boost/type_traits/decay.hpp>

#include <boost/type_traits/is_assignable.hpp>

#include <boost/type_traits/is_base_of.hpp>

#include <boost/type_traits/is_const.hpp>

#include <boost/type_traits/is_constructible.hpp>

#include <boost/type_traits/is_convertible.hpp>

#include <boost/type_traits/is_lvalue_reference.hpp>

#include <boost/type_traits/is_nothrow_move_assignable.hpp>

#include <boost/type_traits/is_nothrow_move_constructible.hpp>

#include <boost/type_traits/is_rvalue_reference.hpp>

#include <boost/type_traits/is_same.hpp>

#include <boost/type_traits/is_volatile.hpp>

#include <boost/type_traits/is_scalar.hpp>

#include <boost/optional/optional_fwd.hpp>

#include <boost/optional/detail/optional_config.hpp>

#include <boost/optional/detail/optional_aligned_storage.hpp>

namespace boost {

namespace optional_detail {

struct init_value_tag {};

template<class T>

class optional_base : public optional_tag

} ;

#include <boost/optional/detail/optional_trivially_copyable_base.hpp>

template <typename U>

struct is_optional_or_tag

{};

template <typename T, typename U>

struct has_dedicated_constructor

: boost::disjunction<is_optional_or_tag<U>, boost::is_same<T, BOOST_DEDUCED_TYPENAME boost::decay<U>::type> >

{};

template <typename U>

struct is_factory

: boost::disjunction< is_in_place_factory<U>, is_typed_in_place_factory<U> >

{};

#if !defined(BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT)

template <typename T, typename U>

struct is_factory_or_constructible_to_T

: boost::disjunction< is_factory<U>, boost::is_constructible<T, U&&> >

{};

template <typename T, typename U>

struct is_optional_constructible : boost::is_constructible<T, U>

{};

#else

template <typename, typename>

struct is_factory_or_constructible_to_T : boost::true_type

{};

template <typename T, typename U>

struct is_optional_constructible : boost::true_type

{};

#endif // is_convertible condition

#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)

template <typename T, typename U>

struct is_opt_assignable

: boost::conjunction<boost::is_convertible<U&&, T>, boost::is_assignable<T&, U&&> >

{};

#else

template <typename T, typename U>

struct is_opt_assignable : boost::is_convertible<U, T>

{};

#endif

template <typename T, typename U>

struct is_factory_or_opt_assignable_to_T

: boost::disjunction< is_factory<U>, is_opt_assignable<T, U> >

{};

template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>

struct is_optional_val_init_candidate

: boost::false_type

{};

template <typename T, typename U>

struct is_optional_val_init_candidate<T, U, false>

: is_factory_or_constructible_to_T<T, U>

{};

template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>

struct is_optional_val_assign_candidate

: boost::false_type

{};

template <typename T, typename U>

struct is_optional_val_assign_candidate<T, U, false>

: is_factory_or_opt_assignable_to_T<T, U>

{};

} // namespace optional_detail

namespace optional_config {

template <typename T>

struct optional_uses_direct_storage_for

: boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)

, boost::true_type, boost::false_type>::type

{};

} // namespace optional_config

#ifndef BOOST_OPTIONAL_DETAIL_NO_DIRECT_STORAGE_SPEC

# define BOOST_OPTIONAL_BASE_TYPE(T) boost::conditional< optional_config::optional_uses_direct_storage_for<T>::value, \

optional_detail::tc_optional_base<T>, \

optional_detail::optional_base<T> \

>::type

#else

# define BOOST_OPTIONAL_BASE_TYPE(T) optional_detail::optional_base<T>

#endif

template<class T>

class optional

: public BOOST_OPTIONAL_BASE_TYPE(T)

{

typedef typename BOOST_OPTIONAL_BASE_TYPE(T) base ;

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::rval_reference_type rval_reference_type ;

typedef BOOST_DEDUCED_TYPENAME base::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ;

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() BOOST_NOEXCEPT : base() {}

// Creates an optional<T> uninitialized.

// No-throw

optional( none_t none_ ) BOOST_NOEXCEPT : base(none_) {}

// Creates an optional<T> initialized with 'val'.

// Can throw if T::T(T const&) does

optional ( argument_type val ) : base(optional_detail::init_value_tag(), val) {}

// Creates an optional<T> initialized with 'move(val)'.

// Can throw if T::T(T &&) does

optional ( rval_reference_type val ) : base(optional_detail::init_value_tag(), optional_detail::forward_<T>(val))

{}

// Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional.

// Can throw if T::T(T const&) does

optional ( bool cond, argument_type val ) : base(cond,val) {}

/// Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional.

// Can throw if T::T(T &&) does

optional ( bool cond, rval_reference_type val ) : base( cond, optional_detail::forward_<T>(val) )

{}

// 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

}

// Creates a deep move of another convertible optional<U>

// Requires a valid conversion from U to T.

// Can throw if T::T(U&&) does

template<class U>

explicit optional ( optional<U> && rhs

}

#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 implicitly 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 if the resolved T ctor throws.

template<class Expr>

explicit optional ( Expr&& expr,

{}

#endif // !defined BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT

// Creates a deep copy of another optional<T>

// Can throw if T::T(T const&) does

#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS

optional ( optional const& ) = default;

#else

optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}

#endif

// Creates a deep move of another optional<T>

// Can throw if T::T(T&&) does

#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS

optional ( optional && ) = default;

#else

optional ( optional && rhs )

BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value)

: base( optional_detail::move_(rhs) )

{}

#endif

#if BOOST_WORKAROUND(_MSC_VER, <= 1600)

// On old MSVC compilers the implicitly declared dtor is not called

~optional() {}

#endif

#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>

BOOST_DEDUCED_TYPENAME boost::enable_if<optional_detail::is_optional_val_assign_candidate<T, Expr>, optional&>::type

operator= ( Expr&& expr )

{

this->assign_expr(optional_detail::forward_<Expr>(expr),boost::addressof(expr));

return *this ;

}

#endif // !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION)

// Copy-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);

return *this ;

}

// Move-assigns from another convertible optional<U> (converts && deep-moves the rhs value)

// Requires a valid conversion from U to T.

// Basic Guarantee: If T::T( U && ) throws, this is left UNINITIALIZED

template<class U>

optional& operator= ( optional<U> && rhs )

{

this->assign(optional_detail::move_(rhs));

return *this ;

}

// 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)

#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS

optional& operator= ( optional const& rhs ) = default;

#else

optional& operator= ( optional const& rhs )

{

this->assign( static_cast<base const&>(rhs) ) ;

return *this ;

}

#endif

// Assigns from another optional<T> (deep-moves the rhs value)

#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS

optional& operator= ( optional && ) = default;

#else

optional& operator= ( optional && rhs )

BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)

}

#endif

#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX

// Assigns from a T (deep-moves/copies the rhs value)

template <typename T_>

BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_same<T, BOOST_DEDUCED_TYPENAME boost::decay<T_>::type>, optional&>::type

operator= ( T_&& val )

{

this->assign( optional_detail::forward_<T_>(val) ) ;

return *this ;

}

#else

// 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 T (deep-moves the rhs value)

optional& operator= ( rval_reference_type val )

{

this->assign( optional_detail::move_(val) ) ;

return *this ;

}

#endif // BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX

// 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 none_ ) BOOST_NOEXCEPT

{

this->assign( none_ ) ;

return *this ;

}

// Constructs in-place

// upon exception *this is always uninitialized

template<class... Args>

void emplace ( Args&&... args )

{

this->emplace_assign( optional_detail::forward_<Args>(args)... );

}

template<class... Args>

explicit optional ( in_place_init_t, Args&&... args )

: base( in_place_init, optional_detail::forward_<Args>(args)... )

{}

template<class... Args>

explicit optional ( in_place_init_if_t, bool cond, Args&&... args )

: base( in_place_init_if, cond, optional_detail::forward_<Args>(args)... )

{}

void swap( optional & arg )

BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)

}

// 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 copy of the value if this is initialized, 'v' otherwise

reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; }

reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; }

// 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 *() BOOST_OPTIONAL_CONST_REF_QUAL { return this->get() ; }

reference_type operator *() BOOST_OPTIONAL_REF_QUAL { return this->get() ; }

#ifndef BOOST_NO_CXX11_REF_QUALIFIERS

reference_type_of_temporary_wrapper operator *() && { return optional_detail::move_(this->get()) ; }

#endif

reference_const_type value() BOOST_OPTIONAL_CONST_REF_QUAL

{

if (this->is_initialized())

return this->get() ;

else

throw_exception(bad_optional_access());

}

reference_type value() BOOST_OPTIONAL_REF_QUAL

{

if (this->is_initialized())

return this->get() ;

else

throw_exception(bad_optional_access());

}

template <class U>

value_type value_or ( U&& v ) BOOST_OPTIONAL_CONST_REF_QUAL

{

if (this->is_initialized())

return get();

else

return optional_detail::forward_<U>(v);

}

template <typename F>

value_type value_or_eval ( F f ) BOOST_OPTIONAL_CONST_REF_QUAL

{

if (this->is_initialized())

return get();

else

return f();

}

#ifndef BOOST_NO_CXX11_REF_QUALIFIERS

reference_type_of_temporary_wrapper value() &&

}

template <class U>

value_type value_or ( U&& v ) &&

}

template <typename F>

value_type value_or_eval ( F f ) &&

}

#endif

template <typename F>

optional<typename optional_detail::result_of<F, reference_type>::type> map(F f) BOOST_OPTIONAL_REF_QUAL

{

if (this->has_value())

return f(get());

else

return none;

}

template <typename F>

optional<typename optional_detail::result_of<F, reference_const_type>::type> map(F f) BOOST_OPTIONAL_CONST_REF_QUAL

{

if (this->has_value())

return f(get());

else

return none;

}

#ifndef BOOST_NO_CXX11_REF_QUALIFIERS

template <typename F>

optional<typename optional_detail::result_of<F, reference_type_of_temporary_wrapper>::type> map(F f) &&

}

#endif

template <typename F>

optional<typename optional_detail::result_value_type<F, reference_type>::type>

flat_map(F f) BOOST_OPTIONAL_REF_QUAL

{

if (this->has_value())

return f(get());

else

return none;

}

template <typename F>

optional<typename optional_detail::result_value_type<F, reference_const_type>::type>

flat_map(F f) BOOST_OPTIONAL_CONST_REF_QUAL

{

if (this->has_value())

return f(get());

else

return none;

}