switch binary to std::vector<uint_8>

Author: markaren

export/include/fmu4cpp/fmu_base.hpp

@@ -213,7 +213,7 @@ namespace fmu4cpp {
                 const auto idx = vrToBinaryIndices_.at(ref);
                 const uint8_t *ptr = value[i];
                 const size_t len = valueSizes[i];
-                binary_[idx].set(std::string(reinterpret_cast<const char*>(ptr), len));
+                binary_[idx].set(std::vector(ptr, ptr + len));
             }
         }
 
@@ -267,10 +267,10 @@ namespace fmu4cpp {
                               const std::function<std::string()> &getter,
                               const std::optional<std::function<void(std::string)>> &setter = std::nullopt);
 
-        BinaryVariable binary(const std::string &name, std::string *ptr, const std::function<void()> &onChange = {});
+        BinaryVariable binary(const std::string &name, BinaryType *ptr, const std::function<void()> &onChange = {});
         BinaryVariable binary(const std::string &name,
-                              const std::function<std::string()> &getter,
-                              const std::optional<std::function<void(std::string)>> &setter = std::nullopt);
+                              const std::function<std::vector<uint8_t>()> &getter,
+                              const std::optional<std::function<void(std::vector<uint8_t>)>> &setter = std::nullopt);
 
         void register_variable(IntVariable v);
         void register_variable(RealVariable v);

export/include/fmu4cpp/fmu_variable.hpp

@@ -10,9 +10,12 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <cstdint>
 
 namespace fmu4cpp {
 
+    using BinaryType = std::vector<uint8_t>;
+
     enum class causality_t {
         PARAMETER,
         CALCULATED_PARAMETER,
@@ -279,19 +282,19 @@ namespace fmu4cpp {
             : Variable(name, vr, index, getter, setter) {}
     };
 
-    class BinaryVariable : public Variable<std::string, BinaryVariable> {
+    class BinaryVariable : public Variable<BinaryType, BinaryVariable> {
 
     public:
         BinaryVariable(
                 const std::string &name,
-                unsigned int vr, size_t index, std::string *ptr, const std::function<void()> &onChange)
+                unsigned int vr, size_t index, BinaryType *ptr, const std::function<void()> &onChange)
             : Variable(name, vr, index, ptr, onChange) {}
 
         BinaryVariable(
                 const std::string &name,
                 unsigned int vr, size_t index,
-                const std::function<std::string()> &getter,
-                const std::optional<std::function<void(std::string)>> &setter)
+                const std::function<BinaryType()> &getter,
+                const std::optional<std::function<void(BinaryType)>> &setter)
             : Variable(name, vr, index, getter, setter) {}
     };
 

export/src/fmu4cpp/fmu_base.cpp

@@ -68,12 +68,12 @@ namespace fmu4cpp {
         return {name, vr, numVariables_, getter, setter};
     }
 
-    BinaryVariable fmu_base::binary(const std::string &name, std::string *ptr, const std::function<void()> &onChange) {
+    BinaryVariable fmu_base::binary(const std::string &name, BinaryType *ptr, const std::function<void()> &onChange) {
         const auto vr = static_cast<unsigned int>(numVariables_++);
         return {name, vr, numVariables_, ptr, onChange};
     }
 
-    BinaryVariable fmu_base::binary(const std::string &name, const std::function<std::string()> &getter, const std::optional<std::function<void(std::string)>> &setter) {
+    BinaryVariable fmu_base::binary(const std::string &name, const std::function<BinaryType()> &getter, const std::optional<std::function<void(BinaryType)>> &setter) {
         const auto vr = static_cast<unsigned int>(numVariables_++);
         return {name, vr, numVariables_, getter, setter};
     }

export/tests/fmi3/binary_test.cpp

@@ -18,28 +18,36 @@ class Model : public fmu4cpp::fmu_base {
     FMU4CPP_CTOR(Model) {
 
         register_variable(binary("binaryIn", &binaryIn_).setCausality(fmu4cpp::causality_t::INPUT));
-        register_variable(real("numberOut", &numberOut_).setCausality(fmu4cpp::causality_t::OUTPUT));
+        register_variable(real("realOut", &realOut_).setCausality(fmu4cpp::causality_t::OUTPUT));
+        register_variable(integer("integerOut", &integerOut_).setCausality(fmu4cpp::causality_t::OUTPUT));
+        register_variable(string("stringOut", &stringOut_).setCausality(fmu4cpp::causality_t::OUTPUT));
 
         Model::reset();
     }
 
     bool do_step(double dt) override {
 
-        std::cout << binaryIn_ << std::endl;
         nlohmann::json j = nlohmann::json::from_msgpack(binaryIn_);
-        numberOut_ = j["number"];
+        realOut_ = j["real"];
+        integerOut_ = j["integer"];
+        stringOut_ = j["string"];
 
         return true;
     }
 
     void reset() override {
-        binaryIn_ = "";
-        numberOut_ = 0;
+        binaryIn_ = {};
+        realOut_ = 0;
+        integerOut_ = 0;
+        stringOut_ = "empty";
     }
 
 private:
-    std::string binaryIn_;
-    double numberOut_;
+    std::vector<uint8_t> binaryIn_;
+
+    double realOut_;
+    int integerOut_;
+    std::string stringOut_;
 };
 
 fmu4cpp::model_info fmu4cpp::get_model_info() {
@@ -70,10 +78,14 @@ TEST_CASE("test_binary") {
     REQUIRE(fmi3EnterInitializationMode(c, false, 0, 0, false, 0) == fmi3OK);
     REQUIRE(fmi3ExitInitializationMode(c) == fmi3OK);
 
-    double numberIn = 3.9;
+    double realIn = 3.9;
+    int integerIn = 42;
+    std::string stringIn = "hello";
 
     nlohmann::json j;
-    j["number"] = numberIn;
+    j["real"] = realIn;
+    j["integer"] = integerIn;
+    j["string"] = stringIn;
 
     const auto data = nlohmann::json::to_msgpack(j);
     const uint8_t *binaryPtr = data.data();
@@ -95,15 +107,24 @@ TEST_CASE("test_binary") {
     bool terminateSimulation;
     bool earlyReturn;
     double lastSucessfulTime;
-
     REQUIRE(fmi3DoStep(c, 0, 0.1, true, &eventhandlingNeeded, &terminateSimulation, &earlyReturn, &lastSucessfulTime) == fmi3OK);
 
 
-    fmi3ValueReference outVr = 2;
-    double numberOut;
-    fmi3GetFloat64(c, &outVr, 1, &numberOut, 1);
+    double realOut;
+    fmi3ValueReference realVr = 2;
+    CHECK(fmi3GetFloat64(c, &realVr, 1, &realOut, 1) == fmi3OK);
+
+    int integerOut;
+    fmi3ValueReference integerVr = 3;
+    CHECK(fmi3GetInt32(c, &integerVr, 1, &integerOut, 1) == fmi3OK);
+
+    fmi3String stringOut;
+    fmi3ValueReference stringVr = 4;
+    CHECK(fmi3GetString(c, &stringVr, 1, &stringOut, 1) == fmi3OK);
 
-    CHECK(numberOut == Catch::Approx(3.9));
+    CHECK(realOut == Catch::Approx(realIn));
+    CHECK(integerOut == integerIn);
+    CHECK(stringOut == stringIn);
 
     REQUIRE(fmi3Terminate(c) == fmi3OK);