Implements userdata function support

tests/integration/UserData.cpp

@@ -5,6 +5,9 @@
 #include "../../src/UserData/UserData.hpp"
 #include "../../src/UserData/UserDataStorage.hpp"
 #include "../../src/UserData/UserDataValue.hpp"
+#include "../../src/UserData/UserDataFunction.hpp"
+#include "../../src/UserData/UserDataFunctionType.hpp"
+
 using namespace Porygon;
 using namespace Porygon::UserData;
 using namespace Porygon::Utilities;
@@ -12,7 +15,15 @@ using namespace Porygon::Utilities;
 class UserDataTestObject{
 public:
     int foo = 10;
+    int getFoo(){
+        return foo;
+    }
 
+    int Addition(int a, int b){
+        return a + b;
+    }
+
+private:
     static EvalValue* GetFoo(void* obj){
         return new IntegerEvalValue(((UserDataTestObject*)obj)->foo);
     }
@@ -21,16 +32,54 @@ public:
         ((UserDataTestObject*)obj)->foo = val->EvaluateInteger();
     }
 
+    static EvalValue* CallFooFunction(void* obj, EvalValue* parameters[], int parameterCount){
+        return new IntegerEvalValue(((UserDataTestObject*)obj)->getFoo());
+    }
+
+    static EvalValue* GetFooFunction(void* obj){
+        return new UserDataFunction(CallFooFunction, obj,
+                                    make_shared<UserDataFunctionType>(make_shared<NumericScriptType>(true, false), vector<shared_ptr<ScriptType>>(0)));
+    }
+
+    static EvalValue* CallAddition(void* obj, EvalValue* parameters[], int parameterCount){
+        return new IntegerEvalValue(((UserDataTestObject*)obj)->Addition(
+                parameters[0] -> EvaluateInteger(),
+                parameters[1] -> EvaluateInteger()
+                ));
+    }
+
+    static GenericFunctionScriptType* AdditionFunctionType;
+
+    static EvalValue* GetAdditionFunction(void* obj){
+        return new UserDataFunction(CallAddition, obj, shared_ptr<GenericFunctionScriptType>(AdditionFunctionType));
+    }
+
+public:
     static Porygon::UserData::UserData* CreateData(){
         return new Porygon::UserData::UserData({
             {
                 HashedString::ConstHash("foo"),
                 new UserDataField(new NumericScriptType(true, false), GetFoo, SetFoo)
+            },
+            {
+                    HashedString::ConstHash("getFoo"),
+                    new UserDataField(new UserDataFunctionType(make_shared<NumericScriptType>(true, false), {}), GetFooFunction, nullptr)
+            },
+            {
+                    HashedString::ConstHash("Addition"),
+                    new UserDataField(AdditionFunctionType, GetAdditionFunction, nullptr)
             }
-        });
+       });
     }
 };
 
+GenericFunctionScriptType* UserDataTestObject::AdditionFunctionType =
+        new UserDataFunctionType(make_shared<NumericScriptType>(true, false),
+               vector<shared_ptr<ScriptType>>{
+                       make_shared<NumericScriptType>(true, false),
+                       make_shared<NumericScriptType>(true, false)
+               });
+
 TEST_CASE( "Gets UserData value", "[integration]" ) {
     UserDataStorage::RegisterType(HashedString::ConstHash("testObject"), UserDataTestObject::CreateData());
     Script* script = Script::Create(R"(
@@ -65,6 +114,41 @@ end
     delete parameter;
 }
 
+TEST_CASE( "Calls UserData function", "[integration]" ) {
+    UserDataStorage::RegisterType(HashedString::ConstHash("testObject"), UserDataTestObject::CreateData());
+    Script* script = Script::Create(R"(
+function testFunc(testObject obj)
+    return obj.getFoo()
+end
+)");
+    REQUIRE(!script->Diagnostics -> HasErrors());
+    script->Evaluate();
+    auto obj = new UserDataTestObject();
+    auto parameter = new UserDataValue(HashedString::ConstHash("testObject"), obj);
+    auto result = script->CallFunction(u"testFunc", {parameter});
+    REQUIRE(result -> EvaluateInteger() == 10);
+    delete script;
+    delete obj;
+    delete parameter;
+}
+
+TEST_CASE( "Calls UserData function with parameters", "[integration]" ) {
+    UserDataStorage::RegisterType(HashedString::ConstHash("testObject"), UserDataTestObject::CreateData());
+    Script* script = Script::Create(R"(
+function testFunc(testObject obj)
+    return obj.Addition(5046, 8432)
+end
+)");
+    REQUIRE(!script->Diagnostics -> HasErrors());
+    script->Evaluate();
+    auto obj = new UserDataTestObject();
+    auto parameter = new UserDataValue(HashedString::ConstHash("testObject"), obj);
+    auto result = script->CallFunction(u"testFunc", {parameter});
+    REQUIRE(result -> EvaluateInteger() == 13478);
+    delete script;
+    delete obj;
+    delete parameter;
+}
 
 
 #endif