Added ElunaInfoKey

Author: NixAJ

ElunaMgr.cpp

@@ -31,7 +31,7 @@ void ElunaMgr::Create(Map* map, ElunaInfo const& info)
     _elunaMap.emplace(info.key, std::make_unique<Eluna>(map));
 }
 
-Eluna* ElunaMgr::Get(uint64 key) const
+Eluna* ElunaMgr::Get(ElunaInfoKey key) const
 {
     auto it = _elunaMap.find(key);
     if (it != _elunaMap.end())
@@ -45,7 +45,7 @@ Eluna* ElunaMgr::Get(ElunaInfo const& info) const
     return Get(info.key);
 }
 
-void ElunaMgr::Destroy(uint64 key)
+void ElunaMgr::Destroy(ElunaInfoKey key)
 {
     _elunaMap.erase(key);
 }
@@ -55,45 +55,75 @@ void ElunaMgr::Destroy(ElunaInfo const& info)
     Destroy(info.key);
 }
 
-ElunaInfo::ElunaInfo(uint32 mapId, uint32 instanceId)
+ElunaInfoKey::ElunaInfoKey(uint32 mapId, uint32 instanceId)
 {
-    key = MakeKey(mapId, instanceId);
+    value = MakeKey(mapId, instanceId);
 }
 
-ElunaInfo::~ElunaInfo()
+bool ElunaInfoKey::operator==(const ElunaInfoKey& other) const
 {
-    if (IsValid() && sElunaMgr)
-        sElunaMgr->Destroy(key);
+    return value == other.value;
 }
 
-constexpr uint64 ElunaInfo::MakeKey(uint32 mapId, uint32 instanceId)
+constexpr ElunaInfoKey ElunaInfoKey::MakeKey(uint32 mapId, uint32 instanceId)
 {
-    return instanceId | (static_cast<uint64>(mapId) << 32);
+    return ElunaInfoKey(instanceId | (static_cast<uint64>(mapId) << 32));
 }
 
-constexpr uint64 ElunaInfo::MakeGlobalKey(uint32 instanceId)
+constexpr ElunaInfoKey ElunaInfoKey::MakeGlobalKey(uint32 instanceId)
 {
     return MakeKey(GLOBAL_MAP_ID, instanceId);
 }
 
+bool ElunaInfoKey::IsValid() const
+{
+    return value != INVALID_KEY_VALUE;
+}
+
+bool ElunaInfoKey::IsGlobal() const
+{
+    return IsValid() && GetMapId() == GLOBAL_MAP_ID;
+}
+
+uint32 ElunaInfoKey::GetMapId() const
+{
+    return value >> 32;
+}
+
+uint32 ElunaInfoKey::GetInstanceId() const
+{
+    return value & 0xFFFFFFFF;
+}
+
+ElunaInfo::ElunaInfo(uint32 mapId, uint32 instanceId)
+{
+    key = ElunaInfoKey::MakeKey(mapId, instanceId);
+}
+
+ElunaInfo::~ElunaInfo()
+{
+    if (IsValid() && sElunaMgr)
+        sElunaMgr->Destroy(key);
+}
+
 bool ElunaInfo::IsValid() const
 {
-    return key != INVALID_KEY_ID;
+    return key.IsValid();
 }
 
 bool ElunaInfo::IsGlobal() const
 {
-    return IsValid() && GetMapId() == GLOBAL_MAP_ID;
+    return key.IsGlobal();
 }
 
 uint32 ElunaInfo::GetMapId() const
 {
-    return key >> 32;
+    return key.GetMapId();
 }
 
 uint32 ElunaInfo::GetInstanceId() const
 {
-    return key & 0xFFFFFFFF;
+    return key.GetInstanceId();
 }
 
 Eluna* ElunaInfo::GetEluna() const

ElunaMgr.h

@@ -13,16 +13,55 @@
 
 class Eluna;
 
+struct ElunaInfoKey
+{
+public:
+    ElunaInfoKey() : value(INVALID_KEY_VALUE) {}
+    ElunaInfoKey(uint64 key) : value(key) {}
+    ElunaInfoKey(uint32 mapId, uint32 instanceId);
+    ~ElunaInfoKey() {}
+
+    bool operator==(const ElunaInfoKey& other) const;
+
+public:
+    static constexpr ElunaInfoKey MakeKey(uint32 mapId, uint32 instanceId);
+    static constexpr ElunaInfoKey MakeGlobalKey(uint32 instanceId);
+
+    bool IsValid() const;
+    bool IsGlobal() const;
+
+    uint32 GetMapId() const;
+    uint32 GetInstanceId() const;
+    
+public:
+    static uint64 const INVALID_KEY_VALUE = std::numeric_limits<uint64>().max();
+    static uint32 const GLOBAL_MAP_ID = std::numeric_limits<uint32>().max();
+
+    uint64 value;
+};
+
+// Specialize ElunaInfoKey for use in unordered_map
+namespace std
+{
+    template <>
+    struct hash<ElunaInfoKey>
+    {
+        size_t operator()(const ElunaInfoKey& key) const
+        {
+            return key.value;
+        }
+    };
+}
+
 struct ElunaInfo
 {
 public:
+    ElunaInfo() : key() {}
+    ElunaInfo(ElunaInfoKey key) : key(key) {}
     ElunaInfo(uint32 mapId, uint32 instanceId);
     ~ElunaInfo();
 
 public:
-    static constexpr uint64 MakeKey(uint32 mapId, uint32 instanceId);
-    static constexpr uint64 MakeGlobalKey(uint32 instanceId);
-
     bool IsValid() const;
     bool IsGlobal() const;
 
@@ -33,10 +72,7 @@ struct ElunaInfo
     Eluna* GetEluna() const;
 
 public:
-    static uint64 const INVALID_KEY_ID = std::numeric_limits<uint64>().max();
-    static uint32 const GLOBAL_MAP_ID = std::numeric_limits<uint32>().max();
-
-    uint64 key = INVALID_KEY_ID;
+    ElunaInfoKey key;
 };
 
 class ElunaMgr
@@ -52,14 +88,14 @@ class ElunaMgr
 
     void Create(Map* map, ElunaInfo const& info);
 
-    Eluna* Get(uint64 key) const;
+    Eluna* Get(ElunaInfoKey key) const;
     Eluna* Get(ElunaInfo const& info) const;
 
-    void Destroy(uint64 key);
+    void Destroy(ElunaInfoKey key);
     void Destroy(ElunaInfo const& info);
 
 private:
-    std::unordered_map<uint64, std::unique_ptr<Eluna>> _elunaMap;
+    std::unordered_map<ElunaInfoKey, std::unique_ptr<Eluna>> _elunaMap;
 };
 
 #define sElunaMgr ElunaMgr::instance()