refactor: replace string-based registry lookup with std::type_index (#360)

Use std::type_index(typeid(T)) to key registries instead of raw strings.
Remove ENDSTONE_REGISTRY_TYPE macro and T::RegistryType from all types.
Add type-erased virtuals to IRegistry (get0, forEach0, getTypeId) so
Python bindings use a single opaque Registry class via IRegistry directly,
extracting std::type_info from py::type to call Server::_getRegistry.

Author: wu-vincent

endstone/__init__.pyi

@@ -797,3 +797,4 @@ class Registry(typing.Generic[_T]):
     def __getitem__(self, key: str) -> _T: ...
     def __iter__(self) -> list: ...
     def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...

include/endstone/actor/actor_type.h

@@ -168,7 +168,5 @@ class ActorType : public Registry<ActorType>::Type {
     static constexpr auto WitherSkullDangerous = ActorTypeId::minecraft("wither_skull_dangerous");
     static constexpr auto XpBottle = ActorTypeId::minecraft("xp_bottle");
     static constexpr auto XpOrb = ActorTypeId::minecraft("xp_orb");
-
-    ENDSTONE_REGISTRY_TYPE(ActorType)
-};
+``};
 }  // namespace endstone

include/endstone/block/block_type.h

@@ -31,8 +31,6 @@ class BlockType : public Registry<BlockType>::Type {
 public:
     static constexpr auto Air = BlockTypeId::minecraft("air");
 
-    ENDSTONE_REGISTRY_TYPE(BlockType)
-
     /**
      * @brief Returns true if this BlockType has a corresponding ItemType.
      *

include/endstone/enchantments/enchantment.h

@@ -21,7 +21,6 @@ class ItemStack;
 using EnchantmentId = Identifier<class Enchantment>;
 class Enchantment : public Registry<Enchantment>::Type {
 public:
-    ENDSTONE_REGISTRY_TYPE(Enchantment)
     /**
      * @brief Provides protection against environmental damage
      */

include/endstone/inventory/item_type.h

@@ -26,8 +26,6 @@ class ItemType : public Registry<ItemType>::Type {
 public:
     static constexpr auto Air = ItemTypeId::minecraft("air");
 
-    ENDSTONE_REGISTRY_TYPE(ItemType)
-
     /**
      * @brief Get the translation key, suitable for use in a translation component.
      *

include/endstone/registry.h

@@ -26,9 +26,20 @@
 #include "server.h"
 
 namespace endstone {
+namespace python {
+class PyRegistry;
+}
+
 class IRegistry {
 public:
     virtual ~IRegistry() = default;
+    [[nodiscard]] virtual std::size_t size() const = 0;
+
+protected:
+    friend class python::PyRegistry;
+    [[nodiscard]] virtual const void *get0(std::string_view id) const noexcept = 0;
+    virtual void forEach0(std::function<bool(const void *)> func) const = 0;
+    [[nodiscard]] virtual const std::type_info &getTypeId() const noexcept = 0;
 };
 
 /**
@@ -147,16 +158,21 @@ class Registry : public IRegistry {
      */
     virtual void forEach(std::function<bool(const T &)> func) const = 0;
 
-    /**
-     * @brief Returns the number of entries in this registry.
-     *
-     * @return std::size_t The number of entries.
-     */
-    [[nodiscard]] virtual std::size_t size() const = 0;
-};
+    [[nodiscard]] std::size_t size() const override = 0;
 
-#define ENDSTONE_REGISTRY_TYPE(type) static constexpr auto RegistryType = #type;
+private:
+    [[nodiscard]] const void *get0(std::string_view id) const noexcept override
+    {
+        return get(Identifier<T>(id));
+    }
 
+    void forEach0(std::function<bool(const void *)> func) const override
+    {
+        forEach([&func](const T &elem) { return func(&elem); });
+    }
+
+    [[nodiscard]] const std::type_info &getTypeId() const noexcept override { return typeid(T); }
+};
 }  // namespace endstone
 
 template <typename T>

include/endstone/server.h

@@ -20,6 +20,7 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
+#include <typeinfo>
 #include <utility>
 #include <vector>
 
@@ -406,12 +407,12 @@ class Server {
      *
      * @return the corresponding registry or null if not present
      */
-    [[nodiscard]] virtual IRegistry *_getRegistry(const std::string &type) const = 0;
+    [[nodiscard]] virtual IRegistry *_getRegistry(const std::type_info &type) const = 0;
 
     template <typename T>
     [[nodiscard]] const Registry<T> &getRegistry() const
     {
-        return *static_cast<Registry<T> *>(_getRegistry(T::RegistryType));
+        return *static_cast<Registry<T> *>(_getRegistry(typeid(T)));
     }
 
     /**

src/endstone/core/server.cpp

@@ -191,10 +191,10 @@ void EndstoneServer::setLevel(::Level &level)
 
 void EndstoneServer::initRegistries()
 {
-    registries_["ActorType"] = EndstoneRegistry<ActorType, std::string>::create();
-    registries_["BlockType"] = EndstoneRegistry<BlockType, ::BlockType>::create();
-    registries_["Enchantment"] = EndstoneRegistry<Enchantment, ::Enchant>::create();
-    registries_["ItemType"] = EndstoneRegistry<ItemType, ::Item>::create();
+    registries_[typeid(ActorType)] = EndstoneRegistry<ActorType, std::string>::create();
+    registries_[typeid(BlockType)] = EndstoneRegistry<BlockType, ::BlockType>::create();
+    registries_[typeid(Enchantment)] = EndstoneRegistry<Enchantment, ::Enchant>::create();
+    registries_[typeid(ItemType)] = EndstoneRegistry<ItemType, ::Item>::create();
     BlockStateRegistry::get().unregisterBlockStates();
     ::BlockState::forEachState([](const auto &state) {
         BlockStateRegistry::get().registerBlockState(state);
@@ -639,9 +639,9 @@ ServiceManager &EndstoneServer::getServiceManager() const
     return *service_manager_;
 }
 
-IRegistry *EndstoneServer::_getRegistry(const std::string &type) const
+IRegistry *EndstoneServer::_getRegistry(const std::type_info &type) const
 {
-    const auto it = registries_.find(type);
+    const auto it = registries_.find(std::type_index(type));
     if (registries_.end() == it) {
         return nullptr;
     }

src/endstone/core/server.h

@@ -17,6 +17,7 @@
 #include <chrono>
 #include <memory>
 #include <string>
+#include <typeindex>
 
 #include "bedrock/resources/resource_pack_repository_interface.h"
 #include "bedrock/server/server_instance.h"
@@ -110,7 +111,7 @@ class EndstoneServer : public Server {
     [[nodiscard]] PlayerBanList &getBanList() const override;
     [[nodiscard]] IpBanList &getIpBanList() const override;
     [[nodiscard]] ServiceManager &getServiceManager() const override;
-    [[nodiscard]] IRegistry *_getRegistry(const std::string &type) const override;
+    [[nodiscard]] IRegistry *_getRegistry(const std::type_info &type) const override;
     [[nodiscard]] MapView *getMap(std::int64_t id) const override;
     [[nodiscard]] MapView &createMap(const Dimension &dimension) const override;
 
@@ -152,7 +153,7 @@ class EndstoneServer : public Server {
     std::unique_ptr<EndstoneScheduler> scheduler_;
     std::unique_ptr<EndstoneCommandMap> command_map_;
     std::unique_ptr<EndstoneLevel> level_;
-    std::unordered_map<std::string, std::unique_ptr<IRegistry>> registries_;
+    std::unordered_map<std::type_index, std::unique_ptr<IRegistry>> registries_;
     std::shared_ptr<EndstoneScoreboard> scoreboard_;
     std::unique_ptr<EndstoneMetrics> metrics_;
     std::unordered_map<UUID, std::shared_ptr<EndstoneScoreboard>> player_boards_;

src/endstone/python/endstone_python.cpp

@@ -133,8 +133,8 @@ PYBIND11_MODULE(_python, m)  // NOLINT(*-use-anonymous-namespace)
     auto block = py::class_<Block>(m_block, "Block", "Represents a block.");
     auto command_sender = py_class<CommandSender>(m_command, "CommandSender", "Represents a command sender.");
     auto actor = py_class<Actor>(m_actor, "Actor", "Represents a base actor in the level.");
-    auto mob = py_class<Mob>(m_actor, "Mob",
-                      "Represents a mobile entity (i.e. living entity), such as a monster or player.");
+    auto mob =
+        py_class<Mob>(m_actor, "Mob", "Represents a mobile entity (i.e. living entity), such as a monster or player.");
     py::class_<OfflinePlayer>(
         m, "OfflinePlayer",
         "Represents a reference to a player identity and the data belonging to a player that is stored on the disk and "
@@ -274,7 +274,14 @@ void init_logger(py::module &m)
 
 void init_registry(py::module_ &m)
 {
-    bind_registries(m, RegistryTypes{});
+    py::class_<PyRegistry>(m, "Registry")
+        .def("get", &PyRegistry::get, py::arg("id"), "Get the object by its identifier.")
+        .def("get_or_throw", &PyRegistry::getOrThrow, py::arg("id"),
+             "Get the object by its identifier or throw if missing.")
+        .def("__getitem__", &PyRegistry::getOrThrow, py::arg("id"))
+        .def("__iter__", &PyRegistry::iter)
+        .def("__contains__", &PyRegistry::contains, py::arg("id"))
+        .def("__len__", &PyRegistry::size);
 }
 
 void init_server(py::class_<Server> &server)
@@ -303,8 +310,18 @@ void init_server(py::class_<Server> &server)
                                "Gets the service manager.")
         .def(
             "get_registry",
-            [](const Server &self, const py::type &t) -> py::object { return get_registry(self, t, RegistryTypes{}); },
-            py::arg("type"), py::return_value_policy::reference, "Returns the registry for all the enchantments.")
+            [](const Server &self, const py::type &t) -> py::object {
+                auto *type_info = py::detail::get_type_info(reinterpret_cast<PyTypeObject *>(t.ptr()));
+                if (!type_info) {
+                    return py::none();
+                }
+                auto *registry = self._getRegistry(*type_info->cpptype);
+                if (!registry) {
+                    return py::none();
+                }
+                return py::cast(PyRegistry(*registry));
+            },
+            py::arg("type"), "Returns the registry for the given type.")
         .def_property_readonly("level", &Server::getLevel, py::return_value_policy::reference_internal,
                                "Gets the server level.")
         .def_property_readonly("online_players", &Server::getOnlinePlayers, py::return_value_policy::reference_internal,