coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-11-09 14:49:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Interim commit

Browse Source
This commit is contained in:
John Wellbelove 2021-05-22 20:28:40 +01:00
parent c3bef2c493
commit 92515111d9
2 changed files with 121 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
include/etl/private/variant_new.h
View File

@ -58,7 +58,15 @@ namespace etl
{
static_assert(ETL_CPP11_SUPPORTED, "Only supported for C++11 or above");
static size_t variant_npos = etl::integral_limits<size_t>::max;
constexpr size_t variant_npos = etl::integral_limits<size_t>::max;
//***************************************************************************
/// Monostate for variants.
///\ingroup variant
//***************************************************************************
struct monostate
{
};
//***************************************************************************
/// Base exception for the variant class.
@ -193,11 +201,13 @@ namespace etl
template <typename T, typename... TArgs>
T& emplace(TArgs&&... args)
{
static_assert(etl::is_one_of<T, TTypes>::value, "Unsupported type");
static_assert(etl::is_one_of<T, TTypes...>::value, "Unsupported type");
T temp(etl::forward<TArgs>(args)...);
operation(action_type::Destruct, data, nullptr);
operation = do_operation<T>;
operation(action_type::Construct, data, &temp);
type_id = etl::parameter_pack<TTypes...>::index_of_type<T>::value;
@ -292,7 +302,7 @@ namespace etl
template <typename T>
const T& get() const
{
static_assert(etl::is_one_of<T, TTypes>::value, "Unsupported type");
static_assert(etl::is_one_of<T, TTypes...>::value, "Unsupported type");
ETL_ASSERT(is_type<T>(), ETL_ERROR(variant_incorrect_type_exception));
return static_cast<const T&>(data);
@ -475,6 +485,56 @@ namespace etl
return get<Index>(v);
}
//***************************************************************************
/// get_if
//***************************************************************************
template < size_t Index, class... Types >
constexpr etl::add_pointer_t<etl::variant_alternative_t<Index, etl::variant<Types...>>>
get_if(etl::variant<Types...>* pv) noexcept
{
if ((pv != nullptr) && (pv->index() == Index))
{
return &etl::get<Index>(*pv);
}
else
{
return nullptr;
}
}
//***********************************
template< size_t Index, class... Types >
constexpr etl::add_pointer_t<const etl::variant_alternative_t<Index, etl::variant<Types...>>>
get_if(const etl::variant<Types...>* pv) noexcept
{
if ((pv != nullptr) && (pv->index() == Index))
{
return &etl::get<Index>(*pv);
}
else
{
return nullptr;
}
}
//***********************************
template< class T, class... Types >
constexpr etl::add_pointer_t<T> get_if(etl::variant<Types...>* pv) noexcept
{
constexpr size_t Index = etl::parameter_pack<TTypes...>::index_of_type<T>::value;
return etl::get_if<Index>(pv);
}
//***********************************
template< class T, class... Types >
constexpr etl::add_pointer_t<const T> get_if(const etl::variant<Types...>* pv) noexcept
{
constexpr size_t Index = etl::parameter_pack<TTypes...>::index_of_type<T>::value;
return etl::get_if<Index>(pv);
}
//***************************************************************************
/// swap
//***************************************************************************
@ -483,4 +543,23 @@ namespace etl
{
lhs.swap(rhs);
}
//***************************************************************************
/// variant_size
//***************************************************************************
template <typename T>
struct variant_size;
template <typename... TTypes>
struct variant_size<etl::variant<TTypes...>>
: etl::integral_constant<size_t, sizeof...(TTypes)>
{
};
template <typename T>
struct variant_size<const T>
: etl::integral_constant<size_t, variant_size<T>::value>
{
};
}

136
test/test_variant_new.cpp
View File

@ -307,6 +307,28 @@ namespace
CHECK_EQUAL(text, variant_2.get<std::string>());
}
//*************************************************************************
TEST(test_assignment_incorrect_type_exception)
{
std::string text("Some Text");
test_variant_3a variant(text);
int i;
CHECK_THROW(etl::get<int>(variant), etl::variant_incorrect_type_exception);
(void)i;
}
//*************************************************************************
TEST(test_self_assignment)
{
test_variant_3a variant;
variant = 1;
variant = variant;
CHECK_EQUAL(1, etl::get<int>(variant));
}
//*************************************************************************
TEST(test_member_swap_variants)
{
@ -342,105 +364,25 @@ namespace
}
//*************************************************************************
TEST(test_assignment_incorrect_type_exception)
TEST(test_emplace)
{
std::string text("Some Text");
test_variant_3a variant(text);
test_variant_emplace variant;
int i;
CHECK_THROW(etl::get<int>(variant), etl::variant_incorrect_type_exception);
(void)i;
variant.emplace<D1>("1");
CHECK(etl::holds_alternative<D1>(variant));
CHECK_EQUAL(D1("1"), etl::get<D1>(variant));
variant.emplace<D2>("1", "2");
CHECK(etl::holds_alternative<D2>(variant));
CHECK_EQUAL(D2("1", "2"), etl::get<D2>(variant));
variant.emplace<D3>("1", "2", "3");
CHECK(etl::holds_alternative<D3>(variant));
CHECK_EQUAL(D3("1", "2", "3"), etl::get<D3>(variant));
variant.emplace<D4>("1", "2", "3", "4");
CHECK(etl::holds_alternative<D4>(variant));
CHECK_EQUAL(D4("1", "2", "3", "4"), etl::get<D4>(variant));
}
////*************************************************************************
//TEST(test_get)
//{
// test_variant_3a variant;
// variant = 1;
// CHECK_EQUAL(1, variant.get<int>());
// variant = 'a';
// CHECK_EQUAL('a', variant.get<char>());
// variant = std::string("Some Text");
// CHECK_EQUAL(std::string("Some Text"), variant.get<std::string>());
//}
////*************************************************************************
//TEST(test_get_const)
//{
// test_variant_3a variant;
// variant = 1;
// const test_variant_3a cvariant1(variant);
// CHECK_EQUAL(1, cvariant1.get<int>());
// variant = 'a';
// const test_variant_3a cvariant2(variant);
// CHECK_EQUAL('a', cvariant2.get<char>());
// variant = std::string("Some Text");
// const test_variant_3a cvariant3(variant);
// CHECK_EQUAL(std::string("Some Text"), cvariant3.get<std::string>());
//}
////*************************************************************************
//TEST(test_self_assignment)
//{
// test_variant_3a variant;
// variant = 1;
// variant = variant;
// CHECK_EQUAL(1, variant.get<int>());
//}
////*************************************************************************
//TEST(TestGetException)
//{
// test_variant_3a variant;
// variant = 1;
// char c;
// CHECK_THROW(c = variant.get<char>(), etl::variant_incorrect_type_exception);
// (void)c;
//}
////*************************************************************************
//TEST(TestPolymorphic)
//{
// test_variant_polymorphic variant;
// variant = derived_1();
// variant.upcast<base>().set();
// CHECK_EQUAL(1, variant.get<derived_1>().value);
// variant = derived_2();
// variant.upcast<base>().set();
// CHECK_EQUAL(2, variant.get<derived_2>().value);
//}
////*************************************************************************
//TEST(TestEmplace)
//{
// test_variant_emplace variant;
// variant.emplace<D1>("1");
// CHECK(variant.is_type<D1>());
// CHECK_EQUAL(D1("1"), variant.get<D1>());
// variant.emplace<D2>("1", "2");
// CHECK(variant.is_type<D2>());
// CHECK_EQUAL(D2("1", "2"), variant.get<D2>());
// variant.emplace<D3>("1", "2", "3");
// CHECK(variant.is_type<D3>());
// CHECK_EQUAL(D3("1", "2", "3"), variant.get<D3>());
// variant.emplace<D4>("1", "2", "3", "4");
// CHECK(variant.is_type<D4>());
// CHECK_EQUAL(D4("1", "2", "3", "4"), variant.get<D4>());
//}
};
}