Fix all valgrind leak issues in tests

Signed-off-by: Deukhoofd <deukhoofd@gmail.com>

src/UserData/UserData.hpp

@@ -1,3 +1,5 @@
+#include <utility>
+
 #ifndef PORYGONLANG_USERDATA_HPP
 #define PORYGONLANG_USERDATA_HPP
 
@@ -9,23 +11,30 @@ namespace Porygon::UserData {
     class UserData {
         std::unordered_map<uint32_t, UserDataField *> _fields;
     public:
-        explicit UserData(std::unordered_map<uint32_t, UserDataField *> fields) {
-            _fields = std::move(fields);
+        explicit UserData(std::unordered_map<uint32_t, UserDataField *> fields)
+            : _fields(std::move(fields))
+        {
         }
 
-        bool ContainsField(uint32_t fieldId) {
+        ~UserData(){
+            for (auto f: _fields){
+                delete f.second;
+            }
+        }
+
+        bool ContainsField(uint32_t fieldId) const{
             return _fields.find(fieldId) != _fields.end();
         }
 
-        UserDataField *GetField(uint32_t fieldId) {
-            return _fields[fieldId];
+        UserDataField *GetField(uint32_t fieldId) const {
+            return _fields.at(fieldId);
         }
 
         void CreateField(uint32_t fieldId, UserDataField *field) {
             _fields.insert({fieldId, field});
         }
 
-        int32_t GetFieldCount() {
+        int32_t GetFieldCount() const{
             return _fields.size();
         }
     };

src/UserData/UserDataScriptType.hpp

@@ -10,14 +10,14 @@
 
 namespace Porygon::UserData {
     class UserDataScriptType : public ScriptType {
-        shared_ptr<UserData> _userData;
+        UserData* _userData;
     public:
         explicit UserDataScriptType(uint32_t id) : ScriptType(TypeClass::UserData) {
             _userData = UserDataStorage::GetUserDataType(id);
         }
 
-        explicit UserDataScriptType(shared_ptr<UserData> ud) : ScriptType(TypeClass::UserData) {
-            _userData = std::move(ud);
+        explicit UserDataScriptType(UserData* ud) : ScriptType(TypeClass::UserData) {
+            _userData = ud;
         }
 
         const bool CanBeIndexedWith(ScriptType *indexer) const final {

src/UserData/UserDataStorage.hpp

@@ -3,27 +3,46 @@
 #define PORYGONLANG_USERDATASTORAGE_HPP
 
 #include <unordered_map>
+#include <mutex>
 #include "UserData.hpp"
 
 namespace Porygon::UserData {
     class UserDataStorage {
         class _internalDataStorage {
         public:
-            std::unordered_map<uint32_t, shared_ptr<UserData>> _userData;
+            std::unordered_map<uint32_t, UserData*> _userData;
+            std::mutex _userDataMutex;
+
+            ~_internalDataStorage(){
+                std::lock_guard<std::mutex> guard(_userDataMutex);
+                for (auto u: _userData){
+                    delete u.second;
+                }
+                _userData.clear();
+            }
         };
 
         static _internalDataStorage _internal;
 
     public:
         static void RegisterType(uint32_t i, UserData *ud) {
-            UserDataStorage::_internal._userData.insert({i, shared_ptr<UserData>(ud)});
+            std::lock_guard<std::mutex> guard(_internal._userDataMutex);
+            UserDataStorage::_internal._userData.insert({i, ud});
+        }
+
+        static void ClearTypes(){
+            std::lock_guard<std::mutex> guard(_internal._userDataMutex);
+            for (auto u: _internal._userData){
+                delete u.second;
+            }
+            _internal._userData.clear();
         }
 
         static bool HasUserDataType(uint32_t i) {
             return UserDataStorage::_internal._userData.find(i) != UserDataStorage::_internal._userData.end();
         }
 
-        static shared_ptr<UserData> GetUserDataType(uint32_t i) {
+        static UserData* GetUserDataType(uint32_t i) {
             return UserDataStorage::_internal._userData[i];
         }
     };

src/UserData/UserDataValue.hpp

@@ -9,11 +9,11 @@
 
 namespace Porygon::UserData {
     class UserDataValue : public Evaluation::EvalValue {
-        const shared_ptr<UserData> _userData;
+        const UserData* _userData;
         void *_obj;
     public:
-        UserDataValue(shared_ptr<UserData> userData, void *obj)
-                : _userData(std::move(userData)) {
+        UserDataValue(const UserData* userData, void *obj)
+                : _userData(userData) {
             _obj = obj;
         }