pythonfmu3 0.3.3__tar.gz → 0.3.4__tar.gz

{pythonfmu3-0.3.3/pythonfmu3.egg-info → pythonfmu3-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonfmu3
-Version: 0.3.3
+Version: 0.3.4
 Summary: A lightweight framework that enables the packaging of Python3.x code as co-simulation FMUs.
 Home-page: https://github.com/stephensmith25/PythonFMU3
 Author: Stephen Smith

pythonfmu3-0.3.4/pythonfmu3/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.4"

{pythonfmu3-0.3.3 → pythonfmu3-0.3.4}/pythonfmu3/fmi3slave.py

@@ -183,8 +183,7 @@ class Fmi3SlaveBase(object):
         initial_unknown = list(
             filter(lambda v: (v.causality == Fmi3Causality.output and (v.initial in allowed_variability))
                               or v.causality == Fmi3Causality.calculatedParameter
-                              or v in continuous_state_derivatives and v.initial in allowed_variability
-                              or v.variability == Fmi3Variability.continuous and v.initial in allowed_variability and v.causality != Fmi3Causality.independent, self.vars.values())
+                              or v in continuous_state_derivatives and v.initial in allowed_variability, self.vars.values())
         )
 
         for v in outputs:
@@ -282,10 +281,13 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Int32):
-                refs.append(int(var.getter()))
+                if len(var.dimensions) == 0:
+                    refs.append(int(var.getter()))
+                else:
+                    refs.extend(map(int, var.getter()))
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Integer!"
+                    f"Variable with valueReference={vr} is not of type Int32!"
                 )
         return refs
     
@@ -294,7 +296,10 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, (Enumeration, Int64)):
-                refs.append(int(var.getter()))
+                if len(var.dimensions) == 0:
+                    refs.append(int(var.getter()))
+                else:
+                    refs.extend(map(int, var.getter()))
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type Int64!"
@@ -306,11 +311,14 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, UInt64):
-                val = var.getter()
-                refs.append(val if isinstance(val, ctypes.c_uint64) else ctypes.c_uint64(val))
+                if len(var.dimensions) == 0:
+                    val = var.getter()
+                    refs.append(ctypes.c_uint64(val) if not isinstance(val, ctypes.c_uint64) else val)
+                else:
+                    refs.extend(map(ctypes.c_uint64, var.getter()))
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type UInt64!"
+                    f"Variable with valueReference={vr} is not of type Uint64!"
                 )
         return refs
 
@@ -325,7 +333,7 @@ class Fmi3SlaveBase(object):
                     refs.extend(var.getter())
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Real!"
+                    f"Variable with valueReference={vr} is not of type Float64!"
                 )
         return refs
 
@@ -334,7 +342,11 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Boolean):
-                refs.append(bool(var.getter()))
+                if len(var.dimensions) == 0:
+                    refs.append(bool(var.getter()))
+                else:
+                    refs.extend(var.getter())
+            
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type Boolean!"
@@ -354,30 +366,48 @@ class Fmi3SlaveBase(object):
         return refs
 
     def set_int32(self, vrs: List[int], values: List[int]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Int32):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Integer!"
+                    f"Variable with valueReference={vr} is not of type Int32!"
                 )
                 
     def set_int64(self, vrs: List[int], values: List[int]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, (Enumeration, Int64)):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Integer!"
+                    f"Variable with valueReference={vr} is not of type Int64!"
                 )
 
     def set_uint64(self, vrs: List[int], values: List[int]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, UInt64):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type UInt64!"
@@ -396,14 +426,20 @@ class Fmi3SlaveBase(object):
                 offset += size
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Real!"
+                    f"Variable with valueReference={vr} is not of type Float64!"
                 )
 
     def set_boolean(self, vrs: List[int], values: List[bool]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Boolean):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type Boolean!"

{pythonfmu3-0.3.3 → pythonfmu3-0.3.4}/pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.cpp

@@ -66,7 +66,8 @@ void SlaveInstance::SetFloat64(
 void SlaveInstance::SetInt32(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    const FMIInt32 /*value*/[])
+    const FMIInt32 /*value*/[],
+    std::size_t nValues)
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to set nonexistent variable");
@@ -76,7 +77,8 @@ void SlaveInstance::SetInt32(
 void SlaveInstance::SetInt64(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    const FMIInt64 /*value*/[])
+    const FMIInt64 /*value*/[],
+    std::size_t nValues)
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to set nonexistent variable");
@@ -86,7 +88,8 @@ void SlaveInstance::SetInt64(
 void SlaveInstance::SetUInt64(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    const FMIUInt64 /*value*/[])
+    const FMIUInt64 /*value*/[],
+    std::size_t nValues)
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to set nonexistent variable");
@@ -97,7 +100,8 @@ void SlaveInstance::SetUInt64(
 void SlaveInstance::SetBoolean(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    const FMIBoolean /*value*/[])
+    const FMIBoolean /*value*/[],
+    std::size_t nValues)
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to set nonexistent variable");
@@ -108,7 +112,8 @@ void SlaveInstance::SetBoolean(
 void SlaveInstance::SetString(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    const FMIString /*value*/[])
+    const FMIString /*value*/[],
+    std::size_t nValues)
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to set nonexistent variable");
@@ -131,7 +136,8 @@ void SlaveInstance::GetFloat64(
 void SlaveInstance::GetInt32(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    FMIInt32 /*value*/[]) const
+    FMIInt32 /*value*/[],
+    std::size_t nValues) const
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to get nonexistent variable");
@@ -142,7 +148,8 @@ void SlaveInstance::GetInt32(
 void SlaveInstance::GetInt64(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    FMIInt64 /*value*/[]) const
+    FMIInt64 /*value*/[],
+    std::size_t nValues) const
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to get nonexistent variable");
@@ -153,7 +160,8 @@ void SlaveInstance::GetInt64(
 void SlaveInstance::GetUInt64(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    FMIUInt64 /*value*/[]) const
+    FMIUInt64 /*value*/[],
+    std::size_t nValues) const
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to get nonexistent variable");
@@ -164,7 +172,8 @@ void SlaveInstance::GetUInt64(
 void SlaveInstance::GetBoolean(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    FMIBoolean /*value*/[]) const
+    FMIBoolean /*value*/[],
+    std::size_t nValues) const
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to set nonexistent variable");
@@ -175,7 +184,8 @@ void SlaveInstance::GetBoolean(
 void SlaveInstance::GetString(
     const FMIValueReference /*vr*/[],
     std::size_t nvr,
-    FMIString /*value*/[]) const
+    FMIString /*value*/[],
+    std::size_t nValues) const
 {
     if (nvr != 0) {
         throw std::logic_error("Attempted to set nonexistent variable");

{pythonfmu3-0.3.3 → pythonfmu3-0.3.4}/pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.hpp

@@ -76,23 +76,28 @@ public:
     virtual void SetInt32(
         const FMIValueReference vr[],
         std::size_t nvr,
-        const FMIInt32 value[]);
+        const FMIInt32 value[],
+        std::size_t nValues);
     virtual void SetInt64(
         const FMIValueReference vr[],
         std::size_t nvr,
-        const FMIInt64 value[]);
+        const FMIInt64 value[],
+        std::size_t nValues);
     virtual void SetUInt64(
         const FMIValueReference vr[],
         std::size_t nvr,
-        const FMIUInt64 value[]);
+        const FMIUInt64 value[],
+        std::size_t nValues);
     virtual void SetBoolean(
         const FMIValueReference vr[],
         std::size_t nvr,
-        const FMIBoolean value[]);
+        const FMIBoolean value[],
+        std::size_t nValues);
     virtual void SetString(
         const FMIValueReference vr[],
         std::size_t nvr,
-        const FMIString value[]);
+        const FMIString value[],
+        std::size_t nValues);
 
     /* Called from fmi3GetXxx()/fmiGetXxx().
      * Throws std::logic_error by default.
@@ -105,23 +110,28 @@ public:
     virtual void GetInt32(
         const FMIValueReference vr[],
         std::size_t nvr,
-        FMIInt32 value[]) const;
+        FMIInt32 value[],
+        std::size_t nValues) const;
     virtual void GetInt64(
         const FMIValueReference vr[],
         std::size_t nvr,
-        FMIInt64 value[]) const;
+        FMIInt64 value[],
+        std::size_t nValues) const;
     virtual void GetUInt64(
         const FMIValueReference vr[],
         std::size_t nvr,
-        FMIUInt64 value[]) const;
+        FMIUInt64 value[],
+        std::size_t nValues) const;
     virtual void GetBoolean(
         const FMIValueReference vr[],
         std::size_t nvr,
-        FMIBoolean value[]) const;
+        FMIBoolean value[],
+        std::size_t nValues) const;
     virtual void GetString(
         const FMIValueReference vr[],
         std::size_t nvr,
-        FMIString value[]) const;
+        FMIString value[],
+        std::size_t nValues) const;
 
     // Called from fmi3DoStep()/fmiDoStep(). Must be implemented in model code.
     virtual FMIStatus DoStep(

{pythonfmu3-0.3.3 → pythonfmu3-0.3.4}/pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp

@@ -334,7 +334,7 @@ fmi3Status fmi3GetInt32(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->GetInt32(vr, nvr, values);
+        component->slave->GetInt32(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -354,7 +354,7 @@ fmi3Status fmi3GetInt64(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->GetInt64(vr, nvr, values);
+        component->slave->GetInt64(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -374,7 +374,7 @@ fmi3Status fmi3GetUInt64(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->GetUInt64(vr, nvr, values);
+        component->slave->GetUInt64(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -394,7 +394,7 @@ fmi3Status fmi3GetBoolean(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->GetBoolean(vr, nvr, values);
+        component->slave->GetBoolean(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -414,7 +414,7 @@ fmi3Status fmi3GetString(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->GetString(vr, nvr, values);
+        component->slave->GetString(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -455,7 +455,7 @@ fmi3Status fmi3SetInt32(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->SetInt32(vr, nvr, values);
+        component->slave->SetInt32(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -475,7 +475,7 @@ fmi3Status fmi3SetInt64(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->SetInt64(vr, nvr, values);
+        component->slave->SetInt64(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -495,7 +495,7 @@ fmi3Status fmi3SetUInt64(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->SetUInt64(vr, nvr, values);
+        component->slave->SetUInt64(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -515,7 +515,7 @@ fmi3Status fmi3SetBoolean(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->SetBoolean(vr, nvr, values);
+        component->slave->SetBoolean(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());
@@ -535,7 +535,7 @@ fmi3Status fmi3SetString(
 {
     const auto component = reinterpret_cast<Component*>(c);
     try {
-        component->slave->SetString(vr, nvr, values);
+        component->slave->SetString(vr, nvr, values, nValues);
         return fmi3OK;
     } catch (const cppfmu::FatalError& e) {
         component->logger.Log(fmi3Fatal, "", e.what());

{pythonfmu3-0.3.3 → pythonfmu3-0.3.4}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp

@@ -285,13 +285,16 @@ void PySlaveInstance::SetFloat64(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* values)
+void PySlaveInstance::SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("i", values[i]));
         }
 
@@ -306,13 +309,15 @@ void PySlaveInstance::SetInt32(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* values)
+void PySlaveInstance::SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("L", values[i]));
         }
 
@@ -327,13 +332,15 @@ void PySlaveInstance::SetInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* values)
+void PySlaveInstance::SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("K", values[i]));
         }
 
@@ -348,13 +355,15 @@ void PySlaveInstance::SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* values)
+void PySlaveInstance::SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, PyBool_FromLong(values[i]));
         }
 
@@ -369,13 +378,15 @@ void PySlaveInstance::SetBoolean(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* values)
+void PySlaveInstance::SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         PyObject* refs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("s", values[i]));
         }
 
@@ -413,9 +424,9 @@ void PySlaveInstance::GetFloat64(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* values) const
+void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -426,7 +437,7 @@ void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getInt32] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyList_GetItem(refs, i);
             values[i] = static_cast<cppfmu::FMIInt32>(PyLong_AsLong(value));
         }
@@ -435,9 +446,9 @@ void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* values) const
+void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -448,7 +459,7 @@ void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getInt64] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyList_GetItem(refs, i);
             values[i] = static_cast<cppfmu::FMIInt64>(PyLong_AsLongLong(value));
         }
@@ -457,9 +468,9 @@ void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* values) const
+void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -470,7 +481,7 @@ void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getUInt64] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* item = PyList_GetItem(refs, i);
             PyObject* value = PyObject_GetAttrString(item, "value");
             if (value && PyLong_Check(value))
@@ -484,9 +495,9 @@ void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* values) const
+void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -497,7 +508,7 @@ void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_
             handle_py_exception("[getBoolean] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyList_GetItem(refs, i);
             values[i] = PyObject_IsTrue(value);
         }
@@ -506,9 +517,9 @@ void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* values) const
+void PySlaveInstance::GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         clearStrBuffer();
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
@@ -520,7 +531,7 @@ void PySlaveInstance::GetString(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getString] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyUnicode_AsEncodedString(PyList_GetItem(refs, i), "utf-8", nullptr);
             values[i] = PyBytes_AsString(value);
             strBuffer.emplace_back(value);

{pythonfmu3-0.3.3 → pythonfmu3-0.3.4}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp

@@ -34,18 +34,18 @@ public:
         cppfmu::FMIFloat64& endOfStep) override;
 
     void SetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIFloat64* value, std::size_t nValues) override;
-    void SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* value) override;
-    void SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* value) override;
-    void SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* value) override;
-    void SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* value) override;
-    void SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* value) override;
+    void SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* value, std::size_t nValues) override;
+    void SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* value, std::size_t nValues) override;
+    void SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* value, std::size_t nValues) override;
+    void SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* value, std::size_t nValues) override;
+    void SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* value, std::size_t nValues) override;
 
     void GetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIFloat64* value, std::size_t nValues) const override;
-    void GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* value) const override;
-    void GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* value) const override;
-    void GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* value) const override;
-    void GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* value) const override;
-    void GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* value) const override;
+    void GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* value, std::size_t nValues) const override;
+    void GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* value, std::size_t nValues) const override;
+    void GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* value, std::size_t nValues) const override;
+    void GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* value, std::size_t nValues) const override;
+    void GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* value, std::size_t nValues) const override;
 
     void GetFMUstate(fmi3FMUState& State) override;
     void SetFMUstate(const fmi3FMUState& State) override;