From aa5fdac522c8ea6747cbad508936bbcac5d793cd Mon Sep 17 00:00:00 2001
From: Michele Caini <michele.caini@gmail.com>
Date: Fri, 18 Sep 2020 10:15:57 +0200
Subject: [PATCH] type_info: it's now copyable and moveable as it ought be

---
 src/entt/core/type_info.hpp  | 65 ++++++++++++++++++++++++++++++------
 test/entt/core/type_info.cpp | 22 ++++++++++++
 2 files changed, 77 insertions(+), 10 deletions(-)

diff --git a/src/entt/core/type_info.hpp b/src/entt/core/type_info.hpp
index f5451f14b..ed108fde2 100644
--- a/src/entt/core/type_info.hpp
+++ b/src/entt/core/type_info.hpp
@@ -133,19 +133,64 @@ class type_info final {
     template<typename>
     friend type_info type_id() ENTT_NOEXCEPT;
 
-    type_info(seq_fn *seq_func, hash_fn *hash_func, name_fn *name_func)
-        : seq{seq_func},
-          hash{hash_func},
-          name{name_func}
+    type_info(seq_fn *seq_ptr, hash_fn *hash_ptr, name_fn *name_ptr)
+        : seq_func{seq_ptr},
+          hash_func{hash_ptr},
+          name_func{name_ptr}
     {}
 
 public:
-    /*! @brief Type sequential identifier. */
-    seq_fn * const seq;
-    /*! @brief Type hash. */
-    hash_fn * const hash;
-    /*! @brief Type name. */
-    name_fn * const name;
+    /*! Default constructor. */
+    type_info()
+        : type_info{nullptr, nullptr, nullptr}
+    {}
+
+    /*! Default copy constructor. */
+    type_info(const type_info &) = default;
+    /*! Default move constructor. */
+    type_info(type_info &&) = default;
+
+    /*! Default copy assignment operator. */
+    type_info & operator=(const type_info &) = default;
+    /*! Default move assignment operator. */
+    type_info & operator=(type_info &&) = default;
+
+    /**
+    * @brief Checks if a type info object is properly initialized.
+    * @return True if the object is properly initialized, false otherwise.
+    */
+    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
+        return !(seq_func == nullptr);
+    }
+
+    /**
+     * @brief Type sequential identifier.
+     * @return Type sequential identifier.
+     */
+    [[nodiscard]] id_type seq() const ENTT_NOEXCEPT {
+        return seq_func();
+    }
+
+    /**
+     * @brief Type hash.
+     * @return Type hash.
+     */
+    [[nodiscard]] id_type hash() const ENTT_NOEXCEPT {
+        return hash_func();
+    }
+
+    /**
+    * @brief Type name.
+    * @return Type name.
+    */
+    [[nodiscard]] std::string_view name() const ENTT_NOEXCEPT {
+        return name_func();
+    }
+
+private:
+    seq_fn *seq_func;
+    hash_fn *hash_func;
+    name_fn *name_func;
 };
 
 
diff --git a/test/entt/core/type_info.cpp b/test/entt/core/type_info.cpp
index 051d55bd4..5119b8129 100644
--- a/test/entt/core/type_info.cpp
+++ b/test/entt/core/type_info.cpp
@@ -32,9 +32,13 @@ TEST(TypeName, Functionalities) {
 TEST(TypeInfo, Functionalities) {
     auto info = entt::type_id<int>();
     auto other = entt::type_id(42);
+    entt::type_info empty{};
 
+    static_assert(std::is_default_constructible_v<decltype(info)>);
     static_assert(std::is_copy_constructible_v<decltype(info)>);
     static_assert(std::is_move_constructible_v<decltype(info)>);
+    static_assert(std::is_copy_assignable_v<decltype(info)>);
+    static_assert(std::is_move_assignable_v<decltype(info)>);
 
     ASSERT_EQ(info.seq(), other.seq());
     ASSERT_EQ(info.hash(), other.hash());
@@ -43,4 +47,22 @@ TEST(TypeInfo, Functionalities) {
     ASSERT_EQ(info.seq(), entt::type_seq<int>::value());
     ASSERT_EQ(info.hash(), entt::type_hash<int>::value());
     ASSERT_EQ(info.name(), entt::type_name<int>::value());
+
+    ASSERT_FALSE(empty);
+    ASSERT_TRUE(info);
+    ASSERT_TRUE(other);
+
+    empty = info;
+
+    ASSERT_TRUE(empty);
+    ASSERT_EQ(empty.hash(), info.hash());
+
+    empty = {};
+
+    ASSERT_FALSE(empty);
+
+    empty = std::move(other);
+
+    ASSERT_TRUE(empty);
+    ASSERT_EQ(empty.hash(), other.hash());
 }
\ No newline at end of file