Allow using pointer to variables (#20)

Ecos-platform · Dec 3, 2024 · 5cfa566 · 5cfa566
1 parent 422dc07
commit 5cfa566
Show file tree

Hide file tree

Showing 13 changed files with 387 additions and 60 deletions.
diff --git a/README.md b/README.md
@@ -30,28 +30,25 @@ public:
 
         register_variable(
                 real(
-                        "height", [this] { return height; })
+                        "height", &height)
                         .setCausality(causality_t::OUTPUT)
                         .setVariability(variability_t::CONTINUOUS));
 
         register_variable(
                 real(
-                        "velocity", [this] { return velocity; })
+                        "velocity", &velocity)
                         .setCausality(causality_t::LOCAL)
                         .setVariability(variability_t::CONTINUOUS));
 
         register_variable(
                 real(
-                        "gravity", [this] { return gravity; },
-                        [this](const auto &input) { gravity = input; })
+                        "gravity", &gravity)
                         .setCausality(causality_t::PARAMETER)
                         .setVariability(variability_t::FIXED));
 
         register_variable(
                 real(
-                        "bounceFactor",
-                        [this] { return bounceFactor; },
-                        [this](const auto &input) { bounceFactor = input; })
+                        "bounceFactor", &bounceFactor)
                         .setCausality(causality_t::PARAMETER)
                         .setVariability(variability_t::FIXED));
 

diff --git a/export/examples/BouncingBall/bouncing_ball.cpp b/export/examples/BouncingBall/bouncing_ball.cpp
@@ -12,29 +12,26 @@ class BouncingBall : public fmu_base {
 
         register_variable(
                 real(
-                        "height", [this] { return height_; })
+                        "height", &height_)
                         .setCausality(causality_t::OUTPUT)
                         .setVariability(variability_t::CONTINUOUS)
                         .setInitial(initial_t::EXACT));
 
         register_variable(
                 real(
-                        "velocity", [this] { return velocity_; })
+                        "velocity", &velocity_)
                         .setCausality(causality_t::LOCAL)
                         .setVariability(variability_t::CONTINUOUS));
 
         register_variable(
                 real(
-                        "gravity", [this] { return gravity_; },
-                        [this](const auto &input) { gravity_ = input; })
+                        "gravity", &gravity_)
                         .setCausality(causality_t::PARAMETER)
                         .setVariability(variability_t::FIXED));
 
         register_variable(
                 real(
-                        "bounceFactor",
-                        [this] { return bounceFactor_; },
-                        [this](const auto &input) { bounceFactor_ = input; })
+                        "bounceFactor", &bounceFactor_)
                         .setCausality(causality_t::PARAMETER)
                         .setVariability(variability_t::FIXED));
 

diff --git a/export/examples/Resource/resource.cpp b/export/examples/Resource/resource.cpp
@@ -15,12 +15,11 @@ class Resource : public fmu_base {
 
         std::ifstream ifs(resources / "file.txt");
 
-        std::string line;
-        std::getline(ifs, line);
+        std::getline(ifs, content_);
 
         register_variable(
                 string(
-                        "content", [line] { return line; })
+                        "content", &content_)
                         .setVariability(variability_t::CONSTANT)
                         .setCausality(causality_t::OUTPUT));
 
@@ -37,6 +36,9 @@ class Resource : public fmu_base {
         // do nothing
     }
 
+private:
+    std::string content_;
+
 };
 
 model_info fmu4cpp::get_model_info() {

diff --git a/export/examples/SimplePendulum/simple_pendulum.cpp b/export/examples/SimplePendulum/simple_pendulum.cpp
@@ -12,31 +12,23 @@ class SimplePendulum : public fmu_base {
     SimplePendulum(const std::string &instanceName, const std::filesystem::path &resources)
         : fmu_base(instanceName, resources) {
 
-        register_variable(real("angle",
-                               [this] { return angle_; })
+        register_variable(real("angle", &angle_)
                                   .setCausality(causality_t::OUTPUT)
                                   .setVariability(variability_t::CONTINUOUS));
 
-        register_variable(real("angularVelocity",
-                               [this] { return angularVelocity_; })
+        register_variable(real("angularVelocity", &angularVelocity_)
                                   .setCausality(causality_t::LOCAL)
                                   .setVariability(variability_t::CONTINUOUS));
         register_variable(real(
-                                  "gravity",
-                                  [this] { return gravity_; },
-                                  [this](double input) { gravity_ = input; })
+                                  "gravity", &gravity_)
                                   .setCausality(causality_t::PARAMETER)
                                   .setVariability(variability_t::FIXED));
         register_variable(real(
-                                  "length",
-                                  [this] { return length_; },
-                                  [this](double input) { length_ = input; })
+                                  "length", &length_)
                                   .setCausality(causality_t::PARAMETER)
                                   .setVariability(variability_t::FIXED));
         register_variable(real(
-                                  "damping",
-                                  [this] { return damping_; },
-                                  [this](double input) { damping_ = input; })
+                                  "damping", &damping_)
                                   .setCausality(causality_t::PARAMETER)
                                   .setVariability(variability_t::FIXED));
 

diff --git a/export/include/fmu4cpp/fmu_base.hpp b/export/include/fmu4cpp/fmu_base.hpp
@@ -166,18 +166,22 @@ namespace fmu4cpp {
         virtual ~fmu_base() = default;
 
     protected:
+        IntVariable integer(const std::string &name, int *ptr);
         IntVariable integer(const std::string &name,
                             const std::function<int()> &getter,
                             const std::optional<std::function<void(int)>> &setter = std::nullopt);
 
+        RealVariable real(const std::string &name, double *ptr);
         RealVariable real(const std::string &name,
                           const std::function<double()> &getter,
                           const std::optional<std::function<void(double)>> &setter = std::nullopt);
 
+        BoolVariable boolean(const std::string &name, bool *ptr);
         BoolVariable boolean(const std::string &name,
-                             const std::function<bool()> &getter,
-                             const std::optional<std::function<void(bool)>> &setter = std::nullopt);
+                                       const std::function<bool()> &getter,
+                                       const std::optional<std::function<void(bool)>> &setter);
 
+        StringVariable string(const std::string &name, std::string *ptr);
         StringVariable string(const std::string &name,
                               const std::function<std::string()> &getter,
                               const std::optional<std::function<void(std::string)>> &setter = std::nullopt);

diff --git a/export/include/fmu4cpp/fmu_variable.hpp b/export/include/fmu4cpp/fmu_variable.hpp
@@ -2,7 +2,9 @@
 #ifndef FMU4CPP_FMU_VARIABLE_HPP
 #define FMU4CPP_FMU_VARIABLE_HPP
 
-#include <functional>
+#include "variable_access.hpp"
+
+#include <memory>
 #include <optional>
 #include <stdexcept>
 #include <string>
@@ -37,6 +39,7 @@ namespace fmu4cpp {
     std::string to_string(const variability_t &v);
     std::string to_string(const initial_t &i);
 
+
     class VariableBase {
 
     protected:
@@ -93,19 +96,30 @@ namespace fmu4cpp {
     class Variable : public VariableBase {
 
     public:
+        Variable(
+                const std::string &name,
+                unsigned int vr, size_t index, T *ptr)
+            : VariableBase(name, vr, index), access_(std::make_unique<PtrAccess<T>>(ptr)) {}
+
         Variable(
                 const std::string &name,
                 unsigned int vr, size_t index,
                 std::function<T()> getter,
                 std::optional<std::function<void(T)>> setter)
-            : VariableBase(name, vr, index), getter_(std::move(getter)), setter_(std::move(setter)) {}
+            : VariableBase(name, vr, index),
+              access_(std::make_unique<LambdaAccess<T>>(std::move(getter), std::move(setter))) {}
 
         [[nodiscard]] T get() const {
-            return getter_();
+
+            return access_->get();
         }
 
         void set(T value) {
-            if (setter_) setter_->operator()(value);
+            if (causality_ == causality_t::LOCAL || causality_ == causality_t::OUTPUT) {
+                throw std::logic_error("Cannot set value for variable with causality: " + to_string(causality_));
+            }
+
+            access_->set(value);
         }
 
         V &setCausality(causality_t causality) {
@@ -131,13 +145,17 @@ namespace fmu4cpp {
         }
 
     private:
-        std::function<T()> getter_;
-        std::optional<std::function<void(T)>> setter_;
+        std::shared_ptr<VariableAccess<T>> access_;
     };
 
     class IntVariable final : public Variable<int, IntVariable> {
 
     public:
+        IntVariable(
+                const std::string &name,
+                unsigned int vr, size_t index, int *ptr)
+            : Variable(name, vr, index, ptr) {}
+
         IntVariable(
                 const std::string &name,
                 unsigned int vr, size_t index,
@@ -171,6 +189,14 @@ namespace fmu4cpp {
     class RealVariable final : public Variable<double, RealVariable> {
 
     public:
+        RealVariable(
+                const std::string &name,
+                unsigned int vr, size_t index, double *ptr)
+            : Variable(name, vr, index, ptr) {
+
+            variability_ = variability_t::CONTINUOUS;
+        }
+
         RealVariable(
                 const std::string &name,
                 unsigned int vr, size_t index,
@@ -207,6 +233,11 @@ namespace fmu4cpp {
     class BoolVariable final : public Variable<bool, BoolVariable> {
 
     public:
+        BoolVariable(
+                const std::string &name,
+                unsigned int vr, size_t index, bool *ptr)
+            : Variable(name, vr, index, ptr) {}
+
         BoolVariable(
                 const std::string &name,
                 unsigned int vr, size_t index,
@@ -218,6 +249,11 @@ namespace fmu4cpp {
     class StringVariable final : public Variable<std::string, StringVariable> {
 
     public:
+        StringVariable(
+                const std::string &name,
+                unsigned int vr, size_t index, std::string *ptr)
+            : Variable(name, vr, index, ptr) {}
+
         StringVariable(
                 const std::string &name,
                 unsigned int vr, size_t index,

diff --git a/export/include/fmu4cpp/variable_access.hpp b/export/include/fmu4cpp/variable_access.hpp
@@ -0,0 +1,62 @@
+
+#ifndef VARIABLEACCESS_HPP
+#define VARIABLEACCESS_HPP
+
+#include <functional>
+#include <optional>
+#include <utility>
+
+namespace fmu4cpp {
+
+    template<typename T>
+    struct VariableAccess {
+        virtual T get() = 0;
+        virtual void set(T value) = 0;
+
+        virtual ~VariableAccess() = default;
+    };
+
+    template<typename T>
+    class PtrAccess final : public VariableAccess<T> {
+
+    public:
+        explicit PtrAccess(T *ptr) : ptr_(ptr) {}
+
+        T get() override {
+            return *ptr_;
+        }
+
+        void set(T value) override {
+            *ptr_ = value;
+        }
+
+    private:
+        T *ptr_;
+    };
+
+    template<typename T>
+    class LambdaAccess final : public VariableAccess<T> {
+
+    public:
+        LambdaAccess(std::function<T()> getter, std::optional<std::function<void(T)>> setter)
+            : getter_(std::move(getter)),
+              setter_(std::move(setter)) {}
+
+        T get() override {
+            return getter_();
+        }
+
+        void set(T value) override {
+            if (setter_) {
+                setter_->operator()(value);
+            }
+        }
+
+    private:
+        std::function<T()> getter_;
+        std::optional<std::function<void(T)>> setter_;
+    };
+
+}// namespace fmu4cpp
+
+#endif//VARIABLEACCESS_HPP
diff --git a/export/src/fmu4cpp/fmu_base.cpp b/export/src/fmu4cpp/fmu_base.cpp
@@ -195,18 +195,34 @@ namespace fmu4cpp {
         return ss.str();
     }
 
+    IntVariable fmu_base::integer(const std::string &name, int *ptr) {
+        return {name, static_cast<unsigned int>(integers_.size()), numVariables_++, ptr};
+    }
+
     IntVariable fmu_base::integer(const std::string &name, const std::function<int()> &getter, const std::optional<std::function<void(int)>> &setter) {
         return {name, static_cast<unsigned int>(integers_.size()), numVariables_++, getter, setter};
     }
 
+    RealVariable fmu_base::real(const std::string &name, double *ptr) {
+        return {name, static_cast<unsigned int>(reals_.size()), numVariables_++, ptr};
+    }
+
     RealVariable fmu_base::real(const std::string &name, const std::function<double()> &getter, const std::optional<std::function<void(double)>> &setter) {
         return {name, static_cast<unsigned int>(reals_.size()), numVariables_++, getter, setter};
     }
 
+    BoolVariable fmu_base::boolean(const std::string &name, bool *ptr) {
+        return {name, static_cast<unsigned int>(booleans_.size()), numVariables_++, ptr};
+    }
+
     BoolVariable fmu_base::boolean(const std::string &name, const std::function<bool()> &getter, const std::optional<std::function<void(bool)>> &setter) {
         return {name, static_cast<unsigned int>(booleans_.size()), numVariables_++, getter, setter};
     }
 
+    StringVariable fmu_base::string(const std::string &name, std::string *ptr) {
+        return {name, static_cast<unsigned int>(strings_.size()), numVariables_++, ptr};
+    }
+
     StringVariable fmu_base::string(const std::string &name, const std::function<std::string()> &getter, const std::optional<std::function<void(std::string)>> &setter) {
         return {name, static_cast<unsigned int>(strings_.size()), numVariables_++, getter, setter};
     }

diff --git a/export/tests/CMakeLists.txt b/export/tests/CMakeLists.txt
@@ -17,4 +17,5 @@ function(make_test modelIdentifier sources)
 endfunction()
 
 make_test(basic_test basic_test.cpp)
+make_test(identity_test identity_test.cpp)
 make_test(test_resource test_resource.cpp)
diff --git a/export/tests/basic_test.cpp b/export/tests/basic_test.cpp
@@ -10,13 +10,13 @@ class Model : public fmu4cpp::fmu_base {
     Model(const std::string &instanceName, const std::filesystem::path &resources)
         : fmu_base(instanceName, resources) {
 
-        register_variable(real("myReal", [this] { return real_; })
+        register_variable(real("myReal", &real_)
                                   .setCausality(fmu4cpp::causality_t::OUTPUT));
-        register_variable(integer("myInteger", [this] { return integer_; })
+        register_variable(integer("myInteger", &integer_)
                                   .setCausality(fmu4cpp::causality_t::OUTPUT));
-        register_variable(boolean("myBoolean", [this] { return boolean_; })
+        register_variable(boolean("myBoolean", &boolean_)
                                   .setCausality(fmu4cpp::causality_t::OUTPUT));
-        register_variable(string("myString", [this] { return str_; })
+        register_variable(string("myString", &str_)
                                   .setCausality(fmu4cpp::causality_t::OUTPUT));
 
         Model::reset();
@@ -74,6 +74,10 @@ TEST_CASE("basic_test") {
     instance->enter_initialisation_mode();
     instance->exit_initialisation_mode();
 
+    unsigned int vr = boolean->value_reference();
+    int testFail = false;
+    REQUIRE_THROWS(instance->set_boolean(&vr, 1, &testFail));
+
     int i = 0;
     while (t < 10) {
         instance->do_step(t, dt);