/usr/include/boost/variant
Edit: /usr/include/boost/variant/variant.hpp (71048B)
//-----------------------------------------------------------------------------
// boost variant/variant.hpp header file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
// Copyright (c) 2002-2003 Eric Friedman, Itay Maman
// Copyright (c) 2012-2020 Antony Polukhin
//
// Distributed under 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)
// Thanks to Adam Romanek for providing patches for exception-disabled env.
#ifndef BOOST_VARIANT_VARIANT_HPP
#define BOOST_VARIANT_VARIANT_HPP
#include
// for std::size_t
#include // for placement new
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
///////////////////////////////////////////////////////////////////////////////
// Implementation Macros:
//
// BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
// Defined in boost/variant/detail/visitation_impl.hpp.
//
// BOOST_VARIANT_MINIMIZE_SIZE
// When #defined, implementation employs all known means to minimize the
// size of variant obje cts. However, often unsuccessful due to alignment
// issues, and potentially harmful to runtime speed, so not enabled by
// default. (TODO: Investigate further.)
#if defined(BOOST_VARIANT_MINIMIZE_SIZE)
# include // for SCHAR_MAX
# include
# include
# include
# include
# include
# include
# include
# include
#endif
namespace boost {
namespace detail { namespace variant {
///////////////////////////////////////////////////////////////////////////////
// (detail) metafunction max_value
//
// Finds the maximum value of the unary metafunction F over Sequence.
//
template
struct max_value
{
private: // helpers, for metafunction result (below)
typedef typename mpl::transform1::type transformed_;
typedef typename mpl::max_element::type max_it;
public: // metafunction result
typedef typename mpl::deref::type
type;
};
struct add_alignment
{
template
struct apply
: mpl::size_t<
::boost::integer::static_lcm<
BOOST_MPL_AUX_VALUE_WKND(State)::value
, ::boost::alignment_of- ::value
>::value
>
{};
};
///////////////////////////////////////////////////////////////////////////////
// (detail) metafunction find_fallback_type
//
// Provides a fallback (i.e., nothrow default-constructible) type from the
// specified sequence, or no_fallback_type if not found.
//
// This implementation is designed to prefer boost::blank over other potential
// fallback types, regardless of its position in the specified sequence.
//
class no_fallback_type;
struct find_fallback_type_pred
{
template
struct apply
{
private:
typedef typename mpl::deref::type t_;
public:
typedef mpl::not_< has_nothrow_constructor > type;
};
};
template
struct find_fallback_type
{
private: // helpers, for metafunction result (below)
typedef typename mpl::end::type end_it;
// [Find the first suitable fallback type...]
typedef typename mpl::iter_fold_if<
Types
, mpl::int_<0>, mpl::protect< mpl::next<> >
, mpl::protect< find_fallback_type_pred >
>::type first_result_;
typedef typename first_result_::first first_result_index;
typedef typename first_result_::second first_result_it;
// [...now search the rest of the sequence for boost::blank...]
typedef typename mpl::iter_fold_if<
mpl::iterator_range< first_result_it,end_it >
, first_result_index, mpl::protect< mpl::next<> >
, mpl::protect< mpl::not_same_as >
>::type second_result_;
typedef typename second_result_::second second_result_it;
public: // metafunction result
// [...and return the results of the search:]
typedef typename mpl::eval_if<
is_same< second_result_it,end_it >
, mpl::if_<
is_same< first_result_it,end_it >
, mpl::pair< no_fallback_type,no_fallback_type >
, first_result_
>
, mpl::identity< second_result_ >
>::type type;
};
#ifndef BOOST_NO_CXX11_NOEXCEPT
///////////////////////////////////////////////////////////////////////////////
// (detail) metafunction is_variant_move_noexcept_constructible
//
// Returns true_type if all the types are nothrow move constructible.
//
template
struct is_variant_move_noexcept_constructible {
typedef typename boost::mpl::find_if<
Types, mpl::not_ >
>::type iterator_t;
typedef typename boost::mpl::end::type end_t;
typedef typename boost::is_same<
iterator_t, end_t
>::type type;
};
///////////////////////////////////////////////////////////////////////////////
// (detail) metafunction is_variant_move_noexcept_assignable
//
// Returns true_type if all the types are nothrow move constructible.
//
template
struct is_variant_move_noexcept_assignable {
typedef typename boost::mpl::find_if<
Types, mpl::not_ >
>::type iterator_t;
typedef typename boost::mpl::end::type end_t;
typedef typename boost::is_same<
iterator_t, end_t
>::type type;
};
#endif // BOOST_NO_CXX11_NOEXCEPT
///////////////////////////////////////////////////////////////////////////////
// (detail) metafunction is_variant_constructible_from
//
// Derives from true_type if at least one variant's type is constructible from T.
//
template
struct is_constructible_ext:
boost::mpl::or_<
boost::is_constructible<
T1,
T2
>,
boost::is_constructible<
T1,
typename boost::add_lvalue_reference::type
>
>
{};
template
struct is_variant_constructible_from:
boost::mpl::not_< boost::is_same<
typename boost::mpl::find_if<
Types,
is_constructible_ext
>::type,
typename boost::mpl::end::type
> >
{};
template
struct is_variant_constructible_from< boost::variant, Types >:
boost::is_same<
typename boost::mpl::find_if<
typename boost::variant::recursive_enabled_types,
mpl::not_< is_variant_constructible_from< boost::mpl::_1, Types> >
>::type,
typename boost::mpl::end< typename boost::variant::recursive_enabled_types >::type
>
{};
template
struct is_variant_constructible_from< const boost::variant& , Types >:
is_variant_constructible_from, Types >
{};
template
struct is_variant_constructible_from< boost::variant& , Types >:
is_variant_constructible_from, Types >
{};
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template
struct is_variant_constructible_from< boost::variant&& , Types >:
is_variant_constructible_from, Types >
{};
template
struct is_variant_constructible_from< boost::variant const && , Types >:
is_variant_constructible_from, Types >
{};
#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCE
///////////////////////////////////////////////////////////////////////////////
// (detail) metafunction make_storage
//
// Provides an aligned storage type capable of holding any of the types
// specified in the given type-sequence.
//
template
struct make_storage
{
private: // helpers, for metafunction result (below)
typedef typename mpl::eval_if<
NeverUsesBackupFlag
, mpl::identity< Types >
, mpl::push_front<
Types, backup_holder
>
>::type types;
typedef typename max_value<
types, mpl::sizeof_
>::type max_size;
#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0551))
typedef typename mpl::fold<
types
, mpl::size_t<1>
, add_alignment
>::type max_alignment;
#else // borland
// temporary workaround -- use maximal alignment
typedef mpl::size_t< -1 > max_alignment;
#endif // borland workaround
public: // metafunction result
typedef ::boost::aligned_storage<
BOOST_MPL_AUX_VALUE_WKND(max_size)::value
, BOOST_MPL_AUX_VALUE_WKND(max_alignment)::value
> type;
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class destroyer
//
// Internal visitor that destroys the value it visits.
//
struct destroyer
: public static_visitor<>
{
public: // visitor interfaces
template
void internal_visit(T& operand, int) const BOOST_NOEXCEPT
{
operand.~T(); // must be noexcept
#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0551)) || \
BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
(void)operand; // suppresses warnings
#endif
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class template known_get
//
// Visitor that returns a reference to content of the specified type.
//
// Precondition: visited variant MUST contain logical content of type T.
//
template
class known_get
: public static_visitor
{
public: // visitor interface
T& operator()(T& operand) const BOOST_NOEXCEPT
{
return operand;
}
template
T& operator()(U&) const
{
// logical error to be here: see precondition above
return ::boost::detail::variant::forced_return< T& >();
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class copy_into
//
// Internal visitor that copies the value it visits into the given buffer.
//
class copy_into
: public static_visitor<>
{
private: // representation
void* storage_;
public: // structors
explicit copy_into(void* storage) BOOST_NOEXCEPT
: storage_(storage)
{
}
public: // internal visitor interface
template
void internal_visit(boost::detail::variant::backup_holder& operand, long) const
{
new(storage_) T( operand.get() );
}
template
void internal_visit(const boost::detail::variant::backup_holder& operand, long) const
{
new(storage_) T( operand.get() );
}
template
void internal_visit(const T& operand, int) const
{
new(storage_) T(operand);
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class move_into
//
// Internal visitor that moves the value it visits into the given buffer.
//
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
class move_into
: public static_visitor<>
{
private: // representation
void* storage_;
public: // structors
explicit move_into(void* storage) BOOST_NOEXCEPT
: storage_(storage)
{
}
public: // internal visitor interface
template
void internal_visit(boost::detail::variant::backup_holder& operand, long) const
{
new(storage_) T( ::boost::detail::variant::move(operand.get()) );
}
template
void internal_visit(T& operand, int) const BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(T(boost::declval())))
{
new(storage_) T(::boost::detail::variant::move(operand));
}
};
#endif
///////////////////////////////////////////////////////////////////////////////
// (detail) class assign_storage
//
// Internal visitor that assigns the given storage (which must be a
// constructed value of the same type) to the value it visits.
//
struct assign_storage
: public static_visitor<>
{
private: // representation
const void* rhs_storage_;
public: // structors
explicit assign_storage(const void* rhs_storage) BOOST_NOEXCEPT
: rhs_storage_(rhs_storage)
{
}
public: // internal visitor interfaces
template
void internal_visit(backup_holder& lhs_content, long) const
{
lhs_content.get()
= static_cast< const backup_holder* >(rhs_storage_)->get();
}
template
void internal_visit(const backup_holder& lhs_content, long) const
{
lhs_content.get()
= static_cast< const backup_holder* >(rhs_storage_)->get();
}
template
void internal_visit(T& lhs_content, int) const
{
// NOTE TO USER :
// Compile error here indicates one of variant's bounded types does
// not meet the requirements of the Assignable concept. Thus,
// variant is not Assignable.
//
// Hint: Are any of the bounded types const-qualified or references?
//
lhs_content = *static_cast< const T* >(rhs_storage_);
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class move_storage
//
// Internal visitor that moves the given storage (which must be a
// constructed value of the same type) to the value it visits.
//
struct move_storage
: public static_visitor<>
{
private: // representation
void* rhs_storage_;
public: // structors
explicit move_storage(void* rhs_storage) BOOST_NOEXCEPT
: rhs_storage_(rhs_storage)
{
}
public: // internal visitor interfaces
template
void internal_visit(backup_holder& lhs_content, long) const
{
lhs_content.get()
= ::boost::detail::variant::move(static_cast* >(rhs_storage_)->get());
}
template
void internal_visit(const backup_holder& lhs_content, long) const
{
lhs_content.get()
= ::boost::detail::variant::move(static_cast* >(rhs_storage_)->get());
}
template
void internal_visit(T& lhs_content, int) const
{
// NOTE TO USER :
// Compile error here indicates one of variant's bounded types does
// not meet the requirements of the Assignable concept. Thus,
// variant is not Assignable.
//
// Hint: Are any of the bounded types const-qualified or references?
//
lhs_content = ::boost::detail::variant::move(*static_cast(rhs_storage_));
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class direct_assigner
//
// Generic static visitor that: if and only if the visited value is of the
// specified type, assigns the given value to the visited value and returns
// true; else returns false.
//
template
class direct_assigner
: public static_visitor
{
private: // representation
const T& rhs_;
public: // structors
explicit direct_assigner(const T& rhs) BOOST_NOEXCEPT
: rhs_(rhs)
{
}
public: // visitor interface
bool operator()(T& lhs)
{
lhs = rhs_;
return true;
}
template
bool operator()(U&) BOOST_NOEXCEPT
{
return false;
}
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
private:
// silence MSVC warning C4512: assignment operator could not be generated
direct_assigner& operator= (direct_assigner const&);
#endif
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class direct_mover
//
// Generic static visitor that: if and only if the visited value is of the
// specified type, move assigns the given value to the visited value and returns
// true; else returns false.
//
template
class direct_mover
: public static_visitor
{
private: // representation
T& rhs_;
public: // structors
explicit direct_mover(T& rhs) BOOST_NOEXCEPT
: rhs_(rhs)
{
}
public: // visitor interface
bool operator()(T& lhs)
{
lhs = ::boost::detail::variant::move(rhs_);
return true;
}
template
bool operator()(U&) BOOST_NOEXCEPT
{
return false;
}
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
private:
// silence MSVC warning C4512: assignment operator could not be generated
direct_mover& operator= (direct_mover const&);
#endif
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class backup_assigner
//
// Internal visitor that "assigns" the given value to the visited value,
// using backup to recover if the destroy-copy sequence fails.
//
// NOTE: This needs to be a friend of variant, as it needs access to
// indicate_which, indicate_backup_which, etc.
//
template
class backup_assigner
: public static_visitor<>
{
private: // representation
Variant& lhs_;
int rhs_which_;
const void* rhs_content_;
void (*copy_rhs_content_)(void*, const void*);
public: // structors
template
backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content)
: lhs_(lhs)
, rhs_which_(rhs_which)
, rhs_content_(&rhs_content)
, copy_rhs_content_(&construct_impl)
{
}
private: // helpers, for visitor interface (below)
template
static void construct_impl(void* addr, const void* obj)
{
new(addr) RhsT(*static_cast(obj));
}
template
void backup_assign_impl(
backup_holder& lhs_content
, mpl::false_ // is_nothrow_move_constructible
, long
)
{
// Move lhs content to backup...
backup_holder backup_lhs_content(0);
backup_lhs_content.swap(lhs_content); // nothrow
// ...destroy lhs content...
lhs_content.~backup_holder(); // nothrow
BOOST_TRY
{
// ...and attempt to copy rhs content into lhs storage:
copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
}
BOOST_CATCH (...)
{
// In case of failure, copy backup pointer to lhs storage...
new(lhs_.storage_.address())
backup_holder( 0 ); // nothrow
static_cast* >(lhs_.storage_.address())
->swap(backup_lhs_content); // nothrow
// ...and rethrow:
BOOST_RETHROW;
}
BOOST_CATCH_END
// In case of success, indicate new content type:
lhs_.indicate_which(rhs_which_); // nothrow
}
template
void backup_assign_impl(
LhsT& lhs_content
, mpl::true_ // is_nothrow_move_constructible
, int
)
{
// Move lhs content to backup...
LhsT backup_lhs_content(
::boost::detail::variant::move(lhs_content)
); // nothrow
// ...destroy lhs content...
lhs_content.~LhsT(); // nothrow
BOOST_TRY
{
// ...and attempt to copy rhs content into lhs storage:
copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
}
BOOST_CATCH (...)
{
// In case of failure, restore backup content to lhs storage...
new(lhs_.storage_.address())
LhsT(
::boost::detail::variant::move(backup_lhs_content)
); // nothrow
// ...and rethrow:
BOOST_RETHROW;
}
BOOST_CATCH_END
// In case of success, indicate new content type:
lhs_.indicate_which(rhs_which_); // nothrow
}
template
void backup_assign_impl(
LhsT& lhs_content
, mpl::false_ // is_nothrow_move_constructible
, int
)
{
// Backup lhs content...
LhsT* backup_lhs_ptr = new LhsT(lhs_content);
// ...destroy lhs content...
lhs_content.~LhsT(); // nothrow
BOOST_TRY
{
// ...and attempt to copy rhs content into lhs storage:
copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
}
BOOST_CATCH (...)
{
// In case of failure, copy backup pointer to lhs storage...
new(lhs_.storage_.address())
backup_holder( backup_lhs_ptr ); // nothrow
// ...indicate now using backup...
lhs_.indicate_backup_which( lhs_.which() ); // nothrow
// ...and rethrow:
BOOST_RETHROW;
}
BOOST_CATCH_END
// In case of success, indicate new content type...
lhs_.indicate_which(rhs_which_); // nothrow
// ...and delete backup:
delete backup_lhs_ptr; // nothrow
}
public: // visitor interface
template
void internal_visit(LhsT& lhs_content, int)
{
typedef typename is_nothrow_move_constructible::type
nothrow_move;
backup_assign_impl( lhs_content, nothrow_move(), 1L);
}
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
private:
// silence MSVC warning C4512: assignment operator could not be generated
backup_assigner& operator= (backup_assigner const&);
#endif
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class swap_with
//
// Visitor that swaps visited value with content of given variant.
//
// Precondition: Given variant MUST have same logical type as visited value.
//
template
struct swap_with
: public static_visitor<>
{
private: // representation
Variant& toswap_;
public: // structors
explicit swap_with(Variant& toswap) BOOST_NOEXCEPT
: toswap_(toswap)
{
}
public: // internal visitor interfaces
template
void operator()(T& operand) const
{
// Since the precondition ensures types are same, get T...
known_get getter;
T& other = toswap_.apply_visitor(getter);
// ...and swap:
::boost::detail::variant::move_swap( operand, other );
}
private:
swap_with& operator=(const swap_with&);
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class reflect
//
// Generic static visitor that performs a typeid on the value it visits.
//
class reflect
: public static_visitor
{
public: // visitor interfaces
template
const boost::typeindex::type_info& operator()(const T&) const BOOST_NOEXCEPT
{
return boost::typeindex::type_id().type_info();
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class comparer
//
// Generic static visitor that compares the content of the given lhs variant
// with the visited rhs content using Comp.
//
// Precondition: lhs.which() == rhs.which()
//
template
class comparer
: public static_visitor
{
private: // representation
const Variant& lhs_;
public: // structors
explicit comparer(const Variant& lhs) BOOST_NOEXCEPT
: lhs_(lhs)
{
}
public: // visitor interfaces
template
bool operator()(T& rhs_content) const
{
// Since the precondition ensures lhs and rhs types are same, get T...
known_get getter;
const T& lhs_content = lhs_.apply_visitor(getter);
// ...and compare lhs and rhs contents:
return Comp()(lhs_content, rhs_content);
}
private:
comparer& operator=(const comparer&);
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class equal_comp
//
// Generic function object compares lhs with rhs using operator==.
//
struct equal_comp
{
template
bool operator()(const T& lhs, const T& rhs) const
{
return lhs == rhs;
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class less_comp
//
// Generic function object compares lhs with rhs using operator<.
//
struct less_comp
{
template
bool operator()(const T& lhs, const T& rhs) const
{
return lhs < rhs;
}
};
///////////////////////////////////////////////////////////////////////////////
// (detail) class template invoke_visitor
//
// Internal visitor that invokes the given visitor using:
// * for wrappers (e.g., recursive_wrapper), the wrapper's held value.
// * for all other values, the value itself.
//
template
class invoke_visitor
{
private: // representation
Visitor& visitor_;
public: // visitor typedefs
typedef typename Visitor::result_type
result_type;
public: // structors
explicit invoke_visitor(Visitor& visitor) BOOST_NOEXCEPT
: visitor_(visitor)
{
}
public: // internal visitor interfaces
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
//using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
template
typename enable_if_c::value, result_type>::type internal_visit(T&& operand, int)
{
return visitor_(::boost::move(operand));
}
//using workaround with is_same to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
template
typename disable_if_c::value, result_type>::type internal_visit(T&& operand, int)
{
return visitor_(operand);
}
#else
template
result_type internal_visit(T& operand, int)
{
return visitor_(operand);
}
# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0564))
template
result_type internal_visit(const T& operand, int)
{
return visitor_(operand);
}
# endif //BORLAND
#endif //RVALUE REFERENCES
public: // internal visitor interfaces, cont.
template
result_type internal_visit(boost::recursive_wrapper& operand, long)
{
return internal_visit( operand.get(), 1L );
}
template
result_type internal_visit(const boost::recursive_wrapper& operand, long)
{
return internal_visit( operand.get(), 1L );
}
template
result_type internal_visit(boost::detail::reference_content& operand, long)
{
return internal_visit( operand.get(), 1L );
}
template
result_type internal_visit(const boost::detail::reference_content& operand, long)
{
return internal_visit( operand.get(), 1L );
}
template
result_type internal_visit(boost::detail::variant::backup_holder& operand, long)
{
return internal_visit( operand.get(), 1L );
}
template
result_type internal_visit(const boost::detail::variant::backup_holder& operand, long)
{
return internal_visit( operand.get(), 1L );
}
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
private:
// silence MSVC warning C4512: assignment operator could not be generated
invoke_visitor& operator= (invoke_visitor const&);
#endif
};
}} // namespace detail::variant
///////////////////////////////////////////////////////////////////////////////
// class template variant (concept inspired by Andrei Alexandrescu)
//
// See docs and boost/variant/variant_fwd.hpp for more information.
//
template <
typename T0_
, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)
>
class variant
{
private: // helpers, for typedefs (below)
typedef variant wknd_self_t;
struct is_recursive_
: detail::variant::is_recursive_flag
{
};
typedef typename mpl::eval_if<
is_recursive_
, T0_
, mpl::identity< T0_ >
>::type unwrapped_T0_;
struct is_sequence_based_
: detail::variant::is_over_sequence
{
};
#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
private: // helpers, for typedefs (below)
typedef typename mpl::eval_if<
is_sequence_based_
, unwrapped_T0_ // over_sequence<...>::type
, detail::variant::make_variant_list<
unwrapped_T0_
, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
>
>::type specified_types;
BOOST_STATIC_ASSERT((
::boost::mpl::not_< mpl::empty >::value
));
public: // public typedefs
typedef typename mpl::eval_if<
is_recursive_
, mpl::transform<
specified_types
, mpl::protect<
detail::variant::quoted_enable_recursive
>
>
, mpl::identity< specified_types >
>::type recursive_enabled_types; // used by is_variant_constructible_from<> trait
typedef typename mpl::transform<
recursive_enabled_types
, unwrap_recursive
>::type types;
private: // internal typedefs
typedef typename mpl::transform<
recursive_enabled_types
, mpl::protect< detail::make_reference_content<> >
>::type internal_types;
typedef typename mpl::front<
internal_types
>::type internal_T0;
#else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
private: // helpers, for typedefs (below)
typedef unwrapped_T0_ T0;
#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \
typedef typename mpl::eval_if< \
is_recursive_ \
, detail::variant::enable_recursive< \
BOOST_PP_CAT(T,N) \
, wknd_self_t \
> \
, mpl::identity< BOOST_PP_CAT(T,N) > \
>::type BOOST_PP_CAT(recursive_enabled_T,N); \
/**/
BOOST_PP_REPEAT(
BOOST_VARIANT_LIMIT_TYPES
, BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
, _
)
#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
#define BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS(z,N,_) \
typedef typename unwrap_recursive< \
BOOST_PP_CAT(recursive_enabled_T,N) \
>::type BOOST_PP_CAT(public_T,N); \
/**/
BOOST_PP_REPEAT(
BOOST_VARIANT_LIMIT_TYPES
, BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS
, _
)
#undef BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS
public: // public typedefs
typedef typename detail::variant::make_variant_list<
BOOST_VARIANT_ENUM_PARAMS(public_T)
>::type types;
private: // helpers, for internal typedefs (below)
#define BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS(z,N,_) \
typedef detail::make_reference_content< \
BOOST_PP_CAT(recursive_enabled_T,N) \
>::type BOOST_PP_CAT(internal_T,N); \
/**/
BOOST_PP_REPEAT(
BOOST_VARIANT_LIMIT_TYPES
, BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS
, _
)
#undef BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS
private: // internal typedefs
typedef typename detail::variant::make_variant_list<
BOOST_VARIANT_ENUM_PARAMS(internal_T)
>::type internal_types;
private: // static precondition assertions
// NOTE TO USER :
// variant< type-sequence > syntax is not supported on this compiler!
//
BOOST_MPL_ASSERT_NOT(( is_sequence_based_ ));
#endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround
private: // helpers, for representation (below)
typedef typename detail::variant::find_fallback_type<
internal_types
>::type fallback_type_result_;
typedef typename fallback_type_result_::first
fallback_type_index_;
typedef typename fallback_type_result_::second
fallback_type_;
struct has_fallback_type_
: mpl::not_<
is_same< fallback_type_, detail::variant::no_fallback_type >
>
{
};
typedef has_fallback_type_
never_uses_backup_flag;
typedef typename detail::variant::make_storage<
internal_types, never_uses_backup_flag
>::type storage_t;
#ifndef BOOST_NO_CXX11_NOEXCEPT
typedef typename detail::variant::is_variant_move_noexcept_constructible<
internal_types
> variant_move_noexcept_constructible;
typedef typename detail::variant::is_variant_move_noexcept_assignable<
internal_types
> variant_move_noexcept_assignable;
#endif
private: // helpers, for representation (below)
// which_ on:
// * [0, size) indicates stack content
// * [-size, 0) indicates pointer to heap backup
// if which_ >= 0:
// * then which() -> which_
// * else which() -> -(which_ + 1)
#if !defined(BOOST_VARIANT_MINIMIZE_SIZE)
typedef int which_t;
#else // defined(BOOST_VARIANT_MINIMIZE_SIZE)
// [if O1_size available, then attempt which_t size optimization...]
// [select signed char if fewer than SCHAR_MAX types, else signed int:]
typedef typename mpl::eval_if<
mpl::equal_to< mpl::O1_size, mpl::long_<-1> >
, mpl::identity< int >
, mpl::if_<
mpl::less< mpl::O1_size, mpl::int_ >
, signed char
, int
>
>::type which_t;
#endif // BOOST_VARIANT_MINIMIZE_SIZE switch
// representation -- private when possible
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
private:
#else
public:
#endif
which_t which_;
storage_t storage_;
void indicate_which(int which_arg) BOOST_NOEXCEPT
{
which_ = static_cast( which_arg );
}
void indicate_backup_which(int which_arg) BOOST_NOEXCEPT
{
which_ = static_cast( -(which_arg + 1) );
}
private: // helpers, for queries (below)
bool using_backup() const BOOST_NOEXCEPT
{
return which_ < 0;
}
public: // queries
int which() const BOOST_NOEXCEPT
{
// If using heap backup...
if (using_backup())
// ...then return adjusted which_:
return -(which_ + 1);
// Otherwise, return which_ directly:
return which_;
}
private: // helpers, for structors (below)
struct initializer
: BOOST_VARIANT_AUX_INITIALIZER_T(
recursive_enabled_types, recursive_enabled_T
)
{
};
void destroy_content() BOOST_NOEXCEPT
{
detail::variant::destroyer visitor;
this->internal_apply_visitor(visitor);
}
public: // structors
~variant() BOOST_NOEXCEPT
{
destroy_content();
}
variant()
#if !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
BOOST_NOEXCEPT_IF(boost::has_nothrow_constructor::value)
#endif
{
#ifdef _MSC_VER
#pragma warning( push )
// behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized
#pragma warning( disable : 4345 )
#endif
// NOTE TO USER :
// Compile error from here indicates that the first bound
// type is not default-constructible, and so variant cannot
// support its own default-construction.
//
new( storage_.address() ) internal_T0();
indicate_which(0); // zero is the index of the first bounded type
#ifdef _MSC_VER
#pragma warning( pop )
#endif
}
private: // helpers, for structors, cont. (below)
class convert_copy_into
: public static_visitor
{
private: // representation
void* storage_;
public: // structors
explicit convert_copy_into(void* storage) BOOST_NOEXCEPT
: storage_(storage)
{
}
public: // internal visitor interfaces (below)
template
int internal_visit(T& operand, int) const
{
// NOTE TO USER :
// Compile error here indicates one of the source variant's types
// cannot be unambiguously converted to the destination variant's
// types (or that no conversion exists).
//
return initializer::initialize(storage_, operand);
}
# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0564))
template
result_type internal_visit(const T& operand, int) const
{
return initializer::initialize(storage_, operand);
}
# endif
template
int internal_visit(boost::detail::reference_content& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(const boost::detail::reference_content& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(boost::detail::variant::backup_holder& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(const boost::detail::variant::backup_holder& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(boost::recursive_wrapper& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(const boost::recursive_wrapper& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
};
friend class convert_copy_into;
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
class convert_move_into
: public static_visitor
{
private: // representation
void* storage_;
public: // structors
explicit convert_move_into(void* storage) BOOST_NOEXCEPT
: storage_(storage)
{
}
public: // internal visitor interfaces (below)
template
int internal_visit(T& operand, int) const
{
// NOTE TO USER :
// Compile error here indicates one of the source variant's types
// cannot be unambiguously converted to the destination variant's
// types (or that no conversion exists).
//
return initializer::initialize(storage_, detail::variant::move(operand) );
}
template
int internal_visit(boost::detail::reference_content& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(const boost::detail::reference_content& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(boost::detail::variant::backup_holder& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(const boost::detail::variant::backup_holder& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(boost::recursive_wrapper& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
template
int internal_visit(const boost::recursive_wrapper& operand, long) const
{
return internal_visit( operand.get(), 1L );
}
};
friend class convert_move_into;
#endif
private: // helpers, for structors, below
template
void convert_construct(
T& operand
, int
, mpl::false_ = mpl::false_() // is_foreign_variant
)
{
// NOTE TO USER :
// Compile error here indicates that the given type is not
// unambiguously convertible to one of the variant's types
// (or that no conversion exists).
//
indicate_which(
initializer::initialize(
storage_.address()
, operand
)
);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template
typename boost::enable_if >::type convert_construct(
T&& operand
, int
, mpl::false_ = mpl::false_() // is_foreign_variant
)
{
// NOTE TO USER :
// Compile error here indicates that the given type is not
// unambiguously convertible to one of the variant's types
// (or that no conversion exists).
//
indicate_which(
initializer::initialize(
storage_.address()
, detail::variant::move(operand)
)
);
}
#endif
template
void convert_construct(
Variant& operand
, long
, mpl::true_// is_foreign_variant
)
{
convert_copy_into visitor(storage_.address());
indicate_which(
operand.internal_apply_visitor(visitor)
);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template
typename boost::enable_if >::type convert_construct(
Variant&& operand
, long
, mpl::true_// is_foreign_variant
)
{
convert_move_into visitor(storage_.address());
indicate_which(
operand.internal_apply_visitor(visitor)
);
}
#endif
template
void convert_construct_variant(Variant& operand)
{
// [Determine if the given variant is itself a bounded type, or if its
// content needs to be converted (i.e., it is a 'foreign' variant):]
//
typedef typename mpl::find_if<
types
, is_same<
add_const
, const Variant
>
>::type found_it;
typedef typename mpl::end::type not_found;
typedef typename is_same<
found_it, not_found
>::type is_foreign_variant;
// Convert construct from operand:
convert_construct(
operand, 1L
, is_foreign_variant()
);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template