Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

refine noexcept specifiers on constructors #62

Merged
merged 3 commits into from
Jan 28, 2016
Merged

refine noexcept specifiers on constructors #62

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
244c3b7
refine noexcept specifiers on constructors
lightmare Jan 14, 2016
24f69e1
avoid std::is_nothrow_destructible if gcc < 4.8
lightmare Jan 16, 2016
cfa1f95
attempt to fix MSVC error on conversion constructor SFINAE
lightmare Jan 16, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 12 additions & 0 deletions test/t/variant.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -235,6 +235,18 @@ TEST_CASE( "implicit conversion to unsigned char", "[variant][implicit conversio

struct dummy {};

TEST_CASE( "implicit conversion to a suitable type", "[variant][implicit conversion]" ) {
using mapbox::util::variant;
CHECK_NOTHROW((variant<dummy, float, std::string>(123)).get<float>());
CHECK_NOTHROW((variant<dummy, float, std::string>("foo")).get<std::string>());
}

TEST_CASE( "value_traits for non-convertible type", "[variant::detail]" ) {
namespace detail = mapbox::util::detail;
using target_type = detail::value_traits<dummy, int>::target_type;
CHECK((std::is_same<target_type, void>::value) == true);
}

TEST_CASE( "Type indexing should work with variants with duplicated types", "[variant::detail]" ) {
// Index is in reverse order
REQUIRE((mapbox::util::detail::value_traits<bool, bool, int, double, std::string>::index == 3));
Expand Down
34 changes: 21 additions & 13 deletions variant.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -97,9 +97,13 @@ struct convertible_type<T>
template <typename T, typename... Types>
struct value_traits
{
static constexpr std::size_t direct_index = direct_type<T, Types...>::index;
static constexpr std::size_t index =
(direct_index == invalid_value) ? convertible_type<T, Types...>::index : direct_index;
using value_type = typename std::remove_reference<T>::type;
static constexpr std::size_t direct_index = direct_type<value_type, Types...>::index;
static constexpr bool is_direct = direct_index != invalid_value;
static constexpr std::size_t index = is_direct ? direct_index : convertible_type<value_type, Types...>::index;
static constexpr bool is_valid = index != invalid_value;
static constexpr std::size_t tindex = is_valid ? sizeof...(Types) - index : 0;
using target_type = typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
};

// check if T is in Types...
Expand Down Expand Up @@ -569,24 +573,24 @@ class variant
public:

VARIANT_INLINE variant()
noexcept(std::is_nothrow_default_constructible<first_type>::value)
: type_index(sizeof...(Types) - 1)
{
static_assert(std::is_default_constructible<first_type>::value, "First type in variant must be default constructible to allow default construction of variant");
new (&data) first_type();
}

VARIANT_INLINE variant(no_init)
VARIANT_INLINE variant(no_init) noexcept
: type_index(detail::invalid_value) {}

// http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers
template <typename T, class = typename std::enable_if<
detail::is_valid_type<typename std::remove_reference<T>::type, Types...>::value>::type>
VARIANT_INLINE variant(T && val) noexcept
: type_index(detail::value_traits<typename std::remove_reference<T>::type, Types...>::index)
template <typename T, typename Traits = detail::value_traits<T, Types...>,
typename Enable = typename std::enable_if<Traits::is_valid>::type>
VARIANT_INLINE variant(T && val)
noexcept(std::is_nothrow_constructible<typename Traits::target_type, T && >::value)
: type_index(Traits::index)
{
constexpr std::size_t index = sizeof...(Types) - detail::value_traits<typename std::remove_reference<T>::type, Types...>::index - 1;
using target_type = typename std::tuple_element<index, std::tuple<Types...>>::type;
new (&data) target_type(std::forward<T>(val)); // nothrow
new (&data) typename Traits::target_type(std::forward<T>(val));
}

VARIANT_INLINE variant(variant<Types...> const& old)
Expand All @@ -595,7 +599,8 @@ class variant
helper_type::copy(old.type_index, &old.data, &data);
}

VARIANT_INLINE variant(variant<Types...> && old) noexcept
VARIANT_INLINE variant(variant<Types...> && old)
noexcept(std::is_nothrow_move_constructible<std::tuple<Types...>>::value)
: type_index(old.type_index)
{
helper_type::move(old.type_index, &old.data, &data);
Expand Down Expand Up @@ -822,7 +827,10 @@ class variant
return detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, f);
}

~variant() noexcept
~variant()
#if !defined(__GNUC__) || (100 * __GNUC__ + __GNUC_MINOR__ >= 408)
noexcept(std::is_nothrow_destructible<std::tuple<Types...>>::value)
#endif
{
helper_type::destroy(type_index, &data);
}
Expand Down