feedc0de/boost_variant2
1
0
Fork 0
forked from boostorg/variant2
Code Pull Requests Activity

Remove commented-out variant_copy_base

Browse Source
This commit is contained in:
Peter Dimov
2020-01-23 01:08:32 +02:00
parent ef2ef292b9
commit 972280e59f
1 changed files with 0 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
include/boost/variant2/variant.hpp
View File

@ -1052,162 +1052,6 @@ template<class T> struct is_nothrow_swappable: mp11::mp_valid<det2::is_nothrow_s
#endif
// variant_copy_base
/*
template<bool Trivial, class... T> struct variant_copy_base_impl;
template<class... T> using variant_copy_base = variant_copy_base_impl<
mp11::mp_all<
std::is_trivially_destructible<T>...,
is_trivially_copy_constructible<T>...,
is_trivially_move_constructible<T>...,
is_trivially_copy_assignable<T>...,
is_trivially_move_assignable<T>...>::value, T...>;
template<class... T> struct variant_copy_base_impl<true, T...>: public variant_base<T...>
{
using variant_base = detail::variant_base<T...>;
using variant_base::variant_base;
variant_copy_base_impl() = default;
variant_copy_base_impl( variant_copy_base_impl const& ) = default;
variant_copy_base_impl( variant_copy_base_impl && ) = default;
variant_copy_base_impl& operator=( variant_copy_base_impl const& ) = default;
variant_copy_base_impl& operator=( variant_copy_base_impl && ) = default;
};
template<class... T> struct variant_copy_base_impl<false, T...>: public variant_base<T...>
{
using variant_base = detail::variant_base<T...>;
using variant_base::variant_base;
private:
variant_copy_base_impl( variant_copy_base_impl const volatile& r ) = delete;
variant_copy_base_impl& operator=( variant_copy_base_impl const volatile& r ) = delete;
public:
variant_copy_base_impl() = default;
// copy constructor
template<class E1 = void,
class E2 = mp11::mp_if<mp11::mp_all<detail::is_trivially_copy_constructible<T>...>, E1>
>
constexpr variant_copy_base_impl( variant_copy_base_impl const& r ) noexcept
: variant_base( static_cast<variant_base const&>(r) )
{
}
private:
struct L1
{
variant_base * this_;
variant_copy_base_impl const & r;
template<class I> void operator()( I i ) const
{
this_->_replace( i, r._get_impl( i ) );
}
};
public:
template<class E1 = void,
class E2 = mp11::mp_if<mp11::mp_not<mp11::mp_all<detail::is_trivially_copy_constructible<T>...>>, E1>,
class E3 = mp11::mp_if<mp11::mp_all<std::is_copy_constructible<T>...>, E1>
>
variant_copy_base_impl( variant_copy_base_impl const& r )
noexcept( mp11::mp_all<std::is_nothrow_copy_constructible<T>...>::value )
{
mp11::mp_with_index<sizeof...(T)>( r.index(), L1{ this, r } );
}
// move constructor
variant_copy_base_impl( variant_copy_base_impl && ) = default;
// copy assignment
template<class E1 = void,
class E2 = mp11::mp_if<mp11::mp_all<std::is_trivially_destructible<T>..., detail::is_trivially_copy_constructible<T>..., detail::is_trivially_copy_assignable<T>...>, E1>
>
BOOST_CXX14_CONSTEXPR variant_copy_base_impl& operator=( variant_copy_base_impl const & r ) noexcept
{
static_cast<variant_base&>( *this ) = static_cast<variant_base const&>( r );
return *this;
}
private:
struct L3
{
variant_copy_base_impl * this_;
variant_copy_base_impl const & r;
template<class I> void operator()( I i ) const
{
this_->variant_base::template emplace<I::value>( r._get_impl( i ) );
}
};
public:
template<class E1 = void,
class E2 = mp11::mp_if<mp11::mp_not<mp11::mp_all<std::is_trivially_destructible<T>..., detail::is_trivially_copy_constructible<T>..., detail::is_trivially_copy_assignable<T>...>>, E1>,
class E3 = mp11::mp_if<mp11::mp_all<std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>, E1>
>
BOOST_CXX14_CONSTEXPR variant_copy_base_impl& operator=( variant_copy_base_impl const & r )
noexcept( mp11::mp_all<std::is_nothrow_copy_constructible<T>...>::value )
{
mp11::mp_with_index<sizeof...(T)>( r.index(), L3{ this, r } );
return *this;
}
// move assignment
template<class E1 = void,
class E2 = mp11::mp_if<mp11::mp_all<std::is_trivially_destructible<T>..., detail::is_trivially_move_constructible<T>..., detail::is_trivially_move_assignable<T>...>, E1>
>
BOOST_CXX14_CONSTEXPR variant_copy_base_impl& operator=( variant_copy_base_impl && r ) noexcept
{
static_cast<variant_base&>( *this ) = static_cast<variant_base&&>( r );
return *this;
}
private:
struct L4
{
variant_copy_base_impl * this_;
variant_copy_base_impl & r;
template<class I> void operator()( I i ) const
{
this_->variant_base::template emplace<I::value>( std::move( r._get_impl( i ) ) );
}
};
public:
template<class E1 = void,
class E2 = mp11::mp_if<mp11::mp_not<mp11::mp_all<std::is_trivially_destructible<T>..., detail::is_trivially_move_constructible<T>..., detail::is_trivially_move_assignable<T>...>>, E1>,
class E3 = mp11::mp_if<mp11::mp_all<std::is_move_constructible<T>..., std::is_move_assignable<T>...>, E1>
>
variant_copy_base_impl& operator=( variant_copy_base_impl && r )
noexcept( mp11::mp_all<std::is_nothrow_move_constructible<T>...>::value )
{
mp11::mp_with_index<sizeof...(T)>( r.index(), L4{ this, r } );
return *this;
}
};
*/
// variant_cc_base
template<bool CopyConstructible, bool TriviallyCopyConstructible, class... T> struct variant_cc_base_impl;