From cccd1baa2fe889e7697e207c0838c06dbc0dad37 Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Fri, 26 Jun 2020 15:42:47 +0200 Subject: [PATCH] meta: minor changes --- src/entt/meta/container.hpp | 4 +- src/entt/meta/meta.hpp | 150 ++++++++++++++++-------------------- 2 files changed, 67 insertions(+), 87 deletions(-) diff --git a/src/entt/meta/container.hpp b/src/entt/meta/container.hpp index 37ff50cc3..0d9993568 100644 --- a/src/entt/meta/container.hpp +++ b/src/entt/meta/container.hpp @@ -45,7 +45,7 @@ struct meta_sequence_container_traits> { * @param sz The new size of the container. * @return True in case of success, false otherwise. */ - [[nodiscard]] static bool resize(std::vector &vec, size_type sz) ENTT_NOEXCEPT { + [[nodiscard]] static bool resize(std::vector &vec, size_type sz) { return (vec.resize(sz), true); } @@ -140,7 +140,7 @@ struct meta_sequence_container_traits> { * @brief Does nothing. * @return False to indicate failure in all cases. */ - [[nodiscard]] static bool resize(const std::array &, size_type) ENTT_NOEXCEPT { + [[nodiscard]] static bool resize(const std::array &, size_type) { return false; } diff --git a/src/entt/meta/meta.hpp b/src/entt/meta/meta.hpp index a4ef8e452..7444768ac 100644 --- a/src/entt/meta/meta.hpp +++ b/src/entt/meta/meta.hpp @@ -38,7 +38,9 @@ public: using iterator = meta_iterator; /*! @brief Default constructor. */ - meta_sequence_container() = default; + meta_sequence_container() ENTT_NOEXCEPT + : instance{nullptr} + {} /** * @brief Construct a proxy object for sequence containers. @@ -46,7 +48,7 @@ public: * @param container The container to wrap. */ template - meta_sequence_container(Type *container) + meta_sequence_container(Type *container) ENTT_NOEXCEPT : value_type_fn{&meta_sequence_container_proxy::value_type}, size_fn{&meta_sequence_container_proxy::size}, resize_fn{&meta_sequence_container_proxy::resize}, @@ -61,7 +63,7 @@ public: [[nodiscard]] inline meta_type value_type() const ENTT_NOEXCEPT; [[nodiscard]] inline size_type size() const ENTT_NOEXCEPT; - inline bool resize(size_type) const ENTT_NOEXCEPT; + inline bool resize(size_type) const; inline bool clear(); [[nodiscard]] inline iterator begin(); [[nodiscard]] inline iterator end(); @@ -72,8 +74,8 @@ public: [[nodiscard]] inline explicit operator bool() const ENTT_NOEXCEPT; private: - meta_type(* value_type_fn)(); - size_type(* size_fn)(const void *); + meta_type(* value_type_fn)() ENTT_NOEXCEPT; + size_type(* size_fn)(const void *) ENTT_NOEXCEPT; bool(* resize_fn)(void *, size_type); bool(* clear_fn)(void *); iterator(* begin_fn)(void *); @@ -99,7 +101,9 @@ public: using iterator = meta_iterator; /*! @brief Default constructor. */ - meta_associative_container() = default; + meta_associative_container() ENTT_NOEXCEPT + : instance{nullptr} + {} /** * @brief Construct a proxy object for associative containers. @@ -107,7 +111,7 @@ public: * @param container The container to wrap. */ template - meta_associative_container(Type *container) + meta_associative_container(Type *container) ENTT_NOEXCEPT : key_only_container{is_key_only_meta_associative_container_v}, key_type_fn{&meta_associative_container_proxy::key_type}, mapped_type_fn{&meta_associative_container_proxy::mapped_type}, @@ -138,10 +142,10 @@ public: private: bool key_only_container; - meta_type(* key_type_fn)(); - meta_type(* mapped_type_fn)(); - meta_type(* value_type_fn)(); - size_type(* size_fn)(const void *); + meta_type(* key_type_fn)() ENTT_NOEXCEPT; + meta_type(* mapped_type_fn)() ENTT_NOEXCEPT; + meta_type(* value_type_fn)() ENTT_NOEXCEPT; + size_type(* size_fn)(const void *) ENTT_NOEXCEPT; bool(* clear_fn)(void *); iterator(* begin_fn)(void *); iterator(* end_fn)(void *); @@ -300,17 +304,15 @@ public: */ template [[nodiscard]] const Type * try_cast() const { - const void *ret = nullptr; - if(node) { if(const auto type_id = internal::meta_info::resolve()->type_id; node->type_id == type_id) { - ret = storage.data(); + return static_cast(storage.data()); } else if(const auto *base = internal::find_if<&internal::meta_type_node::base>([type_id](const auto *curr) { return curr->type()->type_id == type_id; }, node); base) { - ret = base->cast(storage.data()); + return static_cast(base->cast(storage.data())); } } - return static_cast(ret); + return nullptr; } /*! @copydoc try_cast */ @@ -354,17 +356,15 @@ public: */ template [[nodiscard]] meta_any convert() const { - meta_any any{}; - if(node) { if(const auto type_id = internal::meta_info::resolve()->type_id; node->type_id == type_id) { - any = *this; + return *this; } else if(const auto * const conv = internal::find_if<&internal::meta_type_node::conv>([type_id](const auto *curr) { return curr->type()->type_id == type_id; }, node); conv) { - any = conv->conv(storage.data()); + return conv->conv(storage.data()); } } - return any; + return {}; } /** @@ -496,9 +496,7 @@ private: */ struct meta_handle { /*! @brief Default constructor. */ - meta_handle() - : any{} - {} + meta_handle() = default; /** * @brief Creates a handle that points to an unmanaged object. @@ -1425,11 +1423,7 @@ public: using iterator_category = std::input_iterator_tag; /*! @brief Default constructor. */ - meta_iterator() ENTT_NOEXCEPT - : next_fn{nullptr}, - get_fn{nullptr}, - handle{} - {} + meta_iterator() ENTT_NOEXCEPT = default; /** * @brief Constructs a meta iterator from a given iterator. @@ -1499,48 +1493,48 @@ private: template struct meta_sequence_container::meta_sequence_container_proxy { - [[nodiscard]] static meta_type value_type() { - return internal::meta_info::value_type>::resolve(); + using traits_type = meta_sequence_container_traits; + + [[nodiscard]] static meta_type value_type() ENTT_NOEXCEPT { + return internal::meta_info::resolve(); } - [[nodiscard]] static size_type size(const void *container) { - return meta_sequence_container_traits::size(*static_cast(container)); + [[nodiscard]] static size_type size(const void *container) ENTT_NOEXCEPT { + return traits_type::size(*static_cast(container)); } [[nodiscard]] static bool resize(void *container, size_type sz) { - return meta_sequence_container_traits::resize(*static_cast(container), sz); + return traits_type::resize(*static_cast(container), sz); } [[nodiscard]] static bool clear(void *container) { - return meta_sequence_container_traits::clear(*static_cast(container)); + return traits_type::clear(*static_cast(container)); } [[nodiscard]] static iterator begin(void *container) { - return iterator{std::in_place_type, meta_sequence_container_traits::begin(*static_cast(container))}; + return iterator{std::in_place_type, traits_type::begin(*static_cast(container))}; } [[nodiscard]] static iterator end(void *container) { - return iterator{std::in_place_type, meta_sequence_container_traits::end(*static_cast(container))}; + return iterator{std::in_place_type, traits_type::end(*static_cast(container))}; } [[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 *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()); + if(const auto *v_ptr = value.try_cast(); v_ptr || value.convert()) { + auto ret = traits_type::insert(*static_cast(container), it.handle.cast(), v_ptr ? *v_ptr : value.cast()); + return {iterator{std::in_place_type, std::move(ret.first)}, ret.second}; } - return {iterator{std::in_place_type, std::move(ret.first)}, ret.second}; + return {}; } [[nodiscard]] static std::pair erase(void *container, iterator it) { - auto ret = meta_sequence_container_traits::erase(*static_cast(container), it.handle.cast::iterator>()); + auto ret = traits_type::erase(*static_cast(container), it.handle.cast()); return {iterator{std::in_place_type, std::move(ret.first)}, ret.second}; } [[nodiscard]] static meta_any get(void *container, size_type pos) { - return std::ref(meta_sequence_container_traits::get(*static_cast(container), pos)); + return std::ref(traits_type::get(*static_cast(container), pos)); } }; @@ -1568,7 +1562,7 @@ struct meta_sequence_container::meta_sequence_container_proxy { * @param sz The new size of the container. * @return True in case of success, false otherwise. */ -inline bool meta_sequence_container::resize(size_type sz) const ENTT_NOEXCEPT { +inline bool meta_sequence_container::resize(size_type sz) const { return resize_fn(instance, sz); } @@ -1688,12 +1682,7 @@ public: using iterator_category = std::input_iterator_tag; /*! @brief Default constructor. */ - meta_iterator() ENTT_NOEXCEPT - : next_fn{nullptr}, - key_fn{nullptr}, - value_fn{nullptr}, - handle{} - {} + meta_iterator() ENTT_NOEXCEPT = default; /** * @brief Constructs a meta iterator from a given iterator. @@ -1765,77 +1754,68 @@ private: template struct meta_associative_container::meta_associative_container_proxy { - [[nodiscard]] static meta_type key_type() { - return internal::meta_info::key_type>::resolve(); + using traits_type = meta_associative_container_traits; + + [[nodiscard]] static meta_type key_type() ENTT_NOEXCEPT { + return internal::meta_info::resolve(); } - [[nodiscard]] static meta_type mapped_type() { + [[nodiscard]] static meta_type mapped_type() ENTT_NOEXCEPT { if constexpr(is_key_only_meta_associative_container_v) { return meta_type{}; } else { - return internal::meta_info::mapped_type>::resolve(); + return internal::meta_info::resolve(); } } - [[nodiscard]] static meta_type value_type() { - return internal::meta_info::value_type>::resolve(); + [[nodiscard]] static meta_type value_type() ENTT_NOEXCEPT { + return internal::meta_info::resolve(); } - [[nodiscard]] static size_type size(const void *container) { - return meta_associative_container_traits::size(*static_cast(container)); + [[nodiscard]] static size_type size(const void *container) ENTT_NOEXCEPT { + return traits_type::size(*static_cast(container)); } [[nodiscard]] static bool clear(void *container) { - return meta_associative_container_traits::clear(*static_cast(container)); + return traits_type::clear(*static_cast(container)); } [[nodiscard]] static iterator begin(void *container) { - return iterator{std::in_place_type, meta_associative_container_traits::begin(*static_cast(container))}; + return iterator{std::in_place_type, traits_type::begin(*static_cast(container))}; } [[nodiscard]] static iterator end(void *container) { - return iterator{std::in_place_type, meta_associative_container_traits::end(*static_cast(container))}; + return iterator{std::in_place_type, traits_type::end(*static_cast(container))}; } [[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(); k_ptr || key.convert()) { + 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 ? *k_ptr : key.cast()); + return traits_type::insert(*static_cast(container), k_ptr ? *k_ptr : key.cast()); } else { - 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()); + if(auto *m_ptr = value.try_cast(); m_ptr || value.convert()) { + return traits_type::insert(*static_cast(container), k_ptr ? *k_ptr : key.cast(), m_ptr ? *m_ptr : value.cast()); } } } - return ret; + return false; } [[nodiscard]] static bool erase(void *container, meta_any key) { - 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 || key.convert()) { - ret = meta_associative_container_traits::erase(*static_cast(container), k_ptr ? *k_ptr : key.cast()); + if(const auto *k_ptr = key.try_cast(); k_ptr || key.convert()) { + return traits_type::erase(*static_cast(container), k_ptr ? *k_ptr : key.cast()); } - return ret; + return false; } [[nodiscard]] static iterator find(void *container, meta_any key) { - using k_type = typename meta_associative_container_traits::key_type; - iterator ret{}; - - if(const auto *k_ptr = key.try_cast::key_type>(); k_ptr || key.convert()) { - ret = iterator{std::in_place_type, meta_associative_container_traits::find(*static_cast(container), k_ptr ? *k_ptr : key.cast())}; + if(const auto *k_ptr = key.try_cast(); k_ptr || key.convert()) { + return iterator{std::in_place_type, traits_type::find(*static_cast(container), k_ptr ? *k_ptr : key.cast())}; } - return ret; + return {}; } };