coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Adjustments in tuple.h from review (#1350)

Browse Source 
* Print test names at test time (#1343)

* Adjustments in tuple.h from review

---------

Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>
This commit is contained in:
Roland Reichwein 2026-03-25 20:28:12 +01:00 committed by GitHub
parent e7107b24f1
commit 7fdea7f7ae
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 136 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
include/etl/tuple.h
View File

@ -276,7 +276,7 @@ namespace etl
/// Implicit conversion
//*********************************
template <typename UHead, typename... UTail, etl::enable_if_t<(number_of_types<THead, TTail...>() == number_of_types<UHead, UTail...>()) &&
(number_of_types<THead, TTail...>() >= 1U) &&
(number_of_types<THead, TTail...>() >= 1U) &&
etl::is_convertible<UHead, THead>::value, int> = 0>
ETL_CONSTEXPR14
tuple(tuple<UHead, UTail...>& other)
@ -290,7 +290,7 @@ namespace etl
/// Explicit conversion
//*********************************
template <typename UHead, typename... UTail, etl::enable_if_t<(number_of_types<THead, TTail...>() == number_of_types<UHead, UTail...>()) &&
(number_of_types<THead, TTail...>() >= 1U) &&
(number_of_types<THead, TTail...>() >= 1U) &&
!etl::is_convertible<UHead, THead>::value, int> = 0>
ETL_CONSTEXPR14
explicit tuple(tuple<UHead, UTail...>& other)
@ -304,7 +304,7 @@ namespace etl
/// Implicit conversion
//*********************************
template <typename UHead, typename... UTail, etl::enable_if_t<(number_of_types<THead, TTail...>() == number_of_types<UHead, UTail...>()) &&
(number_of_types<THead, TTail...>() >= 1U) &&
(number_of_types<THead, TTail...>() >= 1U) &&
etl::is_convertible<UHead, THead>::value, int> = 0>
ETL_CONSTEXPR14
tuple(const tuple<UHead, UTail...>& other)
@ -318,7 +318,7 @@ namespace etl
/// Explicit conversion
//*********************************
template <typename UHead, typename... UTail, etl::enable_if_t<(number_of_types<THead, TTail...>() == number_of_types<UHead, UTail...>()) &&
(number_of_types<THead, TTail...>() >= 1U) &&
(number_of_types<THead, TTail...>() >= 1U) &&
!etl::is_convertible<UHead, THead>::value, int> = 0>
ETL_CONSTEXPR14
explicit tuple(const tuple<UHead, UTail...>& other)
@ -332,7 +332,7 @@ namespace etl
/// Implicit conversion
//*********************************
template <typename UHead, typename... UTail, etl::enable_if_t<(number_of_types<THead, TTail...>() == number_of_types<UHead, UTail...>()) &&
(number_of_types<THead, TTail...>() >= 1U) &&
(number_of_types<THead, TTail...>() >= 1U) &&
etl::is_convertible<UHead, THead>::value, int> = 0>
ETL_CONSTEXPR14
tuple(tuple<UHead, UTail...>&& other)
@ -399,7 +399,7 @@ namespace etl
//*********************************
template <typename UHead, typename... UTail, etl::enable_if_t<!is_tuple<etl::remove_reference_t<UHead>>::value &&
(number_of_types<THead, TTail...>() == number_of_types<UHead, UTail...>()) &&
(number_of_types<THead, TTail...>() >= 1U) &&
(number_of_types<THead, TTail...>() >= 1U) &&
etl::is_convertible<UHead, THead>::value, int> = 0>
ETL_CONSTEXPR14
tuple(UHead&& head, UTail&&... tail) ETL_NOEXCEPT
@ -428,8 +428,8 @@ namespace etl
/// Implicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
etl ::is_convertible<U1, THead>::value &&
etl ::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
etl::is_convertible<U1, THead>::value &&
etl::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
ETL_CONSTEXPR14
tuple(ETL_OR_STD::pair<U1, U2>& p) ETL_NOEXCEPT
: base_type(p.second)
@ -442,8 +442,8 @@ namespace etl
/// Explicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
(!etl ::is_convertible<U1, THead>::value ||
!etl ::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
(!etl::is_convertible<U1, THead>::value ||
!etl::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
ETL_CONSTEXPR14
explicit tuple(ETL_OR_STD::pair<U1, U2>& p) ETL_NOEXCEPT
: base_type(p.second)
@ -456,8 +456,8 @@ namespace etl
/// Implicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
etl ::is_convertible<U1, THead>::value &&
etl ::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
etl::is_convertible<U1, THead>::value &&
etl::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
ETL_CONSTEXPR14
tuple(const ETL_OR_STD::pair<U1, U2>& p) ETL_NOEXCEPT
: base_type(p.second)
@ -470,8 +470,8 @@ namespace etl
/// Explicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
(!etl ::is_convertible<U1, THead>::value ||
!etl ::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
(!etl::is_convertible<U1, THead>::value ||
!etl::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
ETL_CONSTEXPR14
explicit tuple(const ETL_OR_STD::pair<U1, U2>& p) ETL_NOEXCEPT
: base_type(p.second)
@ -484,8 +484,8 @@ namespace etl
/// Implicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
etl ::is_convertible<U1, THead>::value &&
etl ::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
etl::is_convertible<U1, THead>::value &&
etl::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
ETL_CONSTEXPR14
tuple(ETL_OR_STD::pair<U1, U2>&& p) ETL_NOEXCEPT
: base_type(etl::forward<U2>(p.second))
@ -498,8 +498,8 @@ namespace etl
/// Explicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
(!etl ::is_convertible<U1, THead>::value ||
!etl ::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
(!etl::is_convertible<U1, THead>::value ||
!etl::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
ETL_CONSTEXPR14
explicit tuple(ETL_OR_STD::pair<U1, U2>&& p) ETL_NOEXCEPT
: base_type(etl::forward<U2>(p.second))
@ -512,12 +512,12 @@ namespace etl
/// Implicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
etl ::is_convertible<U1, THead>::value &&
etl ::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
etl::is_convertible<U1, THead>::value &&
etl::is_convertible<U2, typename base_type::value_type>::value, int> = 0>
ETL_CONSTEXPR14
tuple(const ETL_OR_STD::pair<U1, U2>&& p) ETL_NOEXCEPT
: base_type(etl::forward<U2>(p.second))
, value(etl::forward<U1>(p.first))
: base_type(etl::forward<const U2>(p.second))
, value(etl::forward<const U1>(p.first))
{
}
@ -526,12 +526,12 @@ namespace etl
/// Explicit conversion.
//*********************************
template <typename U1, typename U2, etl::enable_if_t<number_of_types<THead, TTail...>() == 2U &&
(!etl ::is_convertible<U1, THead>::value ||
!etl ::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
(!etl::is_convertible<U1, THead>::value ||
!etl::is_convertible<U2, typename base_type::value_type>::value), int> = 0>
ETL_CONSTEXPR14
explicit tuple(const ETL_OR_STD::pair<U1, U2>&& p) ETL_NOEXCEPT
: base_type(p.second)
, value(p.first)
: base_type(etl::forward<const U2>(p.second))
, value(etl::forward<const U1>(p.first))
{
}
@ -605,8 +605,8 @@ namespace etl
ETL_CONSTEXPR14
tuple& operator =(const ETL_OR_STD::pair<U1, U2>&& p)
{
get_value() = p.first;
get_base().get_value() = p.second;
get_value() = etl::forward<const U1>(p.first);
get_base().get_value() = etl::forward<const U2>(p.second);
return *this;
}
@ -763,7 +763,7 @@ namespace etl
//***************************************************************************
/// Extracts the element at Index from the tuple.
/// Index must be an integer value in sizeof...(TTypes)).
/// Index must be an integer value in [0, sizeof...(TTypes)).
/// Returns a reference.
//***************************************************************************
template <size_t Index, typename... TTypes>
@ -782,7 +782,7 @@ namespace etl
//***************************************************************************
/// Extracts the element at Index from the tuple.
/// Index must be an integer value in [?0?, sizeof...(TTypes)).
/// Index must be an integer value in [0, sizeof...(TTypes)).
/// Returns a const reference.
//***************************************************************************
template <size_t Index, typename... TTypes>
@ -801,7 +801,7 @@ namespace etl
//***************************************************************************
/// Extracts the element at Index from the tuple.
/// Index must be an integer value in [?0?, sizeof...(TTypes)).
/// Index must be an integer value in [0, sizeof...(TTypes)).
/// Returns an rvalue reference.
//***************************************************************************
template <size_t Index, typename... TTypes>
@ -820,7 +820,7 @@ namespace etl
//***************************************************************************
/// Extracts the element at Index from the tuple.
/// Index must be an integer value in [?0?, sizeof...(TTypes)).
/// Index must be an integer value in [0, sizeof...(TTypes)).
/// Returns a const rvalue reference.
//***************************************************************************
template <size_t Index, typename... TTypes>
@ -1017,17 +1017,17 @@ namespace etl
ETL_NODISCARD
ETL_CONSTEXPR14
auto tuple_cat(Tuple1&& t1, Tuple2&& t2, Tuples&&... ts)
-> decltype(private_tuple::tuple_cat_impl(etl::forward<Tuple1>(t1),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple1>>::value>{},
etl::forward<Tuple2>(t2),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple2>>::value>{}))
-> decltype(tuple_cat(private_tuple::tuple_cat_impl(etl::forward<Tuple1>(t1),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple1>>::value>{},
etl::forward<Tuple2>(t2),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple2>>::value>{}),
etl::forward<Tuples>(ts)...))
{
auto concatenated = private_tuple::tuple_cat_impl(etl::forward<Tuple1>(t1),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple1>>::value>{},
etl::forward<Tuple2>(t2),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple2>>::value>{});
return tuple_cat(etl::move(concatenated), etl::forward<Tuples>(ts)...);
return tuple_cat(private_tuple::tuple_cat_impl(etl::forward<Tuple1>(t1),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple1>>::value>{},
etl::forward<Tuple2>(t2),
etl::make_index_sequence<etl::tuple_size<etl::decay_t<Tuple2>>::value>{}),
etl::forward<Tuples>(ts)...);
}
#if ETL_USING_STL
@ -1317,7 +1317,7 @@ namespace std
template <size_t Index, typename... Types>
struct tuple_element<Index, etl::tuple<Types...>>
{
using type = typename etl::nth_type_t<Index, Types...>;
using type = etl::nth_type_t<Index, Types...>;
};
}

95
test/test_tuple.cpp
View File

@ -35,6 +35,7 @@ SOFTWARE.
#include <string>
#include <array>
#include <type_traits>
namespace
{
@ -486,6 +487,56 @@ namespace
CHECK_EQUAL(std::string("2"), d.value);
}
//*************************************************************************
TEST(test_construct_from_rvalue_pair_implicit_conversion)
{
ETL_OR_STD::pair<int, Data> p(1, Data("2"));
etl::tuple<int, Data> tp(etl::move(p));
int i = etl::get<0>(tp);
Data d = etl::get<1>(tp);
CHECK_EQUAL(1, i);
CHECK_EQUAL(std::string("2"), d.value);
}
//*************************************************************************
TEST(test_construct_from_rvalue_pair_explicit_conversion)
{
ETL_OR_STD::pair<From, From> p(From(1), From(2));
etl::tuple<To, To> tp(etl::move(p));
CHECK_EQUAL(1, etl::get<0>(tp).i);
CHECK_EQUAL(2, etl::get<1>(tp).i);
}
//*************************************************************************
TEST(test_construct_from_const_rvalue_pair_implicit_conversion)
{
const ETL_OR_STD::pair<int, Data> p(1, Data("2"));
etl::tuple<int, Data> tp(etl::move(p));
int i = etl::get<0>(tp);
Data d = etl::get<1>(tp);
CHECK_EQUAL(1, i);
CHECK_EQUAL(std::string("2"), d.value);
}
//*************************************************************************
TEST(test_construct_from_const_rvalue_pair_explicit_conversion)
{
const ETL_OR_STD::pair<From, From> p(From(1), From(2));
etl::tuple<To, To> tp(etl::move(p));
CHECK_EQUAL(1, etl::get<0>(tp).i);
CHECK_EQUAL(2, etl::get<1>(tp).i);
}
//*************************************************************************
ETL_NODISCARD bool Get()
{
@ -553,7 +604,7 @@ namespace
}
//*************************************************************************
TEST(test_tuple_cat)
TEST(test_tuple_cat_2)
{
etl::tuple<int, double> tp1{1, 2.3};
etl::tuple<int, Data> tp2{4, Data("Data", 5)};
@ -566,6 +617,46 @@ namespace
CHECK_EQUAL(etl::get<3>(tp3), etl::get<1>(tp2));
}
//*************************************************************************
TEST(test_tuple_cat_3)
{
etl::tuple<int, double> tp1{1, 2.3};
etl::tuple<int, Data> tp2{4, Data("Data", 5)};
etl::tuple<bool, int> tp3{true, 5};
auto tp4 = etl::tuple_cat(tp1, tp2, tp3);
static_assert(std::is_same<decltype(tp4), etl::tuple<int, double, int, Data, bool, int>>::value, "tp4 type mismatch");
CHECK_EQUAL(etl::get<0>(tp4), etl::get<0>(tp1));
CHECK_EQUAL(etl::get<1>(tp4), etl::get<1>(tp1));
CHECK_EQUAL(etl::get<2>(tp4), etl::get<0>(tp2));
CHECK_EQUAL(etl::get<3>(tp4), etl::get<1>(tp2));
CHECK_EQUAL(etl::get<4>(tp4), etl::get<0>(tp3));
CHECK_EQUAL(etl::get<5>(tp4), etl::get<1>(tp3));
}
//*************************************************************************
TEST(test_tuple_cat_4)
{
etl::tuple<int, double> tp1{1, 2.3};
etl::tuple<int, Data> tp2{4, Data("Data", 5)};
etl::tuple<bool, int> tp3{true, 5};
etl::tuple<double, int, bool> tp4{1.01, 6, false};
auto tp5 = etl::tuple_cat(tp1, tp2, tp3, tp4);
static_assert(std::is_same<decltype(tp5), etl::tuple<int, double, int, Data, bool, int, double, int, bool>>::value, "tp5 type mismatch");
CHECK_EQUAL(etl::get<0>(tp5), etl::get<0>(tp1));
CHECK_EQUAL(etl::get<1>(tp5), etl::get<1>(tp1));
CHECK_EQUAL(etl::get<2>(tp5), etl::get<0>(tp2));
CHECK_EQUAL(etl::get<3>(tp5), etl::get<1>(tp2));
CHECK_EQUAL(etl::get<4>(tp5), etl::get<0>(tp3));
CHECK_EQUAL(etl::get<5>(tp5), etl::get<1>(tp3));
CHECK_EQUAL(etl::get<6>(tp5), etl::get<0>(tp4));
CHECK_EQUAL(etl::get<7>(tp5), etl::get<1>(tp4));
CHECK_EQUAL(etl::get<8>(tp5), etl::get<2>(tp4));
}
//*************************************************************************
TEST(test_forward_as_tuple)
{
@ -831,7 +922,7 @@ namespace
etl::tuple<int, Data> tp(0, Data(""));
tp = static_cast<const ETL_OR_STD::pair<int, Data>&&>(p);
tp = etl::move(p);
int i = etl::get<0>(tp);
Data d = etl::get<1>(tp);