Implements basics for UserData

src/UserData/UserData.cpp

@@ -0,0 +1,2 @@
+
+#include "UserData.hpp"

src/UserData/UserData.hpp

@@ -0,0 +1,25 @@
+#ifndef PORYGONLANG_USERDATA_HPP
+#define PORYGONLANG_USERDATA_HPP
+
+#include <utility>
+#include <unordered_map>
+#include "UserDataField.hpp"
+
+class UserData {
+    std::unordered_map<int, UserDataField*> _fields;
+public:
+    explicit UserData(std::unordered_map<int, UserDataField*> fields){
+        _fields = std::move(fields);
+    }
+
+    bool ContainsField(int fieldId){
+        return _fields.find(fieldId) != _fields.end();
+    }
+
+    UserDataField* GetField(int fieldId){
+        return _fields[fieldId];
+    }
+};
+
+
+#endif //PORYGONLANG_USERDATA_HPP

src/UserData/UserDataField.cpp

@@ -0,0 +1,2 @@
+
+#include "UserDataField.hpp"

src/UserData/UserDataField.hpp

@@ -0,0 +1,33 @@
+
+#ifndef PORYGONLANG_USERDATAFIELD_HPP
+#define PORYGONLANG_USERDATAFIELD_HPP
+
+
+#include "../Evaluator/EvalValues/EvalValue.hpp"
+
+class UserDataField {
+    shared_ptr<ScriptType> _type;
+    EvalValue* (*_get)(void* obj);
+    void (*_set)(void* obj, EvalValue*);
+public:
+    UserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue*)){
+        _type = shared_ptr<ScriptType>(type);
+        _get = getter;
+        _set = setter;
+    }
+
+    shared_ptr<ScriptType> GetType(){
+        return _type;
+    }
+
+    EvalValue* Get(void* obj){
+        return this ->_get(obj);
+    }
+
+    void Set(void* obj, EvalValue* val){
+        this->_set(obj, val);
+    }
+};
+
+
+#endif //PORYGONLANG_USERDATAFIELD_HPP

src/UserData/UserDataScriptType.cpp

@@ -0,0 +1,2 @@
+
+#include "UserDataScriptType.hpp"

src/UserData/UserDataScriptType.hpp

@@ -0,0 +1,31 @@
+
+#ifndef PORYGONLANG_USERDATASCRIPTTYPE_HPP
+#define PORYGONLANG_USERDATASCRIPTTYPE_HPP
+
+
+#include "../ScriptType.hpp"
+#include "UserData.hpp"
+#include "UserDataStorage.hpp"
+
+class UserDataScriptType : public ScriptType{
+    UserData* _userData;
+public:
+    explicit UserDataScriptType(int id) : ScriptType(TypeClass::UserData){
+        _userData = UserDataStorage::GetUserDataType(id);
+    }
+
+    bool CanBeIndexedWith(ScriptType* indexer) final{
+        return indexer->GetClass() == TypeClass ::String;
+    }
+
+    shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) final{
+        auto stringKey = (StringScriptType*)indexer;
+        if (stringKey->IsKnownAtBind()){
+            return _userData->GetField(stringKey->GetHashValue())->GetType();
+        }
+        throw "TODO: indexing with dynamic keys";
+    }
+};
+
+
+#endif //PORYGONLANG_USERDATASCRIPTTYPE_HPP

src/UserData/UserDataStorage.cpp

@@ -0,0 +1,4 @@
+
+#include "UserDataStorage.hpp"
+
+std::unordered_map<int, UserData*> UserDataStorage::_userData = {};

src/UserData/UserDataStorage.hpp

@@ -0,0 +1,21 @@
+
+#ifndef PORYGONLANG_USERDATASTORAGE_HPP
+#define PORYGONLANG_USERDATASTORAGE_HPP
+
+#include <unordered_map>
+#include "UserData.hpp"
+
+class UserDataStorage {
+    static std::unordered_map<int, UserData*> _userData;
+public:
+    static void RegisterType(int i, UserData* ud){
+        UserDataStorage::_userData.insert({i, ud});
+    }
+
+    static UserData* GetUserDataType(int i){
+        return UserDataStorage::_userData[i];
+    }
+};
+
+
+#endif //PORYGONLANG_USERDATASTORAGE_HPP

src/UserData/UserDataValue.cpp

@@ -0,0 +1,2 @@
+
+#include "UserDataValue.hpp"

src/UserData/UserDataValue.hpp

@@ -0,0 +1,50 @@
+
+#ifndef PORYGONLANG_USERDATAVALUE_HPP
+#define PORYGONLANG_USERDATAVALUE_HPP
+
+
+#include "../Evaluator/EvalValues/EvalValue.hpp"
+#include "UserData.hpp"
+#include "UserDataStorage.hpp"
+
+class UserDataValue : public EvalValue{
+    UserData* _userData;
+    void* _obj;
+public:
+    UserDataValue(UserData* userData, void* obj){
+        _userData = userData;
+        _obj = obj;
+    }
+
+    UserDataValue(int userDataId, void* obj){
+        _userData = UserDataStorage::GetUserDataType(userDataId);
+        _obj = obj;
+    }
+
+    const TypeClass GetTypeClass() final{
+        return TypeClass ::UserData;
+    }
+
+    bool operator ==(EvalValue* b) final {
+        if (b->GetTypeClass() != TypeClass::UserData)
+            return false;
+        return _obj == ((UserDataValue*)b)->_obj;
+    }
+
+    shared_ptr<EvalValue> Clone() final{
+        return make_shared<UserDataValue>(_userData, _obj);
+    }
+
+    std::size_t GetHashCode() final{
+        return reinterpret_cast<intptr_t>(_obj);
+    }
+
+    shared_ptr<EvalValue> IndexValue(EvalValue* val) final {
+        auto fieldId = val->GetHashCode();
+        auto field = _userData->GetField(fieldId);
+        return shared_ptr<EvalValue>(field->Get(_obj));
+    }
+};
+
+
+#endif //PORYGONLANG_USERDATAVALUE_HPP