Implements initial math library, several reworks for Userdata memory management

src/UserData/UserData.hpp

@@ -8,7 +8,7 @@
 
 namespace Porygon::UserData {
     class UserData {
-        std::unordered_map<uint32_t, UserDataField *> _fields;
+        std::unordered_map<uint32_t, unique_ptr<UserDataField>> _fields;
 
         // Binary operations
         UserDataBinaryOperation* _addition = nullptr;
@@ -27,14 +27,15 @@ namespace Porygon::UserData {
 
     public:
         explicit UserData(std::unordered_map<uint32_t, UserDataField *> fields)
-            : _fields(std::move(fields))
         {
+            for (auto f: fields){
+                _fields.insert({f.first, unique_ptr<UserDataField>(f.second)});
+            }
         }
 
         ~UserData(){
-            for (auto f: _fields){
-                delete f.second;
-            }
+            _fields.clear();
+
             delete _addition;
             delete _subtraction;
             delete _multiplication;
@@ -57,11 +58,11 @@ namespace Porygon::UserData {
 
         [[nodiscard]]
         inline UserDataField *GetField(uint32_t fieldId) const {
-            return _fields.at(fieldId);
+            return _fields.at(fieldId).get();
         }
 
         inline void CreateField(uint32_t fieldId, UserDataField *field) {
-            _fields.insert({fieldId, field});
+            _fields.insert({fieldId, unique_ptr<UserDataField>(field)});
         }
 
         [[nodiscard]]

src/UserData/UserDataStorage.cpp

@@ -2,6 +2,6 @@
 #include "UserDataStorage.hpp"
 
 namespace Porygon::UserData {
-    UserDataStorage::_internalDataStorage UserDataStorage::_internal = UserDataStorage::_internalDataStorage();
+    UserDataStorage::_internalDataStorage UserDataStorage::_internal;
     std::mutex UserDataStorage::_userDataMutex;
 }

src/UserData/UserDataStorage.hpp

@@ -11,16 +11,17 @@ namespace Porygon::UserData {
     private:
         class _internalDataStorage {
         public:
-            std::unordered_map<uint32_t, UserData*> _userData;
+            std::unordered_map<uint32_t, std::unique_ptr<UserData>> _userData;
+
+            _internalDataStorage()
+            : _userData(std::unordered_map<uint32_t, std::unique_ptr<UserData>>(0))
+            {
+            }
 
             ~_internalDataStorage(){
-                for (auto u: _userData){
-                    delete u.second;
-                }
                 _userData.clear();
             }
 
-            _internalDataStorage() = default;
             _internalDataStorage( const UserDataStorage& ) = delete; // non construction-copyable
             _internalDataStorage& operator=( const UserDataStorage& ) = delete; // non copyable
 
@@ -28,19 +29,14 @@ namespace Porygon::UserData {
 
         static _internalDataStorage _internal;
         static std::mutex _userDataMutex;
-
     public:
         static void RegisterType(uint32_t i, UserData *ud) {
             std::lock_guard<std::mutex> guard(_userDataMutex);
-            UserDataStorage::_internal._userData.insert({i, ud});
+            UserDataStorage::_internal._userData.insert({i, std::unique_ptr<UserData>(ud)});
         }
 
-        static void ClearTypes(){
-            std::lock_guard<std::mutex> guard(_userDataMutex);
-            for (auto u: _internal._userData){
-                delete u.second;
-            }
-            _internal._userData.clear();
+        static void RemoveType(uint32_t key){
+            _internal._userData.erase(key);
         }
 
         inline static bool HasUserDataType(uint32_t i) {
@@ -48,7 +44,7 @@ namespace Porygon::UserData {
         }
 
         inline static UserData* GetUserDataType(uint32_t i) {
-            return UserDataStorage::_internal._userData[i];
+            return UserDataStorage::_internal._userData.at(i).get();
         }
     };
 }