From 5d42a76fe574d05ff2750eb3402c1a76d251ceb1 Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Tue, 23 Jun 2020 10:55:40 +0200 Subject: [PATCH] meta: added support for convertible types to meta containers ::insert functions --- TODO | 3 +-- src/entt/meta/meta.hpp | 18 +++++++++++------- test/entt/meta/meta_container.cpp | 26 +++++++++++++++++--------- 3 files changed, 29 insertions(+), 18 deletions(-) diff --git a/TODO b/TODO index 9052790d9..e253ce559 100644 --- a/TODO +++ b/TODO @@ -26,5 +26,4 @@ Next: * WIP: - remove internal::find_if - - add const meta container support to meta any - - review _t + - add cast_or_convert to meta_any, clean up codebase diff --git a/src/entt/meta/meta.hpp b/src/entt/meta/meta.hpp index e0726a02a..0acd91bb5 100644 --- a/src/entt/meta/meta.hpp +++ b/src/entt/meta/meta.hpp @@ -1619,11 +1619,12 @@ struct meta_sequence_container::meta_sequence_container_proxy { return iterator{std::in_place_type, meta_sequence_container_traits::end(*static_cast(container))}; } - [[nodiscard]] static std::pair insert(void *container, iterator it, meta_any any) { + [[nodiscard]] static std::pair insert(void *container, iterator it, meta_any value) { + using v_type = typename meta_sequence_container_traits::value_type; std::pair::iterator, bool> ret{{}, false}; - if(const auto *value = any.try_cast::value_type>(); value) { - ret = meta_sequence_container_traits::insert(*static_cast(container), it.handle.cast::iterator>(), *value); + if(const auto *v_ptr = value.try_cast(); v_ptr || value.convert()) { + ret = meta_sequence_container_traits::insert(*static_cast(container), it.handle.cast::iterator>(), v_ptr ? *v_ptr : value.cast()); } return {iterator{std::in_place_type, std::move(ret.first)}, ret.second}; @@ -1928,14 +1929,17 @@ struct meta_associative_container::meta_associative_container_proxy { } [[nodiscard]] static bool insert(void *container, meta_any key, meta_any value) { + using k_type = typename meta_associative_container_traits::key_type; bool ret = false; - if(const auto *k_ptr = key.try_cast::key_type>(); k_ptr) { + if(const auto *k_ptr = key.try_cast(); k_ptr || key.convert()) { if constexpr(is_key_only_meta_associative_container_v) { - ret = meta_associative_container_traits::insert(*static_cast(container), *k_ptr); + ret = meta_associative_container_traits::insert(*static_cast(container), k_ptr ? *k_ptr : key.cast()); } else { - if(auto *m_ptr = value.try_cast::mapped_type>(); m_ptr) { - ret = meta_associative_container_traits::insert(*static_cast(container), *k_ptr, *m_ptr); + using m_type = typename meta_associative_container_traits::mapped_type; + + if(auto *m_ptr = value.try_cast(); m_ptr || value.convert()) { + ret = meta_associative_container_traits::insert(*static_cast(container), k_ptr ? *k_ptr : key.cast(), m_ptr ? *m_ptr : value.cast()); } } } diff --git a/test/entt/meta/meta_container.cpp b/test/entt/meta/meta_container.cpp index 9e63d5175..b6b800638 100644 --- a/test/entt/meta/meta_container.cpp +++ b/test/entt/meta/meta_container.cpp @@ -1,10 +1,18 @@ #include #include #include +#include #include #include -TEST(MetaSequenceContainer, Empty) { +struct MetaContainer: ::testing::Test { + static void SetUpTestCase() { + entt::meta().conv(); + entt::meta().conv(); + } +}; + +TEST_F(MetaContainer, EmptySequenceContainer) { entt::meta_sequence_container container{}; ASSERT_FALSE(container); @@ -15,7 +23,7 @@ TEST(MetaSequenceContainer, Empty) { ASSERT_TRUE(container); } -TEST(MetaSequenceContainer, StdVector) { +TEST_F(MetaContainer, StdVector) { std::vector vec{}; entt::meta_any any{std::ref(vec)}; @@ -54,7 +62,7 @@ TEST(MetaSequenceContainer, StdVector) { ASSERT_TRUE(ret.second); ASSERT_FALSE(view.insert(ret.first, 'c').second); - ASSERT_TRUE(view.insert(++ret.first, 1).second); + ASSERT_TRUE(view.insert(++ret.first, 1.).second); ASSERT_EQ(view.size(), 5u); ASSERT_EQ((*view.begin()).cast(), 0); @@ -71,7 +79,7 @@ TEST(MetaSequenceContainer, StdVector) { ASSERT_EQ(view.size(), 0u); } -TEST(MetaSequenceContainer, StdArray) { +TEST_F(MetaContainer, StdArray) { std::array arr{}; entt::meta_any any{std::ref(arr)}; @@ -127,7 +135,7 @@ TEST(MetaSequenceContainer, StdArray) { ASSERT_EQ(view.size(), 3u); } -TEST(MetaAssociativeContainer, Empty) { +TEST_F(MetaContainer, EmptyAssociativeContainer) { entt::meta_associative_container container{}; ASSERT_FALSE(container); @@ -138,7 +146,7 @@ TEST(MetaAssociativeContainer, Empty) { ASSERT_TRUE(container); } -TEST(MetaAssociativeContainer, StdMap) { +TEST_F(MetaContainer, StdMap) { std::map map{{2, 'c'}, {3, 'd'}, {4, 'e'}}; entt::meta_any any{std::ref(map)}; @@ -169,10 +177,10 @@ TEST(MetaAssociativeContainer, StdMap) { ASSERT_EQ((*view.find(3)).second.cast(), 'd'); ASSERT_FALSE(view.insert('a', 'a')); - ASSERT_FALSE(view.insert(1, 1)); + ASSERT_FALSE(view.insert(1, 1.)); ASSERT_TRUE(view.insert(0, 'a')); - ASSERT_TRUE(view.insert(1, 'b')); + ASSERT_TRUE(view.insert(1., static_cast('b'))); ASSERT_EQ(view.size(), 5u); ASSERT_EQ((*view.find(0)).second.cast(), 'a'); @@ -190,7 +198,7 @@ TEST(MetaAssociativeContainer, StdMap) { ASSERT_EQ(view.size(), 0u); } -TEST(MetaAssociativeContainer, StdSet) { +TEST_F(MetaContainer, StdSet) { std::set set{2, 3, 4}; entt::meta_any any{std::ref(set)};