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

Remove valueless; monostate is enough

Browse Source
This commit is contained in:
Peter Dimov
2018-10-18 03:32:57 +03:00
parent 19d48d9d8b
commit 46ee0af110
2 changed files with 174 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/variant_valueless.cpp
+164 -144
View File
@@ -17,217 +17,237 @@ using namespace boost::variant2;
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
enum E1
{
e1
};
//
enum E2
{
e2
};
enum E1 { e1 };
enum E1x { e1x };
struct X1
{
X1() = default;
X1( E2 ) { throw std::runtime_error( "X1(E2)" ); }
X1( E1 ) noexcept {}
X1( E1x ) { throw std::runtime_error( "X1(E1x)" ); }
};
STATIC_ASSERT( std::is_nothrow_default_constructible<X1>::value );
STATIC_ASSERT( std::is_nothrow_copy_constructible<X1>::value );
STATIC_ASSERT( std::is_nothrow_move_constructible<X1>::value );
STATIC_ASSERT( !std::is_nothrow_constructible<X1, E2>::value );
STATIC_ASSERT( std::is_trivially_destructible<X1>::value );
STATIC_ASSERT( std::is_trivially_move_assignable<X1>::value );
STATIC_ASSERT( std::is_nothrow_constructible<X1, E1>::value );
STATIC_ASSERT( !std::is_nothrow_constructible<X1, E1x>::value );
enum E2 { e2 };
enum E2x { e2x };
struct X2
{
X2() = default;
X2();
~X2();
X2( E2 ) { throw std::runtime_error( "X1(E2)" ); }
X2( E2 ) noexcept {}
X2( E2x ) { throw std::runtime_error( "X2(E2x)" ); }
};
X2::X2() {}
X2::~X2() {}
STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
STATIC_ASSERT( std::is_nothrow_copy_constructible<X2>::value );
STATIC_ASSERT( std::is_nothrow_move_constructible<X2>::value );
STATIC_ASSERT( !std::is_nothrow_constructible<X2, E2>::value );
STATIC_ASSERT( !std::is_trivially_destructible<X2>::value );
STATIC_ASSERT( std::is_nothrow_constructible<X2, E2>::value );
STATIC_ASSERT( !std::is_nothrow_constructible<X2, E2x>::value );
enum E3 { e3 };
enum E3x { e3x };
struct X3
{
X3() = default;
X3();
X3( X3 const& ) {}
X3( X3&& ) {}
X3( E3 ) noexcept {}
X3( E3x ) { throw std::runtime_error( "X3(E3x)" ); }
X3& operator=( X3 const& ) = default;
X3& operator=( X3&& ) = default;
};
X3::X3() {}
STATIC_ASSERT( !std::is_nothrow_default_constructible<X3>::value );
STATIC_ASSERT( !std::is_nothrow_copy_constructible<X3>::value );
STATIC_ASSERT( !std::is_nothrow_move_constructible<X3>::value );
STATIC_ASSERT( std::is_trivially_destructible<X3>::value );
STATIC_ASSERT( std::is_trivially_move_assignable<X3>::value );
STATIC_ASSERT( std::is_nothrow_constructible<X3, E3>::value );
STATIC_ASSERT( !std::is_nothrow_constructible<X3, E3x>::value );
//
STATIC_ASSERT( std::is_nothrow_default_constructible<monostate>::value );
STATIC_ASSERT( std::is_nothrow_copy_constructible<monostate>::value );
STATIC_ASSERT( std::is_nothrow_move_constructible<monostate>::value );
STATIC_ASSERT( std::is_trivially_destructible<monostate>::value );
//
int main()
{
{
variant<monostate, E1, X1> v;
variant<X2, X1> v;
v = e1;
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
BOOST_TEST_EQ( v.index(), 0 );
try
{
v = e2;
BOOST_ERROR( "`v = e2;` failed to throw" );
v = e1x;
BOOST_ERROR( "`v = e1x;` failed to throw" );
}
catch( std::exception const& )
{
// basic guarantee; X1 is nothrow default-constructible
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
}
}
{
variant<X3, E1, X1> v;
v = e1;
variant<X1, X2> v( e2 );
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
try
{
v = e2;
BOOST_ERROR( "`v = e2;` failed to throw" );
}
catch( std::exception const& )
{
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
}
}
{
variant<valueless, E1, X1> v;
v = e1;
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
try
{
v = e2;
BOOST_ERROR( "`v = e2;` failed to throw" );
}
catch( std::exception const& )
{
// all types are trivial, so we get a constexpr path
// and v.index() stays 1
BOOST_TEST( v.index() == 0 || v.index() == 1 );
if( v.index() == 1 )
{
BOOST_TEST_EQ( get<1>(v), e1 );
}
}
}
{
variant<monostate, E1, X1, valueless> v;
v = e1;
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
try
{
v = e2;
BOOST_ERROR( "`v = e2` failed to throw" );
}
catch( std::exception const& )
{
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
}
}
{
variant<monostate, E1, X2> v;
v = e1;
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
try
{
v = e2;
BOOST_ERROR( "`v = e2;` failed to throw" );
}
catch( std::exception const& )
{
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
}
}
{
variant<X3, E1, X2> v;
v = e1;
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
try
{
v = e2;
BOOST_ERROR( "`v = e2;` failed to throw" );
}
catch( std::exception const& )
{
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
}
}
{
variant<valueless, E1, X2> v;
v = e1;
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
try
{
v = e2;
BOOST_ERROR( "`v = e2;` failed to throw" );
v = e1x;
BOOST_ERROR( "`v = e1x;` failed to throw" );
}
catch( std::exception const& )
{
// basic guarantee; X1 is nothrow default-constructible
BOOST_TEST_EQ( v.index(), 0 );
}
}
{
variant<monostate, E1, X2, valueless> v;
variant<X2, X1, monostate> v;
v = e1;
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
BOOST_TEST_EQ( v.index(), 0 );
try
{
v = e2;
BOOST_ERROR( "`v = e2;` failed to throw" );
v = e1x;
BOOST_ERROR( "`v = e1x;` failed to throw" );
}
catch( std::exception const& )
{
BOOST_TEST_EQ( v.index(), 1 );
BOOST_TEST_EQ( get<1>(v), e1 );
// basic guarantee; monostate
BOOST_TEST_EQ( v.index(), 2 );
}
}
{
variant<X1, X2, monostate> v( e2 );
BOOST_TEST_EQ( v.index(), 1 );
try
{
v = e1x;
BOOST_ERROR( "`v = e1x;` failed to throw" );
}
catch( std::exception const& )
{
// basic guarantee; monostate
BOOST_TEST_EQ( v.index(), 2 );
}
}
{
variant<X2, X3, X1> v;
BOOST_TEST_EQ( v.index(), 0 );
try
{
v = e3x;
BOOST_ERROR( "`v = e3x;` failed to throw" );
}
catch( std::exception const& )
{
// basic guarantee; X1 is nothrow default-constructible
BOOST_TEST_EQ( v.index(), 2 );
}
}
{
variant<X2, X3, X1, monostate> v;
BOOST_TEST_EQ( v.index(), 0 );
try
{
v = e3x;
BOOST_ERROR( "`v = e3x;` failed to throw" );
}
catch( std::exception const& )
{
// basic guarantee; monostate
BOOST_TEST_EQ( v.index(), 3 );
}
}
{
variant<X2, X3> v;
BOOST_TEST_EQ( v.index(), 0 );
try
{
v = e3x;
BOOST_ERROR( "`v = e3x;` failed to throw" );
}
catch( std::exception const& )
{
// double buffered, no change
BOOST_TEST_EQ( v.index(), 0 );
}
}
{
variant<X3, X1> v;
BOOST_TEST_EQ( v.index(), 0 );
try
{
v = e1x;
BOOST_ERROR( "`v = e1x;` failed to throw" );
}
catch( std::exception const& )
{
// all trivially destructible and move-assignable, no change
BOOST_TEST_EQ( v.index(), 0 );
}
}
{
variant<X3, X1, monostate> v;
BOOST_TEST_EQ( v.index(), 0 );
try
{
v = e1x;
BOOST_ERROR( "`v = e1x;` failed to throw" );
}
catch( std::exception const& )
{
// all trivially destructible and move-assignable, no change
BOOST_TEST_EQ( v.index(), 0 );
}
}