apply changes from #37

and some refactoring

Author: markaren

README.md

@@ -26,14 +26,15 @@ using namespace fmu4cpp;
 class BouncingBall : public fmu_base {
 
 public:
-    BouncingBall(const std::string &instanceName, const std::string &resources)
-        : fmu_base(instanceName, resources) {
+    BouncingBall(const fmu_data& data)
+        : fmu_base(data) {
 
         register_variable(
                 real(
                         "height", &height)
                         .setCausality(causality_t::OUTPUT)
-                        .setVariability(variability_t::CONTINUOUS));
+                        .setVariability(variability_t::CONTINUOUS))
+                        .setInitial(initial_t::EXACT));
 
         register_variable(
                 real(
@@ -80,10 +81,10 @@ public:
     }
 
 private:
-    double height;      // Current height of the ball
-    double velocity;    // Current velocity of the ball
-    double gravity;     // Acceleration due to gravity
-    double bounceFactor;// Factor to reduce velocity on bounce
+    double height{};      // Current height of the ball
+    double velocity{};    // Current velocity of the ball
+    double gravity{};     // Acceleration due to gravity
+    double bounceFactor{};// Factor to reduce velocity on bounce
 };
 
 model_info fmu4cpp::get_model_info() {

export/examples/BouncingBall/bouncing_ball.cpp

@@ -10,8 +10,7 @@ using namespace fmu4cpp;
 class BouncingBall : public fmu_base {
 
 public:
-    BouncingBall(const std::string &instanceName, const std::filesystem::path &resources)
-        : fmu_base(instanceName, resources) {
+    explicit BouncingBall(const fmu_data &data) : fmu_base(data) {
 
         register_variable(
                 real(
@@ -71,10 +70,10 @@ class BouncingBall : public fmu_base {
     }
 
 private:
-    double height_;       // Current height of the ball
-    double velocity_;     // Current velocity of the ball
-    double gravity_;      // Acceleration due to gravity
-    double bounceFactor_; // Factor to reduce velocity on bounce
+    double height_{};      // Current height of the ball
+    double velocity_{};    // Current velocity of the ball
+    double gravity_{};     // Acceleration due to gravity
+    double bounceFactor_{};// Factor to reduce velocity on bounce
 };
 
 model_info fmu4cpp::get_model_info() {

export/examples/Resource/resource.cpp

@@ -10,10 +10,9 @@ using namespace fmu4cpp;
 class Resource : public fmu_base {
 
 public:
-    Resource(const std::string &instanceName, const std::filesystem::path &resources)
-        : fmu_base(instanceName, resources) {
+    explicit Resource(const fmu_data &data) : fmu_base(data) {
 
-        std::ifstream ifs(resources / "file.txt");
+        std::ifstream ifs(resourceLocation() / "file.txt");
 
         std::getline(ifs, content_);
 
@@ -38,7 +37,6 @@ class Resource : public fmu_base {
 
 private:
     std::string content_;
-
 };
 
 model_info fmu4cpp::get_model_info() {

export/examples/SimplePendulum/simple_pendulum.cpp

@@ -8,9 +8,9 @@ using namespace fmu4cpp;
 constexpr double pi = 3.14159265358979323846;
 
 class SimplePendulum : public fmu_base {
+
 public:
-    SimplePendulum(const std::string &instanceName, const std::filesystem::path &resources)
-        : fmu_base(instanceName, resources) {
+    explicit SimplePendulum(const fmu_data &data) : fmu_base(data) {
 
         register_variable(real("angle", &angle_)
                                   .setCausality(causality_t::OUTPUT)
@@ -51,11 +51,11 @@ class SimplePendulum : public fmu_base {
     }
 
 private:
-    double angle_;          // Current angle of the pendulum
-    double angularVelocity_;// Current angular velocity
-    double gravity_;        // Acceleration due to gravity
-    double length_;         // Length of the pendulum
-    double damping_;        // Damping factor
+    double angle_{};          // Current angle of the pendulum
+    double angularVelocity_{};// Current angular velocity
+    double gravity_{};        // Acceleration due to gravity
+    double length_{};         // Length of the pendulum
+    double damping_{};        // Damping factor
 };
 
 

export/include/fmu4cpp/fmu_base.hpp

@@ -16,19 +16,24 @@
 
 #include <filesystem>
 
-#define FMU4CPP_INSTANTIATE(MODELCLASS)                                                                            \
-    std::unique_ptr<fmu4cpp::fmu_base> fmu4cpp::createInstance(const std::string &instanceName,                    \
-                                                               const std::filesystem::path &fmuResourceLocation) { \
-        return std::make_unique<MODELCLASS>(instanceName, fmuResourceLocation);                                    \
+#define FMU4CPP_INSTANTIATE(MODELCLASS)                                                         \
+    std::unique_ptr<fmu4cpp::fmu_base> fmu4cpp::createInstance(const fmu4cpp::fmu_data &data) { \
+        return std::make_unique<MODELCLASS>(data);                                              \
     }
 
 namespace fmu4cpp {
 
+    struct fmu_data {
+        logger *logger{nullptr};
+        std::string instance_name{};
+        std::filesystem::path resourceLocation{};
+    };
+
     class fmu_base {
 
     public:
-        fmu_base(std::string instance_name, std::filesystem::path resourceLocation)
-            : instanceName_(std::move(instance_name)), resourceLocation_(std::move(resourceLocation)) {
+        explicit fmu_base(fmu_data data)
+            : data_(std::move(data)) {
 
             register_variable(real("time", &time_)
                                       .setCausality(causality_t::INDEPENDENT)
@@ -39,11 +44,11 @@ namespace fmu4cpp {
         fmu_base(const fmu_base &&) = delete;
 
         [[nodiscard]] std::string instanceName() const {
-            return instanceName_;
+            return data_.instance_name;
         }
 
         [[nodiscard]] const std::filesystem::path &resourceLocation() const {
-            return resourceLocation_;
+            return data_.resourceLocation;
         }
 
         [[nodiscard]] std::optional<IntVariable> get_int_variable(const std::string &name) const {
@@ -200,13 +205,9 @@ namespace fmu4cpp {
 
         [[nodiscard]] std::string make_description_v3() const;
 
-        void __set_logger(logger *logger) {
-            logger_ = logger;
-        }
-
         void log(const fmiStatus s, const std::string &message) const {
-            if (logger_) {
-                logger_->log(s, message);
+            if (data_.logger) {
+                data_.logger->log(s, message);
             }
         }
 
@@ -265,15 +266,13 @@ namespace fmu4cpp {
         }
 
     private:
-        double time_{0};
-        std::optional<double> stop_;
-        std::optional<double> tolerance_;
+        fmu_data data_;
 
-        logger *logger_ = nullptr;
+        double time_{0};
         size_t numVariables_{0};
 
-        std::string instanceName_;
-        std::filesystem::path resourceLocation_;
+        std::optional<double> stop_;
+        std::optional<double> tolerance_;
 
         std::vector<IntVariable> integers_;
         std::unordered_map<unsigned int, size_t> vrToIntegerIndices_;
@@ -291,7 +290,7 @@ namespace fmu4cpp {
 
     model_info get_model_info();
 
-    std::unique_ptr<fmu_base> createInstance(const std::string &instanceName, const std::filesystem::path &fmuResourceLocation);
+    std::unique_ptr<fmu_base> createInstance(const fmu_data &data);
 
 }// namespace fmu4cpp
 

export/src/fmu4cpp/fmi2.cpp

@@ -51,16 +51,15 @@ namespace {
     // A struct that holds all the data for one model instance.
     struct Fmi2Component {
 
-        Fmi2Component(std::unique_ptr<fmu4cpp::fmu_base> slave, const fmi2CallbackFunctions *callbackFunctions)
+        Fmi2Component(std::unique_ptr<fmu4cpp::fmu_base> slave, std::unique_ptr<fmi2Logger> logger)
             : lastSuccessfulTime{std::numeric_limits<double>::quiet_NaN()},
               slave(std::move(slave)),
-              logger(std::make_unique<fmi2Logger>(this->slave->instanceName(), callbackFunctions)) {
-            this->slave->__set_logger(logger.get());
-        }
+              logger(std::move(logger)) {}
 
         double lastSuccessfulTime{0};
+
         std::unique_ptr<fmu4cpp::fmu_base> slave;
-        std::unique_ptr<fmu4cpp::logger> logger;
+        std::unique_ptr<fmi2Logger> logger;
 
         double start{0};
         std::optional<double> stop;
@@ -80,7 +79,7 @@ const char *fmi2GetVersion(void) {
 }
 
 FMI2_Export void write_description(const char *location) {
-    const auto instance = fmu4cpp::createInstance("", "");
+    const auto instance = fmu4cpp::createInstance({});
     const auto xml = instance->make_description_v2();
     std::ofstream of(location);
     of << xml;
@@ -117,18 +116,27 @@ fmi2Component fmi2Instantiate(fmi2String instanceName,
         resources.replace(0, 6 - magic, "");
     }
 
-    auto slave = fmu4cpp::createInstance(instanceName, resources);
+    auto logger = std::make_unique<fmi2Logger>(instanceName, functions);
+
+    auto slave = fmu4cpp::createInstance({logger.get(), instanceName, resources});
     const auto guid = slave->guid();
     if (guid != fmuGUID) {
         std::cerr << "[fmu4cpp] Error. Wrong guid!" << std::endl;
-        fmi2Logger l(instanceName, functions);
-        l.log(fmiFatal, "Error. Wrong guid!");
+        logger->log(fmiFatal, "Error. Wrong guid!");
         return nullptr;
     }
 
-    auto c = std::make_unique<Fmi2Component>(std::move(slave), functions);
-    c->logger->setDebugLogging(loggingOn);
-    return c.release();
+    try {
+        auto c = std::make_unique<Fmi2Component>(std::move(slave), std::move(logger));
+        c->logger->setDebugLogging(loggingOn);
+
+        return c.release();
+    } catch (const std::exception &e) {
+
+        logger->log(fmiFatal, "Unable to instantiate model! " + std::string(e.what()));
+
+        return nullptr;
+    }
 }
 
 fmi2Status fmi2SetupExperiment(fmi2Component c,

export/src/fmu4cpp/fmi3.cpp

@@ -57,17 +57,14 @@ namespace {
             Invalid = 1 << 4
         };
 
-        Fmi3Component(std::unique_ptr<fmu4cpp::fmu_base> slave, fmi3InstanceEnvironment env, fmi3LogMessageCallback logCallback)
+        Fmi3Component(std::unique_ptr<fmu4cpp::fmu_base> slave, std::unique_ptr<fmi3Logger> logger)
             : state(State::Instantiated),
               slave(std::move(slave)),
-              logger(std::make_unique<fmi3Logger>(env, logCallback, this->slave->instanceName())) {
-
-            this->slave->__set_logger(logger.get());
-        }
+              logger(std::move(logger)) { }
 
         State state;
         std::unique_ptr<fmu4cpp::fmu_base> slave;
-        std::unique_ptr<fmu4cpp::logger> logger;
+        std::unique_ptr<fmi3Logger> logger;
     };
 
 #define FMU_TYPE(type) fmi3##type
@@ -105,7 +102,7 @@ const char *fmi3GetVersion(void) {
 }
 
 FMI3_Export void write_description(const char *location) {
-    const auto instance = fmu4cpp::createInstance("", "");
+    const auto instance = fmu4cpp::createInstance({});
     const auto xml = instance->make_description_v3();
     std::ofstream of(location);
     of << xml;
@@ -175,24 +172,24 @@ fmi3Instance fmi3InstantiateCoSimulation(
         resources.replace(0, 6 - magic, "");
     }
 
-    auto slave = fmu4cpp::createInstance(instanceName, resources);
+    auto logger = std::make_unique<fmi3Logger>(instanceEnvironment, logMessage, instanceName);
+
+    auto slave = fmu4cpp::createInstance({logger.get(), instanceName, resources});
     const auto guid = slave->guid();
     if (guid != instantiationToken) {
         std::cerr << "[fmu4cpp] Error. Wrong guid!" << std::endl;
-        fmi3Logger l(instanceEnvironment, logMessage, instanceName);
-        l.log(fmiFatal, "Error. Wrong guid!");
+        logger->log(fmiFatal, "Error. Wrong guid!");
         return nullptr;
     }
 
     try {
-        auto c = std::make_unique<Fmi3Component>(std::move(slave), instanceEnvironment, logMessage);
+        auto c = std::make_unique<Fmi3Component>(std::move(slave), std::move(logger));
         c->logger->setDebugLogging(loggingOn);
 
         return c.release();
     } catch (const std::exception &e) {
 
-        fmi3Logger l(instanceEnvironment, logMessage, instanceName);
-        l.log(fmiFatal, "Unable to instantiate model! " + std::string(e.what()));
+        logger->log(fmiFatal, "Unable to instantiate model! " + std::string(e.what()));
 
         return nullptr;
     }

export/tests/array_test.cpp

@@ -13,8 +13,8 @@
 class Model : public fmu4cpp::fmu_base {
 
 public:
-    Model(const std::string &instanceName, const std::filesystem::path &resources)
-        : fmu_base(instanceName, resources), reals_(4) {
+    explicit Model(const fmu4cpp::fmu_data &data)
+        : fmu_base(data), reals_(4) {
 
         for (int i = 0; i < reals_.size(); i++) {
             register_variable(
@@ -58,7 +58,7 @@ void fmilogger(fmi2Component, fmi2String instanceName, fmi2Status status, fmi2St
 
 TEST_CASE("test_array") {
 
-    Model model("", "");
+    Model model({});
     const auto guid = model.guid();
 
     std::cout << model.make_description_v2() << std::endl;

export/tests/basic_test.cpp

@@ -7,8 +7,7 @@
 class Model : public fmu4cpp::fmu_base {
 
 public:
-    Model(const std::string &instanceName, const std::filesystem::path &resources)
-        : fmu_base(instanceName, resources) {
+    explicit Model(const fmu4cpp::fmu_data &data) : fmu_base(data) {
 
         register_variable(real("myReal", &real_)
                                   .setCausality(fmu4cpp::causality_t::OUTPUT));
@@ -55,7 +54,7 @@ FMU4CPP_INSTANTIATE(Model);
 
 TEST_CASE("basic_test") {
 
-    const auto instance = fmu4cpp::createInstance("", "");
+    const auto instance = fmu4cpp::createInstance({});
 
     double t = 0;
     const double dt = 0.1;

export/tests/identity_test.cpp

@@ -12,8 +12,7 @@
 class Model : public fmu4cpp::fmu_base {
 
 public:
-    Model(const std::string &instanceName, const std::filesystem::path &resources)
-        : fmu_base(instanceName, resources) {
+    explicit Model(const fmu4cpp::fmu_data &data) : fmu_base(data) {
 
         register_variable(integer("integerIn", &integer_)
                                   .setCausality(fmu4cpp::causality_t::INPUT)
@@ -159,7 +158,7 @@ void fmilogger(fmi2Component, fmi2String instanceName, fmi2Status status, fmi2St
 
 TEST_CASE("test_identity") {
 
-    Model model("", "");
+    Model model({});
     const auto guid = model.guid();
 
     const auto realIn = model.get_real_variable("realIn");