Make use of custom functions when converting menus

src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.cpp

@@ -0,0 +1,43 @@
+#include "CommonExpressionBaseFunctionCall.h"
+
+using namespace menu;
+
+CommonExpressionBaseFunctionCall::CommonExpressionBaseFunctionCall(std::string functionName, size_t functionIndex)
+    : m_function_name(std::move(functionName)),
+      m_function_index(functionIndex)
+{
+}
+
+bool CommonExpressionBaseFunctionCall::Equals(const ISimpleExpression* other) const
+{
+    const auto otherFunctionCall = dynamic_cast<const CommonExpressionBaseFunctionCall*>(other);
+
+    if (!otherFunctionCall
+        || m_function_name != otherFunctionCall->m_function_name
+        || m_function_index != otherFunctionCall->m_function_index
+        || m_args.size() != otherFunctionCall->m_args.size())
+    {
+        return false;
+    }
+
+    for (auto i = 0u; i < m_args.size(); i++)
+    {
+        const auto* arg = m_args[i].get();
+        const auto* otherArg = otherFunctionCall->m_args[i].get();
+
+        if (!arg->Equals(otherArg))
+            return false;
+    }
+
+    return true;
+}
+
+bool CommonExpressionBaseFunctionCall::IsStatic() const
+{
+    return false;
+}
+
+SimpleExpressionValue CommonExpressionBaseFunctionCall::Evaluate() const
+{
+    return SimpleExpressionValue(0);
+}

src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.h

@@ -5,13 +5,14 @@
 
 namespace menu
 {
-    class CommonExpressionFunctionCall final : public ISimpleExpression
+    class CommonExpressionBaseFunctionCall final : public ISimpleExpression
     {
     public:
         std::string m_function_name;
+        size_t m_function_index;
         std::vector<std::unique_ptr<ISimpleExpression>> m_args;
 
-        explicit CommonExpressionFunctionCall(std::string functionName);
+        CommonExpressionBaseFunctionCall(std::string functionName, size_t functionIndex);
 
         _NODISCARD bool Equals(const ISimpleExpression* other) const override;
         _NODISCARD bool IsStatic() const override;

src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.cpp

@@ -0,0 +1,24 @@
+#include "CommonExpressionCustomFunctionCall.h"
+
+using namespace menu;
+
+CommonExpressionCustomFunctionCall::CommonExpressionCustomFunctionCall(std::string functionName)
+    : m_function_name(std::move(functionName))
+{
+}
+
+bool CommonExpressionCustomFunctionCall::Equals(const ISimpleExpression* other) const
+{
+    const auto otherFunctionCall = dynamic_cast<const CommonExpressionCustomFunctionCall*>(other);
+    return otherFunctionCall && m_function_name == otherFunctionCall->m_function_name;
+}
+
+bool CommonExpressionCustomFunctionCall::IsStatic() const
+{
+    return false;
+}
+
+SimpleExpressionValue CommonExpressionCustomFunctionCall::Evaluate() const
+{
+    return SimpleExpressionValue(0);
+}

src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Parsing/Simple/Expression/ISimpleExpression.h"
+
+namespace menu
+{
+    class CommonExpressionCustomFunctionCall final : public ISimpleExpression
+    {
+    public:
+        std::string m_function_name;
+
+        explicit CommonExpressionCustomFunctionCall(std::string functionName);
+
+        _NODISCARD bool Equals(const ISimpleExpression* other) const override;
+        _NODISCARD bool IsStatic() const override;
+        _NODISCARD SimpleExpressionValue Evaluate() const override;
+    };
+}

src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.cpp

@@ -1,41 +0,0 @@
-#include "CommonExpressionFunctionCall.h"
-
-using namespace menu;
-
-CommonExpressionFunctionCall::CommonExpressionFunctionCall(std::string functionName)
-    : m_function_name(std::move(functionName))
-{
-}
-
-bool CommonExpressionFunctionCall::Equals(const ISimpleExpression* other) const
-{
-    const auto otherFunctionCall = dynamic_cast<const CommonExpressionFunctionCall*>(other);
-
-    if (!otherFunctionCall 
-        || m_function_name != otherFunctionCall->m_function_name
-        || m_args.size() != otherFunctionCall->m_args.size())
-    {
-        return false;
-    }
-
-    for(auto i = 0u; i < m_args.size(); i++)
-    {
-        const auto* arg = m_args[i].get();
-        const auto* otherArg = otherFunctionCall->m_args[i].get();
-
-        if (!arg->Equals(otherArg))
-            return false;
-    }
-
-    return true;
-}
-
-bool CommonExpressionFunctionCall::IsStatic() const
-{
-    return false;
-}
-
-SimpleExpressionValue CommonExpressionFunctionCall::Evaluate() const
-{
-    return SimpleExpressionValue(0);
-}