Add binary input

export/include/fmu4cpp/fmu_base.hpp

@@ -76,6 +76,13 @@ namespace fmu4cpp {
             return std::nullopt;
         }
 
+        [[nodiscard]] std::optional<BinaryVariable> get_binary_variable(const std::string &name) const {
+            for (const auto &v: binary_) {
+                if (v.name() == name) return v;
+            }
+            return std::nullopt;
+        }
+
         void enter_initialisation_mode(double start, std::optional<double> stop, std::optional<double> tolerance) {
             time_ = start;
             stop_ = stop;
@@ -196,6 +203,20 @@ namespace fmu4cpp {
             }
         }
 
+        void set_binary(const unsigned int vr[], size_t nvr, const size_t valueSizes[], const uint8_t* const value[]) {
+#ifdef FMI2
+            static_assert("set_binary not available for FMI2");
+#endif
+
+            for (unsigned i = 0; i < nvr; i++) {
+                const auto ref = vr[i];
+                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));
+            }
+        }
+
         [[nodiscard]] std::string guid() const;
 
         [[nodiscard]] std::string make_description() const;
@@ -246,10 +267,17 @@ 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(std::string)> &onChange = {});
+        BinaryVariable binary(const std::string &name,
+                              const std::function<std::string()> &getter,
+                              const std::optional<std::function<void(std::string)>> &setter = std::nullopt);
+
         void register_variable(IntVariable v);
         void register_variable(RealVariable v);
         void register_variable(BoolVariable v);
         void register_variable(StringVariable v);
+        void register_variable(BinaryVariable v);
+
 
         virtual void enter_initialisation_mode();
         virtual bool do_step(double dt) = 0;
@@ -283,6 +311,11 @@ namespace fmu4cpp {
         std::vector<StringVariable> strings_;
         std::vector<std::string> stringBuffer_;
         std::unordered_map<unsigned int, size_t> vrToStringIndices_;
+
+        std::vector<BinaryVariable> binary_;
+        std::vector<std::string> binaryBuffer_;
+        std::unordered_map<unsigned int, size_t> vrToBinaryIndices_;
+
     };
 
 

export/include/fmu4cpp/fmu_variable.hpp

@@ -263,7 +263,7 @@ namespace fmu4cpp {
             : Variable(name, vr, index, getter, setter) {}
     };
 
-    class StringVariable final : public Variable<std::string, StringVariable> {
+    class StringVariable : public Variable<std::string, StringVariable> {
 
     public:
         StringVariable(
@@ -279,6 +279,22 @@ namespace fmu4cpp {
             : Variable(name, vr, index, getter, setter) {}
     };
 
+    class BinaryVariable : public Variable<std::string, BinaryVariable> {
+
+    public:
+        BinaryVariable(
+                const std::string &name,
+                unsigned int vr, size_t index, std::string *ptr, const std::function<void(std::string)> &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)
+            : Variable(name, vr, index, getter, setter) {}
+    };
+
     bool requires_start(const VariableBase &v);
 
 }// namespace fmu4cpp

export/src/fmu4cpp/fmi3/fmi3.cpp

@@ -511,7 +511,7 @@ fmi3Status fmi3SetString(
 
 fmi3Status fmi3GetBinary(fmi3Instance c,
                          const fmi3ValueReference valueReferences[],
-                         size_t nValueReferences,
+                         size_t nvr,
                          size_t valueSizes[],
                          fmi3Binary values[],
                          size_t nValues) {
@@ -523,16 +523,25 @@ fmi3Status fmi3GetBinary(fmi3Instance c,
 }
 
 fmi3Status fmi3SetBinary(fmi3Instance c,
-                         const fmi3ValueReference valueReferences[],
-                         size_t nValueReferences,
+                         const fmi3ValueReference vr[],
+                         size_t nvr,
                          const size_t valueSizes[],
                          const fmi3Binary values[],
                          size_t nValues) {
 
     const auto component = static_cast<Fmi3Component *>(c);
-
-    component->logger->log(fmiError, "Unsupported function fmi3SetBinary");
-    return fmi3Error;
+    try {
+        component->slave->set_binary(vr, nvr, valueSizes, values);
+        return fmi3OK;
+    } catch (const fmu4cpp::fatal_error &ex) {
+        component->logger->log(fmiFatal, ex.what());
+        component->state = Fmi3Component::State::Invalid;
+        return fmi3Fatal;
+    } catch (const std::exception &ex) {
+        component->logger->log(fmiError, ex.what());
+        component->state = Fmi3Component::State::Terminated;
+        return fmi3Error;
+    }
 }
 
 NOT_IMPLEMENTED_SETTER(UInt8);

export/src/fmu4cpp/fmu_base.cpp

@@ -68,6 +68,16 @@ namespace fmu4cpp {
         return {name, vr, numVariables_, getter, setter};
     }
 
+    BinaryVariable fmu_base::binary(const std::string &name, std::string *ptr, const std::function<void(std::string)> &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) {
+        const auto vr = static_cast<unsigned int>(numVariables_++);
+        return {name, vr, numVariables_, getter, setter};
+    }
+
     void fmu_base::register_variable(IntVariable v) {
         integers_.emplace_back(std::move(v));
         vrToIntegerIndices_.emplace(v.value_reference(), integers_.size() - 1);
@@ -88,6 +98,11 @@ namespace fmu4cpp {
         vrToStringIndices_.emplace(v.value_reference(), strings_.size() - 1);
     }
 
+    void fmu_base::register_variable(BinaryVariable v) {
+        binary_.emplace_back(std::move(v));
+        vrToBinaryIndices_.emplace(v.value_reference(), binary_.size() - 1);
+    }
+
     [[maybe_unused]] std::string fmu_base::guid() const {
         const model_info info = get_model_info();
         const std::vector content{

export/tests/CMakeLists.txt

@@ -11,6 +11,7 @@ function(make_test fmi_version modelIdentifier sources)
     )
     target_include_directories(${target_name}
             PRIVATE
+            "${PROJECT_SOURCE_DIR}/export/tests/external"
             "${PROJECT_SOURCE_DIR}/export/include"
             "${PROJECT_SOURCE_DIR}/export/src"
     )