fix merge issues with state saving branch

Author: restenb

include/cosim/algorithm/ecco_algorithm.hpp

@@ -70,6 +70,8 @@ class ecco_algorithm : public algorithm
     void setup(time_point startTime, std::optional<time_point> stopTime) override;
     void initialize() override;
     std::pair<duration, std::unordered_set<simulator_index>> do_step(time_point currentT) override;
+    serialization::node export_current_state() const override;
+    void import_state(const serialization::node& exportedState) override;
 
     /**
      * Adds a variable pair for the power residual calculation.

src/cosim/algorithm/ecco_algorithm.cpp

@@ -232,6 +232,16 @@ class ecco_algorithm::impl
         return {stepSizeTaken, std::move(finished)};
     }
 
+    serialization::node export_current_state() const
+    {
+        throw error(make_error_code(errc::unsupported_feature), "State saving not yet supported by the ECCO algorithm!");
+    }
+
+    void import_state([[maybe_unused]] const serialization::node& exportedState)
+    {
+        throw error(make_error_code(errc::unsupported_feature), "State saving not yet supported by the ECCO algorithm!");
+    }
+
     void get_energies()
     {
         for (std::size_t i = 0; i < energies_.size(); ++i) {
@@ -567,6 +577,16 @@ std::pair<duration, std::unordered_set<simulator_index>> ecco_algorithm::do_step
     return pimpl_->do_step(currentT);
 }
 
+serialization::node ecco_algorithm::export_current_state() const
+{
+    return pimpl_->export_current_state();
+}
+
+void ecco_algorithm::import_state(const serialization::node& exportedState)
+{
+    pimpl_->import_state(exportedState);
+}
+
 void ecco_algorithm::add_power_bond(cosim::variable_id input_a, cosim::variable_id output_a, cosim::variable_id input_b, cosim::variable_id output_b)
 {
     pimpl_->add_power_bond(input_a, output_a, input_b, output_b);

tests/mock_slave.hpp

@@ -38,7 +38,7 @@ class mock_slave : public cosim::slave
         std::function<double(cosim::time_point, cosim::duration, double)> realOp = nullptr,
         std::function<int(cosim::time_point, cosim::duration, int)> intOp = nullptr,
         std::function<bool(cosim::time_point, cosim::duration, bool)> boolOp = nullptr,
-        std::function<std::string(cosim::time_point,  cosim::duration, std::string_view)> stringOp = nullptr,
+        std::function<std::string(cosim::time_point, cosim::duration, std::string_view)> stringOp = nullptr,
         std::function<void(cosim::time_point, cosim::duration)> stepAction = nullptr)
         : realOp_(std::move(realOp))
         , intOp_(std::move(intOp))
@@ -71,7 +71,6 @@ class mock_slave : public cosim::slave
         return [op = std::move(timeIndependentOp)](cosim::time_point, cosim::duration, T... value) { return op(value...); };
     }
 
-
     cosim::model_description model_description() const override
     {
         cosim::model_description md;
@@ -106,7 +105,8 @@ class mock_slave : public cosim::slave
 
     cosim::step_result do_step(cosim::time_point currentT, cosim::duration deltaT) override
     {
-        if (stepAction_) stepAction_(currentT);
+        state_.currentStepSize = deltaT;
+        if (stepAction_) stepAction_(currentT, deltaT);
         state_.currentTime = currentT + deltaT;
         return cosim::step_result::complete;
     }
@@ -117,7 +117,7 @@ class mock_slave : public cosim::slave
     {
         for (std::size_t i = 0; i < variables.size(); ++i) {
             if (variables[i] == real_out_reference) {
-                values[i] = realOp_ ? realOp_(state_.currentTime, state_.realIn) : state_.realIn;
+                values[i] = realOp_ ? realOp_(state_.currentTime, state_.currentStepSize, state_.realIn) : state_.realIn;
             } else if (variables[i] == real_in_reference) {
                 values[i] = state_.realIn;
             } else {
@@ -132,7 +132,7 @@ class mock_slave : public cosim::slave
     {
         for (std::size_t i = 0; i < variables.size(); ++i) {
             if (variables[i] == integer_out_reference) {
-                values[i] = intOp_ ? intOp_(state_.currentTime, state_.intIn) : state_.intIn;
+                values[i] = intOp_ ? intOp_(state_.currentTime, state_.currentStepSize, state_.intIn) : state_.intIn;
             } else if (variables[i] == integer_in_reference) {
                 values[i] = state_.intIn;
             } else {
@@ -147,7 +147,7 @@ class mock_slave : public cosim::slave
     {
         for (std::size_t i = 0; i < variables.size(); ++i) {
             if (variables[i] == boolean_out_reference) {
-                values[i] = boolOp_ ? boolOp_(state_.currentTime, state_.boolIn) : state_.boolIn;
+                values[i] = boolOp_ ? boolOp_(state_.currentTime, state_.currentStepSize, state_.boolIn) : state_.boolIn;
             } else if (variables[i] == boolean_in_reference) {
                 values[i] = state_.boolIn;
             } else {
@@ -162,7 +162,7 @@ class mock_slave : public cosim::slave
     {
         for (std::size_t i = 0; i < variables.size(); ++i) {
             if (variables[i] == string_out_reference) {
-                values[i] = stringOp_ ? stringOp_(state_.currentTime, state_.stringIn) : state_.stringIn;
+                values[i] = stringOp_ ? stringOp_(state_.currentTime, state_.currentStepSize, state_.stringIn) : state_.stringIn;
             } else if (variables[i] == string_in_reference) {
                 values[i] = state_.stringIn;
             } else {
@@ -248,7 +248,8 @@ class mock_slave : public cosim::slave
     {
         const auto& ss = savedStates_.at(state);
         cosim::serialization::node es;
-        es.put("currentTime", ss.currentTime.time_since_epoch().count());
+        es.put("currentTime", cosim::to_double_time_point(ss.currentTime));
+        es.put("currentStepSize", cosim::to_double_duration(ss.currentStepSize, ss.currentTime));
         es.put("realIn", ss.realIn);
         es.put("intIn", ss.intIn);
         es.put("boolIn", ss.boolIn);
@@ -259,8 +260,8 @@ class mock_slave : public cosim::slave
     state_index import_state(const cosim::serialization::node& exportedState) override
     {
         state ss;
-        ss.currentTime = cosim::time_point(cosim::time_point::duration(
-            exportedState.get<cosim::time_point::rep>("currentTime")));
+        ss.currentTime = cosim::time_point(cosim::time_point::duration(exportedState.get<cosim::time_point::rep>("currentTime")));
+        ss.currentStepSize = cosim::to_duration(exportedState.get<double>("currentStepSize"));
         ss.realIn = exportedState.get<decltype(ss.realIn)>("realIn");
         ss.intIn = exportedState.get<decltype(ss.intIn)>("intIn");
         ss.boolIn = exportedState.get<decltype(ss.boolIn)>("boolIn");
@@ -279,6 +280,7 @@ class mock_slave : public cosim::slave
     struct state
     {
         cosim::time_point currentTime;
+        cosim::duration currentStepSize{1000};
 
         double realIn = 0.0;
         int intIn = 0;

tests/save_state_test.cpp

@@ -56,9 +56,10 @@ int main()
 
         auto resolver = cosim::default_model_uri_resolver();
         const auto config = cosim::load_osp_config(configPath, *resolver);
+        auto algorithm_cfg = std::get<cosim::fixed_step_algorithm_params>(config.algorithm_configuration);
         auto execution = cosim::execution(
             config.start_time,
-            std::make_shared<cosim::fixed_step_algorithm>(config.step_size));
+            std::make_shared<cosim::fixed_step_algorithm>(algorithm_cfg));
 
         const auto entityMaps = cosim::inject_system_structure(
             execution, config.system_structure, config.initial_values);
@@ -129,7 +130,7 @@ int main()
         std::vector<cosim::simulator_index> simulators;
         simulators.push_back(
             execution.add_slave(
-                std::make_unique<mock_slave>([](cosim::time_point t, double) {
+                std::make_unique<mock_slave>([](cosim::time_point t, [[maybe_unused]] cosim::duration d, double) {
                     return cosim::to_double_time_point(t);
                 }),
                 "clock"));