From 631acec7ac7e6cd3934d3d6aa0063dc939b30f47 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 15 Mar 2022 11:04:49 +0100
Subject: [PATCH 001/166] Set channel reference for outputs as well

---
 src/components/comp_fmu.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index 8496501..56ef4d2 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -435,6 +435,8 @@ static McxStatus Fmu2SetupChannelOut(ObjectContainer /* Fmu2Values */ * vals, Da
             channelName = ChannelInfoGetName(info);
         }
 
+        val->SetChannel(val, info->channel);
+
         if (val->val.type != info->type) {
             ChannelValueInit(&val->val, info->type);
         }

From 493d8f6b5c2dd855276677abb7139c9480b2a178 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 15 Mar 2022 11:09:02 +0100
Subject: [PATCH 002/166] Define info object for storing variable data from the
 model description

---
 src/fmu/Fmu2Value.c | 105 ++++++++++++++++++++++++++++++++++++++++++++
 src/fmu/Fmu2Value.h |  16 +++++++
 2 files changed, 121 insertions(+)

diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index 68b2779..aa15aaf 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -34,6 +34,106 @@ static Fmu2ValueData * Fmu2ValueDataCreate(Fmu2ValueData * data) {
 
 OBJECT_CLASS(Fmu2ValueData, Object);
 
+Fmu2VariableInfo * Fmu2VariableInfoMake(fmi2_import_variable_t * var) {
+    Fmu2VariableInfo * info = (Fmu2VariableInfo *)object_create(Fmu2VariableInfo);
+
+    if (info) {
+        fmi2_base_type_enu_t type = fmi2_import_get_variable_base_type(var);
+        ChannelValueData min = { 0 };
+        int minDefined = FALSE;
+        ChannelValueData max = { 0 };
+        int maxDefined = FALSE;
+
+        char * xmlDesc = fmi2_import_get_variable_description(var);
+        info->desc = mcx_string_copy(xmlDesc);
+        if (xmlDesc && !info->desc) {
+            goto cleanup;
+        }
+
+        switch (type) {
+            case fmi2_base_type_real:
+                info->type = CHANNEL_DOUBLE;
+                min.d = fmi2_import_get_real_variable_min(fmi2_import_get_variable_as_real(var));
+                minDefined = min.d != -DBL_MAX;
+                max.d = fmi2_import_get_real_variable_max(fmi2_import_get_variable_as_real(var));
+                maxDefined = max.d != DBL_MAX;
+                break;
+            case fmi2_base_type_int:
+                info->type = CHANNEL_INTEGER;
+                min.i = fmi2_import_get_integer_variable_min(fmi2_import_get_variable_as_integer(var));
+                minDefined = min.i != -INT_MIN;
+                max.i = fmi2_import_get_integer_variable_max(fmi2_import_get_variable_as_integer(var));
+                maxDefined = max.i != INT_MAX;
+                break;
+            case fmi2_base_type_enum:
+                info->type = CHANNEL_INTEGER;
+                min.i = fmi2_import_get_enum_variable_min(fmi2_import_get_variable_as_enum(var));
+                minDefined = min.i != -INT_MIN;
+                max.i = fmi2_import_get_enum_variable_max(fmi2_import_get_variable_as_enum(var));
+                maxDefined = max.i != INT_MAX;
+                break;
+            case fmi2_base_type_str:
+                info->type = CHANNEL_STRING;
+                break;
+            case fmi2_base_type_bool:
+                info->type = CHANNEL_BOOL;
+                break;
+            default:
+                info->type = CHANNEL_UNKNOWN;
+                break;
+        }
+
+        if (minDefined) {
+            info->min = (ChannelValueData *)mcx_calloc(1, sizeof(ChannelValueData));
+            if (!info->min) {
+                goto cleanup;
+            }
+            ChannelValueDataSetFromReference(info->min, info->type, &min);
+        }
+
+        if (maxDefined) {
+            info->max = (ChannelValueData*)mcx_calloc(1, sizeof(ChannelValueData));
+            if (!info->max) {
+                goto cleanup;
+            }
+            ChannelValueDataSetFromReference(info->max, info->type, &max);
+        }
+    }
+
+    return info;
+
+cleanup:
+    object_destroy(info);
+    return NULL;
+}
+
+static void Fmu2VariableInfoDestructor(Fmu2VariableInfo * info) {
+    if (info->min) {
+        ChannelValueDataDestructor(info->min, info->type);
+        mcx_free(info->min);
+    }
+    if (info->max) {
+        ChannelValueDataDestructor(info->max, info->type);
+        mcx_free(info->max);
+    }
+
+    if (info->desc) { mcx_free(info->desc); }
+}
+
+static Fmu2VariableInfo * Fmu2VariableInfoCreate(Fmu2VariableInfo * info) {
+    info->type = CHANNEL_UNKNOWN;
+
+    info->min = NULL;
+    info->max = NULL;
+
+    info->desc = NULL;
+
+    return info;
+}
+
+OBJECT_CLASS(Fmu2VariableInfo, Object);
+
+
 Fmu2ValueData * Fmu2ValueDataScalarMake(fmi2_import_variable_t * scalar) {
     Fmu2ValueData * data = (Fmu2ValueData *) object_create(Fmu2ValueData);
 
@@ -136,6 +236,7 @@ static void Fmu2ValueDestructor(Fmu2Value * v) {
         v->unit = NULL;
     }
     object_destroy(v->data);
+    object_destroy(v->info);
     ChannelValueDestructor(&v->val);
 }
 
@@ -148,6 +249,8 @@ static Fmu2Value * Fmu2ValueCreate(Fmu2Value * v) {
     v->unit = NULL;
     v->data = NULL;
     v->channel = NULL;
+    v->info = NULL;
+
     ChannelValueInit(&v->val, CHANNEL_UNKNOWN);
 
     return v;
@@ -174,6 +277,8 @@ Fmu2Value * Fmu2ValueScalarMake(const char * name, fmi2_import_variable_t * scal
     Fmu2ValueData * data = Fmu2ValueDataScalarMake(scalar);
     Fmu2Value * value = Fmu2ValueMake(name, data, unit, channel);
 
+    value->info = Fmu2VariableInfoMake(scalar);
+
     return value;
 }
 
diff --git a/src/fmu/Fmu2Value.h b/src/fmu/Fmu2Value.h
index 7664554..004b277 100644
--- a/src/fmu/Fmu2Value.h
+++ b/src/fmu/Fmu2Value.h
@@ -56,6 +56,21 @@ struct Fmu2ValueData {
 Fmu2ValueData * Fmu2ValueDataScalarMake(fmi2_import_variable_t * scalar);
 Fmu2ValueData * Fmu2ValueDataBinaryMake(fmi2_import_variable_t * hi, fmi2_import_variable_t * lo, fmi2_import_variable_t * size);
 
+
+extern const struct ObjectClass _Fmu2VariableInfo;
+
+typedef struct Fmu2VariableInfo {
+    Object _;
+
+    ChannelType type;
+
+    ChannelValueData * min;
+    ChannelValueData * max;
+
+    char * desc;
+} Fmu2VariableInfo;
+
+
 struct Fmu2Value;
 
 typedef struct Fmu2Value Fmu2Value;
@@ -78,6 +93,7 @@ struct Fmu2Value {
 
     Channel * channel;
     Fmu2ValueData * data;
+    Fmu2VariableInfo * info;
     ChannelValue val;
 };
 

From 056e751207a1cd67d7dae07919ae1eb618ea004c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 8 Apr 2022 14:38:51 +0200
Subject: [PATCH 003/166] Construct proxies to array parameters during read

---
 src/components/comp_fmu.c |  27 +++-----
 src/fmu/common_fmu2.c     | 136 +++++++++++++++++++++++++-------------
 src/fmu/common_fmu2.h     |   4 +-
 3 files changed, 101 insertions(+), 66 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index 56ef4d2..f58fc66 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -804,20 +804,17 @@ static McxStatus Fmu2Read(Component * comp, ComponentInput * input, const struct
         ParametersInput * parametersInput = input->parameters;
 
         if (parametersInput) {
-            vals = Fmu2ReadParams(parametersInput,
-                                  compFmu->fmu2.fmiImport,
-                                  NULL
+            retVal = Fmu2ReadParams(
+                fmu2->params,
+                fmu2->arrayParams,
+                parametersInput,
+                compFmu->fmu2.fmiImport,
+                NULL
             );
-            if (!vals) {
-                ComponentLog(comp, LOG_ERROR, "Could not read parameters");
-                return RETURN_ERROR;
-            }
-            retVal = fmu2->params->Append(fmu2->params, vals);
             if (RETURN_OK != retVal) {
-                ComponentLog(comp, LOG_ERROR, "Could not add parameters");
+                ComponentLog(comp, LOG_ERROR, "Could not read parameters");
                 return RETURN_ERROR;
             }
-            object_destroy(vals);
 
         }
     }
@@ -826,17 +823,11 @@ static McxStatus Fmu2Read(Component * comp, ComponentInput * input, const struct
         ParametersInput * parametersInput = input->initialValues;
 
         if (parametersInput) {
-            vals = Fmu2ReadParams(parametersInput, compFmu->fmu2.fmiImport, NULL);
-            if (!vals) {
-                ComponentLog(comp, LOG_ERROR, "Could not read initial values");
-                return RETURN_ERROR;
-            }
-            retVal = fmu2->initialValues->Append(fmu2->initialValues, vals);
+            retVal = Fmu2ReadParams(fmu2->initialValues, NULL, parametersInput, compFmu->fmu2.fmiImport, NULL);
             if (RETURN_OK != retVal) {
-                ComponentLog(comp, LOG_ERROR, "Could not add initial values");
+                ComponentLog(comp, LOG_ERROR, "Could not read initial values");
                 return RETURN_ERROR;
             }
-            object_destroy(vals);
         }
     }
 
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 2aaf9d7..181294e 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -93,6 +93,8 @@ McxStatus Fmu2CommonStructInit(Fmu2CommonStruct * fmu) {
     fmu->tunableParams = (ObjectContainer *) object_create(ObjectContainer);
     fmu->initialValues = (ObjectContainer *) object_create(ObjectContainer);
 
+    fmu->arrayParams = (ObjectContainer *) object_create(ObjectContainer);
+
     fmu->connectedIn = (ObjectContainer *) object_create(ObjectContainer);
 
     fmu->numLogCategories = 0;
@@ -243,6 +245,11 @@ void Fmu2CommonStructDestructor(Fmu2CommonStruct * fmu) {
         object_destroy(fmu->params);
     }
 
+    if (fmu->arrayParams) {
+        fmu->arrayParams->DestroyObjects(fmu->arrayParams);
+        object_destroy(fmu->arrayParams);
+    }
+
     if (fmu->initialValues) {
         fmu->initialValues->DestroyObjects(fmu->initialValues);
         object_destroy(fmu->initialValues);
@@ -451,98 +458,141 @@ static ObjectContainer* Fmu2ReadArrayParamValues(const char * name,
 }
 
 // Reads parameters from the input file (both scalar and array).
-//
+// If arrayParams is given, creates proxy views to array elements.
 // Ignores parameters provided via the `ignore` argument.
-ObjectContainer * Fmu2ReadParams(ParametersInput * input, fmi2_import_t * import, ObjectContainer * ignore) {
-    ObjectContainer * params = (ObjectContainer *) object_create(ObjectContainer);
-    ObjectContainer * ret = params;                  // used for unified cleanup via goto
+McxStatus Fmu2ReadParams(ObjectContainer * params, ObjectContainer * arrayParams, ParametersInput * input, fmi2_import_t * import, ObjectContainer * ignore) {
+    McxStatus retVal = RETURN_OK;
 
     size_t i = 0;
     size_t num = 0;
-    McxStatus retVal = RETURN_OK;
 
     if (!params) {
-        return NULL;
+        return RETURN_ERROR;
     }
 
     num = input->parameters->Size(input->parameters);
     for (i = 0; i < num; i++) {
         ParameterInput * parameterInput = (ParameterInput *) input->parameters->At(input->parameters, i);
-
         char * name = NULL;
-        Fmu2Value * val = NULL;
-        ObjectContainer * vals = NULL;
-
 
         name = mcx_string_copy(parameterInput->parameter.arrayParameter->name);
         if (!name) {
-            ret = NULL;
-            goto fmu2_read_params_for_cleanup;
+            retVal = RETURN_ERROR;
+            goto cleanup_0;
         }
 
         // ignore the parameter if it is in the `ignore` container
         if (ignore && ignore->GetNameIndex(ignore, name) >= 0) {
-            goto fmu2_read_params_for_cleanup;
+            goto cleanup_0;
         }
 
         if (parameterInput->type == PARAMETER_ARRAY) {
+            ObjectContainer * vals = NULL;
+            ArrayParameterProxy * proxy = NULL;
+            size_t j = 0;
+
             // read parameter dimensions (if any) - should only be defined for array parameters
             if (parameterInput->parameter.arrayParameter->numDims >=2 &&
                 parameterInput->parameter.arrayParameter->dims[1] &&
                 !parameterInput->parameter.arrayParameter->dims[0]) {
                 mcx_log(LOG_ERROR, "FMU: Array parameter %s: Missing definition for the first dimension "
                         "while the second dimension is defined.", parameterInput->parameter.arrayParameter->name);
-                ret = NULL;
-                goto fmu2_read_params_for_cleanup;
+                retVal = RETURN_ERROR;
+                goto cleanup_1;
             }
 
             // array - split it into scalars
             vals = Fmu2ReadArrayParamValues(name, parameterInput->parameter.arrayParameter, import, params);
             if (vals == NULL) {
                 mcx_log(LOG_ERROR, "FMU: Could not read array parameter %s", name);
-                ret = NULL;
-                goto fmu2_read_params_for_cleanup;
+                retVal = RETURN_ERROR;
+                goto cleanup_1;
+            }
+
+            if (arrayParams) {
+                // set up a proxy that will reference the individual scalars
+                proxy = (ArrayParameterProxy *) object_create(ArrayParameterProxy);
+                if (!proxy) {
+                    mcx_log(LOG_ERROR, "FMU: Creating an array proxy failed: No memory");
+                    retVal = RETURN_ERROR;
+                    goto cleanup_1;
+                }
+
+                retVal = proxy->Setup(proxy, name, parameterInput->parameter.arrayParameter->numDims, parameterInput->parameter.arrayParameter->dims);
+                if (RETURN_ERROR == retVal) {
+                    mcx_log(LOG_ERROR, "FMU Array parameter %s: Array proxy setup failed", name);
+                    goto cleanup_1;
+                }
             }
 
             // store the scalar values
-            size_t j = 0;
             for (j = 0; j < vals->Size(vals); j++) {
-                Object * v = vals->At(vals, j);
-                retVal = params->PushBackNamed(params, v, ((Fmu2Value*)v)->name);
+                Fmu2Value * v = (Fmu2Value *) vals->At(vals, j);
+                retVal = params->PushBackNamed(params, (Object *) v, v->name);
                 if (RETURN_OK != retVal) {
-                    ret = NULL;
-                    goto fmu2_read_params_for_cleanup;
+                    mcx_log(LOG_ERROR, "FMU: Adding element #%zu of parameter %s failed", j, name);
+                    goto cleanup_1;
+                }
+
+                vals->SetAt(vals, j, NULL);
+
+                if (arrayParams) {
+                    retVal = proxy->AddValue(proxy, v);
+                    if (RETURN_ERROR == retVal) {
+                        mcx_log(LOG_ERROR, "FMU: Adding proxy to element #%zu of parameter %s failed", j, name);
+                        goto cleanup_1;
+                    }
+                }
+            }
+
+            if (arrayParams) {
+                retVal = arrayParams->PushBackNamed(arrayParams, (Object *) proxy, proxy->GetName(proxy));
+                if (RETURN_ERROR == retVal) {
+                    mcx_log(LOG_ERROR, "FMU: Adding proxy for %s failed", name);
+                    goto cleanup_1;
+                }
+            }
+
+cleanup_1:
+            if (RETURN_ERROR == retVal) {
+                object_destroy(proxy);
+                if (vals) {
+                    vals->DestroyObjects(vals);
                 }
             }
 
             object_destroy(vals);
+
+            if (RETURN_ERROR == retVal) {
+                goto cleanup_0;
+            }
         } else {
+            Fmu2Value * val = NULL;
+
             // read the scalar value
             val = Fmu2ReadParamValue(parameterInput->parameter.scalarParameter, import);
             if (val == NULL) {
                 mcx_log(LOG_ERROR, "FMU: Could not read parameter value of parameter %s", name);
-                ret = NULL;
-                goto fmu2_read_params_for_cleanup;
+                retVal = RETURN_ERROR;
+                goto cleanup_2;
             }
 
             // store the read value
             retVal = params->PushBackNamed(params, (Object * ) val, name);
             if (RETURN_OK != retVal) {
-                ret = NULL;
-                goto fmu2_read_params_for_cleanup;
+                goto cleanup_2;
             }
-        }
 
-fmu2_read_params_for_cleanup:
-        if (name) { mcx_free(name); }
-        if (ret == NULL) {
-            if (val)  { object_destroy(val); }
-            if (vals) {
-                vals->DestroyObjects(vals);
-                object_destroy(vals);
+cleanup_2:
+            if (RETURN_ERROR == retVal) {
+                object_destroy(val);
             }
+        }
 
-            goto cleanup;
+cleanup_0:
+        if (name) { mcx_free(name); }
+        if (retVal == RETURN_ERROR) {
+            return RETURN_ERROR;
         }
     }
 
@@ -555,30 +605,22 @@ ObjectContainer * Fmu2ReadParams(ParametersInput * input, fmi2_import_t * import
             status = params->Sort(params, NaturalComp, NULL);
             if (RETURN_OK != status) {
                 mcx_log(LOG_ERROR, "FMU: Unable to sort parameters");
-                ret = NULL;
-                goto cleanup;
+                return RETURN_ERROR;
             }
 
             for (i = 0; i < n - 1; i++) {
                 Fmu2Value * a = (Fmu2Value *) params->At(params, i);
                 Fmu2Value * b = (Fmu2Value *) params->At(params, i + 1);
 
-                if (! strcmp(a->name, b->name)) {
+                if (!strcmp(a->name, b->name)) {
                     mcx_log(LOG_ERROR, "FMU: Duplicate definition of parameter %s", a->name);
-                    ret = NULL;
-                    goto cleanup;
+                    return RETURN_ERROR;
                 }
             }
         }
     }
 
-cleanup:
-    if (ret == NULL) {
-        params->DestroyObjects(params);
-        object_destroy(params);
-    }
-
-    return ret;
+    return retVal;
 }
 
 
diff --git a/src/fmu/common_fmu2.h b/src/fmu/common_fmu2.h
index 0f61179..024d2ee 100644
--- a/src/fmu/common_fmu2.h
+++ b/src/fmu/common_fmu2.h
@@ -30,7 +30,7 @@ struct Fmu2CommonStruct;
 
 typedef struct Fmu2CommonStruct Fmu2CommonStruct;
 
-ObjectContainer * Fmu2ReadParams(ParametersInput * input, fmi2_import_t * import, ObjectContainer * ignore);
+McxStatus Fmu2ReadParams(ObjectContainer * params, ObjectContainer * arrayParams, ParametersInput * input, fmi2_import_t * import, ObjectContainer * ignore);
 
 // TODO: rename all variablearrays to something better
 McxStatus Fmu2SetVariableArray(Fmu2CommonStruct * fmu, ObjectContainer * vals);
@@ -53,6 +53,8 @@ struct Fmu2CommonStruct {
     ObjectContainer * params;
     ObjectContainer * initialValues;
 
+    ObjectContainer * arrayParams;   // proxy views to array parameter elements (from params) (type: ArrayParameterProxy)
+
     ObjectContainer * connectedIn;
 
     ObjectContainer * localValues;

From 5c6e07d5c43aae9c816974e6ea2ecdc00a1cea3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 9 May 2022 15:11:05 +0200
Subject: [PATCH 004/166] Only take into account fully tunable maps/curves

---
 src/fmu/common_fmu2.c         | 2 +-
 src/objects/ObjectContainer.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 181294e..a6cb9ba 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -965,7 +965,7 @@ ObjectContainer * Fmu2ValueScalarListFromVarList(fmi2_import_variable_list_t * v
 
         Fmu2Value * value = Fmu2ValueScalarMake(name, var, NULL, NULL);
         if (value) {
-            list->PushBack(list, (Object *) value);
+            list->PushBackNamed(list, (Object *) value, name);
         } else {
             list->DestroyObjects(list);
             object_destroy(list);
diff --git a/src/objects/ObjectContainer.c b/src/objects/ObjectContainer.c
index 6e451a7..c7c9cdc 100644
--- a/src/objects/ObjectContainer.c
+++ b/src/objects/ObjectContainer.c
@@ -526,7 +526,7 @@ static ObjectContainer * ObjectContainerFilterCtx(ObjectContainer * container, f
     for (i = 0; i < container->size; i++) {
         Object * obj = container->At(container, i);
         if (predicate(obj, ctx)) {
-            filtered->PushBack(filtered, obj);
+            filtered->PushBackNamed(filtered, obj, container->GetElementName(container, i));
         }
     }
 

From bd270ab12d0b11a32196a8628090e2c24b44a390 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 10 May 2022 08:36:48 +0200
Subject: [PATCH 005/166] Add ParameterProxies

---
 src/CMakeLists.txt                     |   1 +
 src/core/parameters/ParameterProxies.c | 217 +++++++++++++++++++++++++
 src/core/parameters/ParameterProxies.h |  92 +++++++++++
 src/fmu/common_fmu2.c                  |   1 +
 4 files changed, 311 insertions(+)
 create mode 100644 src/core/parameters/ParameterProxies.c
 create mode 100644 src/core/parameters/ParameterProxies.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2de6bcc..5808f1e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -18,6 +18,7 @@ file(GLOB MCX_SRC_COMMON
     "core/channels/*.c" "core/channels/*.cpp"
     "core/connections/*.c" "core/connections/*.cpp"
     "core/connections/filters/*.c" "core/connections/filters/*.cpp"
+    "core/parameters/*.c" "core/parameters/*.cpp"
     "components/*.c" "components/*.cpp"
     "fmu/*.c" "fmu/*.cpp"
     "objects/*.c" "objects/*.cpp"
diff --git a/src/core/parameters/ParameterProxies.c b/src/core/parameters/ParameterProxies.c
new file mode 100644
index 0000000..107daae
--- /dev/null
+++ b/src/core/parameters/ParameterProxies.c
@@ -0,0 +1,217 @@
+/********************************************************************************
+ * Copyright (c) 2021 AVL List GmbH and others
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache Software License 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#include "core/parameters/ParameterProxies.h"
+#include "util/string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+static void ScalarParameterProxySetValue(ScalarParameterProxy * proxy, Fmu2Value * value) {
+    proxy->value_ = value;
+}
+
+static ChannelType ScalarParameterProxyGetType(ScalarParameterProxy * proxy) {
+    if (proxy->value_) {
+        return ChannelValueType(&proxy->value_->val);
+    }
+
+    return CHANNEL_UNKNOWN;
+}
+
+static Fmu2Value * ScalarParameterProxyGetValue(ScalarParameterProxy * proxy) {
+    return proxy->value_;
+}
+
+static void ScalarParameterProxyDestructor(ScalarParameterProxy * proxy) {
+    // don't destroy value as it is just a weak reference
+}
+
+static ScalarParameterProxy * ScalarParameterProxyCreate(ScalarParameterProxy * proxy) {
+    proxy->SetValue = ScalarParameterProxySetValue;
+    proxy->GetType = ScalarParameterProxyGetType;
+    proxy->GetValue = ScalarParameterProxyGetValue;
+
+    proxy->value_ = NULL;
+
+    return proxy;
+}
+
+OBJECT_CLASS(ScalarParameterProxy, Object);
+
+
+
+static McxStatus ArrayParameterProxyAddValue(ArrayParameterProxy * proxy, Fmu2Value * value) {
+    McxStatus retVal = RETURN_OK;
+
+    if (proxy->values_->Size(proxy->values_) > 0) {
+        Fmu2Value * val = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
+
+        // check that data types match
+        if (ChannelValueType(&val->val) != ChannelValueType(&value->val)) {
+            mcx_log(LOG_ERROR, "Adding value of '%s' to array proxy '%s' failed: Data type mismatch", value->name, proxy->name_);
+            return RETURN_ERROR;
+        }
+
+        // check that units match
+        if (!val->unit && value->unit || val->unit && !value->unit || val->unit && value->unit && strcmp(val->unit, value->unit) != 0) {
+            mcx_log(LOG_ERROR, "Adding value of '%s' to array proxy '%s' failed: Unit mismatch", value->name, proxy->name_);
+            return RETURN_ERROR;
+        }
+    }
+
+    // add the value to the internal container
+    retVal = proxy->values_->PushBackNamed(proxy->values_, (Object *)value, value->name);
+    if (retVal == RETURN_ERROR) {
+        mcx_log(LOG_ERROR, "Adding value of '%s' to array proxy '%s' failed", value->name, proxy->name_);
+        return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus ArrayParameterProxySetup(ArrayParameterProxy * proxy, const char * name, size_t numDims, size_t * dims) {
+    proxy->name_ = mcx_string_copy(name);
+    if (name && !proxy->name_) {
+        mcx_log(LOG_ERROR, "Array proxy setup failed: Not enough memory");
+        return RETURN_ERROR;
+    }
+
+    proxy->numDims_ = numDims;
+    proxy->dims_ = (size_t *)mcx_calloc(numDims, sizeof(size_t));
+    if (!proxy->dims_) {
+        mcx_log(LOG_ERROR, "Array proxy setup failed: Not enough memory");
+        return RETURN_ERROR;
+    }
+
+    memcpy((void *)proxy->dims_, (void *)dims, numDims * sizeof(size_t));
+
+    return RETURN_OK;
+}
+
+static const char * ArrayParameterProxyGetName(ArrayParameterProxy * proxy) {
+    return proxy->name_;
+}
+
+static const char * ArrayParameterProxyGetDesc(ArrayParameterProxy * proxy) {
+    if (proxy->values_->Size(proxy->values_) > 0) {
+        Fmu2Value * value = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
+        return value->info->desc;
+    }
+
+    return NULL;
+}
+
+static const char * ArrayParameterProxyGetUnit(ArrayParameterProxy * proxy) {
+    if (proxy->values_->Size(proxy->values_) > 0) {
+        Fmu2Value * value = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
+        return value->unit;
+    }
+
+    return NULL;
+}
+
+static ObjectContainer * ArrayParameterProxyGetValues(ArrayParameterProxy * proxy) {
+    return proxy->values_;
+}
+
+static size_t ArrayParameterProxyGetNumDims(ArrayParameterProxy * proxy) {
+    return proxy->numDims_;
+}
+
+static size_t ArrayParameterProxyGetDim(ArrayParameterProxy * proxy, size_t idx) {
+    if (idx >= proxy->numDims_) {
+        return (size_t)(-1);
+    }
+
+    return proxy->dims_[idx];
+}
+
+static ChannelType ArrayParameterProxyGetType(ArrayParameterProxy * proxy) {
+    if (proxy->values_->Size(proxy->values_) > 0) {
+        Fmu2Value * value = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
+        return ChannelValueType(&value->val);
+    }
+
+    return CHANNEL_UNKNOWN;
+}
+
+static void ArrayParameterProxyDestructor(ArrayParameterProxy * proxy) {
+    if (proxy->name_) { mcx_free(proxy->name_); }
+    if (proxy->dims_) { mcx_free(proxy->dims_); }
+
+    proxy->numDims_ = 0;
+
+    // don't destroy the contained objects as they are just weak references
+    object_destroy(proxy->values_);
+}
+
+static fmi2_value_reference_t ArrayParameterProxyGetValueReference(ArrayParameterProxy * proxy, size_t idx) {
+    if (idx < proxy->values_->Size(proxy->values_)) {
+        Fmu2Value * value = (Fmu2Value *)proxy->values_->At(proxy->values_, idx);
+        return value->data->vr.scalar;
+    }
+
+    return (fmi2_value_reference_t)(-1);;
+}
+
+static ChannelValueData * ArrayParameterProxyGetMin(ArrayParameterProxy * proxy) {
+    if (proxy->values_->Size(proxy->values_) > 0) {
+        Fmu2Value * value = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
+        return value->info->min;
+    }
+
+    return NULL;
+}
+
+static ChannelValueData * ArrayParameterProxyGetMax(ArrayParameterProxy * proxy) {
+    if (proxy->values_->Size(proxy->values_) > 0) {
+        Fmu2Value * value = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
+        return value->info->max;
+    }
+
+    return NULL;
+}
+
+static ArrayParameterProxy * ArrayParameterProxyCreate(ArrayParameterProxy * proxy) {
+    proxy->Setup = ArrayParameterProxySetup;
+    proxy->AddValue = ArrayParameterProxyAddValue;
+
+    proxy->GetName = ArrayParameterProxyGetName;
+    proxy->GetDesc = ArrayParameterProxyGetDesc;
+    proxy->GetUnit = ArrayParameterProxyGetUnit;
+    proxy->GetValues = ArrayParameterProxyGetValues;
+    proxy->GetDim = ArrayParameterProxyGetDim;
+    proxy->GetNumDims = ArrayParameterProxyGetNumDims;
+    proxy->GetType = ArrayParameterProxyGetType;
+    proxy->GetValueReference = ArrayParameterProxyGetValueReference;
+    proxy->GetMin = ArrayParameterProxyGetMin;
+    proxy->GetMax = ArrayParameterProxyGetMax;
+
+    proxy->values_ = (ObjectContainer *)object_create(ObjectContainer);
+    if (!proxy->values_) {
+        return NULL;
+    }
+
+    proxy->name_ = NULL;
+    proxy->dims_ = NULL;
+    proxy->numDims_ = 0;
+
+    return proxy;
+}
+
+OBJECT_CLASS(ArrayParameterProxy, Object);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/parameters/ParameterProxies.h b/src/core/parameters/ParameterProxies.h
new file mode 100644
index 0000000..3d96aec
--- /dev/null
+++ b/src/core/parameters/ParameterProxies.h
@@ -0,0 +1,92 @@
+/********************************************************************************
+ * Copyright (c) 2021 AVL List GmbH and others
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache Software License 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef MCX_CORE_PARAMETERS_PARAMETER_PROXIES_H
+#define MCX_CORE_PARAMETERS_PARAMETER_PROXIES_H
+
+#include "CentralParts.h"
+
+#include "fmu/Fmu2Value.h"
+#include "objects/ObjectContainer.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+struct ScalarParameterProxy;
+typedef struct ScalarParameterProxy ScalarParameterProxy;
+
+typedef void (*fScalarParameterProxySetValue)(ScalarParameterProxy * proxy, Fmu2Value * value);
+typedef ChannelType (*fScalarParameterProxyGetType)(ScalarParameterProxy * proxy);
+typedef Fmu2Value * (*fScalarParameterProxyGetValue)(ScalarParameterProxy * proxy);
+
+extern const struct ObjectClass _ScalarParameterProxy;
+
+struct ScalarParameterProxy {
+    Object _;
+
+    fScalarParameterProxySetValue SetValue;
+    fScalarParameterProxyGetType GetType;
+    fScalarParameterProxyGetValue GetValue;
+
+    Fmu2Value * value_;
+};
+
+
+struct ArrayParameterProxy;
+typedef struct ArrayParameterProxy ArrayParameterProxy;
+
+typedef McxStatus(*fArrayParameterProxyAddValue)(ArrayParameterProxy * proxy, Fmu2Value * value);
+typedef McxStatus(*fArrayParameterProxySetup)(ArrayParameterProxy * proxy, const char * name, size_t numDims, size_t * dims);
+typedef const char * (*fArrayParameterProxyGetName)(ArrayParameterProxy * proxy);
+typedef const char * (*fArrayParameterProxyGetDesc)(ArrayParameterProxy * proxy);
+typedef const char * (*fArrayParameterProxyGetUnit)(ArrayParameterProxy * proxy);
+typedef size_t (*fArrayParameterProxyGetNumDims)(ArrayParameterProxy * proxy);
+typedef size_t (*fArrayParameterProxyGetDim)(ArrayParameterProxy * proxy, size_t idx);
+typedef ObjectContainer * (*fArrayParameterProxyGetValues)(ArrayParameterProxy * proxy);
+typedef ChannelType (*fArrayParameterProxyGetType)(ArrayParameterProxy * proxy);
+typedef fmi2_value_reference_t (*fArrayParameterProxyGetValueReference)(ArrayParameterProxy * proxy, size_t idx);
+typedef ChannelValueData * (*fArrayParameterProxyGetMin)(ArrayParameterProxy * proxy);
+typedef ChannelValueData * (*fArrayParameterProxyGetMax)(ArrayParameterProxy * proxy);
+
+extern const struct ObjectClass _ArrayParameterProxy;
+
+struct ArrayParameterProxy {
+    Object _;
+
+    fArrayParameterProxySetup Setup;
+    fArrayParameterProxyAddValue AddValue;
+    fArrayParameterProxyGetValues GetValues;
+    fArrayParameterProxyGetName GetName;
+    fArrayParameterProxyGetDesc GetDesc;
+    fArrayParameterProxyGetUnit GetUnit;
+    fArrayParameterProxyGetNumDims GetNumDims;
+    fArrayParameterProxyGetDim GetDim;
+    fArrayParameterProxyGetType GetType;
+    fArrayParameterProxyGetValueReference GetValueReference;
+    fArrayParameterProxyGetMin GetMin;
+    fArrayParameterProxyGetMax GetMax;
+
+    size_t numDims_;
+    size_t * dims_;
+
+    char * name_;
+
+    ObjectContainer * values_;       // of Fmu2Value
+};
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* MCX_CORE_PARAMETERS_PARAMETER_PROXIES_H */
\ No newline at end of file
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index a6cb9ba..f0c39d4 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -14,6 +14,7 @@
 #include "fmu/Fmu2Value.h"
 
 #include "core/channels/ChannelInfo.h"
+#include "core/parameters/ParameterProxies.h"
 
 #include "reader/model/parameters/ArrayParameterDimensionInput.h"
 #include "reader/model/parameters/ParameterInput.h"

From 2d03c7aa78d0d367e253683343b1dca53c4e59bd Mon Sep 17 00:00:00 2001
From: Klaus Schuch <klaus.schuch@avl.com>
Date: Fri, 3 Jun 2022 17:33:33 +0200
Subject: [PATCH 006/166] Component: Distinguish error/warning in DoStep

---
 src/core/Component.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/core/Component.c b/src/core/Component.c
index a533d95..5c595ac 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -507,9 +507,11 @@ McxStatus ComponentDoStep(Component * comp, size_t group, double time, double de
         retVal = comp->DoStep(comp, group, time, deltaTime, endTime, isNewStep);
         mcx_signal_handler_unset_function();
         mcx_signal_handler_unset_name();
-        if (RETURN_OK != retVal) {
-            ComponentLog(comp, LOG_DEBUG, "Component specific DoStep failed");
+        if (RETURN_ERROR == retVal) {
+            ComponentLog(comp, LOG_ERROR, "Component specific DoStep failed");
             return RETURN_ERROR;
+        } else if (RETURN_WARNING == retVal) {
+            ComponentLog(comp, LOG_DEBUG, "Component specific DoStep returned with a warning");
         }
     }
 

From 08da9f98c0b081195bc25ca3bd02c5ee32a5530c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 4 Jul 2022 09:21:09 +0200
Subject: [PATCH 007/166] results: Make CSV component files resettable

---
 src/storage/StorageBackendCsv.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/storage/StorageBackendCsv.c b/src/storage/StorageBackendCsv.c
index 61eaf26..f5bdef4 100644
--- a/src/storage/StorageBackendCsv.c
+++ b/src/storage/StorageBackendCsv.c
@@ -185,19 +185,21 @@ static char * QuoteString(const char * _str) {
 static McxStatus SetupComponentFilesCsv(StorageBackend * backend) {
     StorageBackendText * textBackend = (StorageBackendText *) backend;
     ResultsStorage * storage = backend->storage;
-    char * buffer = NULL;
     size_t compIdx = 0;
+    size_t numCompsOld = textBackend->numComponents;
 
-    if (textBackend->numComponents > 0) {
-        mcx_log(LOG_ERROR, "Results: Re-setting up backend");
+    MCX_DEBUG_LOG("Setting up component CSV files (%zu -> %zu)", numCompsOld, storage->numComponents);
+    textBackend->numComponents = storage->numComponents;
+    textBackend->comps = (TextComponent *) mcx_realloc(textBackend->comps, textBackend->numComponents * sizeof(TextComponent));
+    if (textBackend->numComponents && !textBackend->comps) {
+        mcx_log(LOG_ERROR, "SetupComponentFilesCsv: TextComponents: Not enough memory");
         return RETURN_ERROR;
     }
 
-    /* calloc is used for implicit initialization of textBackend->comps */
-    textBackend->numComponents = storage->numComponents;
-    textBackend->comps = (TextComponent *) mcx_calloc(textBackend->numComponents, sizeof(TextComponent));
+    // initialize new TextComponents to 0
+    memset(textBackend->comps + numCompsOld, 0, (textBackend->numComponents - numCompsOld) * sizeof(TextComponent));
 
-    for (compIdx = 0; compIdx < textBackend->numComponents; compIdx++) {
+    for (compIdx = numCompsOld; compIdx < textBackend->numComponents; compIdx++) {
         ComponentStorage * compStore = storage->componentStorage[compIdx];
         Component * comp = (Component *) compStore->comp;
         TextComponent * textComponent = &(textBackend->comps[compIdx]);
@@ -216,6 +218,7 @@ static McxStatus SetupComponentFilesCsv(StorageBackend * backend) {
             ChannelStorage * chStore = compStore->channels[j];
             size_t chNum = chStore->GetChannelNum(chStore);
             size_t chIdx = 0;
+            char * buffer = NULL;
             const size_t nameLen = strlen(localName) + strlen(ChannelStoreSuffix[j]) + 6;
 
             /* do not create a file if channel store is not enabled */
@@ -281,6 +284,7 @@ static McxStatus SetupComponentFilesCsv(StorageBackend * backend) {
         }
         mcx_free(localName);
     }
+
     return RETURN_OK;
 }
 

From d777f0b35cd66acba3ef0fa94c5fc1463deb05ed Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 5 Jul 2021 12:21:51 +0200
Subject: [PATCH 008/166] channel: Add return value to SetFromReference

---
 src/components/comp_constant.c                | 12 +++++++---
 src/core/Conversion.c                         |  4 +++-
 src/core/Databus.c                            | 24 ++++++++++++++-----
 src/core/channels/Channel.c                   | 16 +++++++++----
 src/core/channels/ChannelValue.c              | 20 +++++++++-------
 src/core/channels/ChannelValue.h              |  4 ++--
 src/core/connections/Connection.c             |  8 +++++--
 src/core/connections/Connection.h             |  2 +-
 src/core/connections/FilteredConnection.c     | 16 +++++++++----
 src/core/connections/FilteredConnection.h     |  2 +-
 src/core/connections/filters/DiscreteFilter.c |  4 +++-
 src/fmu/Fmu2Value.c                           |  4 +++-
 src/fmu/common_fmu1.c                         | 16 +++++++++----
 src/fmu/common_fmu2.c                         | 22 +++++++++++++----
 src/reader/model/ports/ScalarPortInput.c      | 24 ++++++++++++++-----
 src/storage/ChannelStorage.c                  |  4 +++-
 16 files changed, 131 insertions(+), 51 deletions(-)

diff --git a/src/components/comp_constant.c b/src/components/comp_constant.c
index 95daef9..1825b67 100644
--- a/src/components/comp_constant.c
+++ b/src/components/comp_constant.c
@@ -38,7 +38,10 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
             if (value->type == CONSTANT_VALUE_SCALAR) {
                 compConstant->values[i] = (ChannelValue *)mcx_calloc(1, sizeof(ChannelValue));
                 ChannelValueInit(compConstant->values[i], value->value.scalar->type);
-                ChannelValueSetFromReference(compConstant->values[i], &value->value.scalar->value);
+                if (RETURN_OK != ChannelValueSetFromReference(compConstant->values[i], &value->value.scalar->value)) {
+                    ComponentLog(comp, LOG_ERROR, "Could not set channel value");
+                    return RETURN_ERROR;
+                }
             } else {
                 size_t j = 0;
                 size_t size = ChannelValueTypeSize(value->value.array->type);
@@ -46,8 +49,11 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
                                                                      sizeof(ChannelValue));
                 for (j = 0; j < value->value.array->numValues; j++) {
                     ChannelValueInit(compConstant->values[i] + j, value->value.array->type);
-                    ChannelValueSetFromReference(compConstant->values[i] + j,
-                                                 (char *)value->value.array->values + j * size);
+                    if (RETURN_OK != ChannelValueSetFromReference(compConstant->values[i] + j,
+                                                                  (char *)value->value.array->values + j * size)) {
+                        ComponentLog(comp, LOG_ERROR, "Could not set channel value");
+                        return RETURN_ERROR;
+                    }
                 }
             }
         }
diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 886def6..a684987 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -273,7 +273,9 @@ static McxStatus UnitConversionConvert(Conversion * conversion, ChannelValue * v
     val = (val + unitConversion->source.offset) * unitConversion->source.factor;
     val = (val / unitConversion->target.factor) - unitConversion->target.offset;
 
-    ChannelValueSetFromReference(value, &val);
+    if (RETURN_OK != ChannelValueSetFromReference(value, &val)) {
+        return RETURN_ERROR;
+    }
 
     return RETURN_OK;
 }
diff --git a/src/core/Databus.c b/src/core/Databus.c
index 74efc5b..d3901a9 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -322,7 +322,9 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         ChannelValueInit(&value, expectedType);
 
         if (scalarPortInput->min.defined) {
-            ChannelValueSetFromReference(&value, &scalarPortInput->min.value);
+            if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->min.value)) {
+                goto cleanup_else_1;
+            }
             info.min = ChannelValueClone(&value);
             if (!info.min) {
                 goto cleanup_else_1;
@@ -330,7 +332,9 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         }
 
         if (scalarPortInput->max.defined) {
-            ChannelValueSetFromReference(&value, &scalarPortInput->max.value);
+            if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->max.value)) {
+                goto cleanup_else_1;
+            }
             info.max = ChannelValueClone(&value);
             if (!info.max) {
                 goto cleanup_else_1;
@@ -338,7 +342,9 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         }
 
         if (scalarPortInput->scale.defined) {
-            ChannelValueSetFromReference(&value, &scalarPortInput->scale.value);
+            if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->scale.value)) {
+                goto cleanup_else_1;
+            }
             info.scale = ChannelValueClone(&value);
             if (!info.scale) {
                 goto cleanup_else_1;
@@ -346,7 +352,9 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         }
 
         if (scalarPortInput->offset.defined) {
-            ChannelValueSetFromReference(&value, &scalarPortInput->offset.value);
+            if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->offset.value)) {
+                goto cleanup_else_1;
+            }
             info.offset = ChannelValueClone(&value);
             if (!info.offset) {
                 goto cleanup_else_1;
@@ -354,7 +362,9 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         }
 
         if (scalarPortInput->default_.defined) {
-            ChannelValueSetFromReference(&value, &scalarPortInput->default_.value);
+            if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->default_.value)) {
+                goto cleanup_else_1;
+            }
             info.defaultValue = ChannelValueClone(&value);
             if (!info.defaultValue) {
                 goto cleanup_else_1;
@@ -362,7 +372,9 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         }
 
         if (scalarPortInput->initial.defined) {
-            ChannelValueSetFromReference(&value, &scalarPortInput->initial.value);
+            if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->initial.value)) {
+                goto cleanup_else_1;
+            }
             info.initialValue = ChannelValueClone(&value);
             if (!info.initialValue) {
                 goto cleanup_else_1;
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 6d656d8..a17b147 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -185,8 +185,12 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         ChannelValueInit(val, ConnectionInfoGetType(connInfo));
 
         /* Update the connection for the current time */
-        conn->UpdateToOutput(conn, time);
-        ChannelValueSetFromReference(val, conn->GetValueReference(conn));
+        if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
+            return RETURN_ERROR;
+        }
+        if (RETURN_OK != ChannelValueSetFromReference(val, conn->GetValueReference(conn))) {
+            return RETURN_ERROR;
+        }
 
         //type
         if (in->data->typeConversion) {
@@ -759,7 +763,9 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
                 MCX_DEBUG_LOG("[%f] CH OUT (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, val);
             }
 #endif // MCX_DEBUG
-            ChannelValueSetFromReference(&channel->value, &val);
+            if (RETURN_OK != ChannelValueSetFromReference(&channel->value, &val)) {
+                return RETURN_ERROR;
+            }
         } else {
 #ifdef MCX_DEBUG
             if (time->startTime < MCX_DEBUG_LOG_TIME) {
@@ -774,7 +780,9 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
                 }
             }
 #endif // MCX_DEBUG
-            ChannelValueSetFromReference(&channel->value, channel->internalValue);
+            if (RETURN_OK != ChannelValueSetFromReference(&channel->value, channel->internalValue)) {
+                return RETURN_ERROR;
+            }
         }
 
         // Apply conversion
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 2c4cc8c..7ec6d04 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -233,8 +233,8 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType type) {
     }
 }
 
-void ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference) {
-    if (!reference) { return; }
+McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference) {
+    if (!reference) { return RETURN_OK; } // TODO: change to ERROR
 
     switch (type) {
     case CHANNEL_DOUBLE:
@@ -279,12 +279,12 @@ void ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type,
     default:
         break;
     }
-}
 
-void ChannelValueSetFromReference(ChannelValue * value, const void * reference) {
-    if (!reference) { return; }
+    return RETURN_OK;
+}
 
-    ChannelValueDataSetFromReference(&value->value, value->type, reference);
+McxStatus ChannelValueSetFromReference(ChannelValue * value, const void * reference) {
+    return ChannelValueDataSetFromReference(&value->value, value->type, reference);
 }
 
 McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
@@ -294,7 +294,9 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
         return RETURN_ERROR;
     }
 
-    ChannelValueSetFromReference(value, ChannelValueReference((ChannelValue *) source));
+    if (RETURN_OK != ChannelValueSetFromReference(value, ChannelValueReference((ChannelValue *) source))) {
+        return RETURN_ERROR;
+    }
 
     return RETURN_OK;
 }
@@ -527,7 +529,9 @@ ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType
         }
 
         ChannelValueInit(array[i], type);
-        ChannelValueSetFromReference(array[i], (char *) values + i*size);
+        if (RETURN_OK != ChannelValueSetFromReference(array[i], (char *) values + i*size)) {
+            return RETURN_ERROR;
+        }
     }
 
     return array;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 7cbdf2a..bc280c6 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -67,9 +67,9 @@ void *      ChannelValueReference(ChannelValue * value);
 
 void ChannelValueDataDestructor(ChannelValueData * data, ChannelType type);
 void ChannelValueDataInit(ChannelValueData * data, ChannelType type);
-void ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference);
+McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference);
 
-void ChannelValueSetFromReference(ChannelValue * value, const void * reference);
+McxStatus ChannelValueSetFromReference(ChannelValue * value, const void * reference);
 void ChannelValueSetToReference(ChannelValue * value, void * reference);
 
 McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source);
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 67622d2..3787984 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1225,7 +1225,7 @@ static void ConnectionInitUpdateFrom(Connection * connection, TimeInterval * tim
     // Do nothing
 }
 
-static void ConnectionInitUpdateTo(Connection * connection, TimeInterval * time) {
+static McxStatus ConnectionInitUpdateTo(Connection * connection, TimeInterval * time) {
     Channel * channel = (Channel *) connection->out_;
 
 #ifdef MCX_DEBUG
@@ -1236,13 +1236,17 @@ static void ConnectionInitUpdateTo(Connection * connection, TimeInterval * time)
 #endif
 
     if (!connection->useInitialValue_) {
-        ChannelValueSetFromReference(&connection->store_, channel->GetValueReference(channel));
+        if (RETURN_OK != ChannelValueSetFromReference(&connection->store_, channel->GetValueReference(channel))) {
+            return RETURN_ERROR;
+        }
         if (channel->IsDefinedDuringInit(channel)) {
             connection->SetDefinedDuringInit(connection);
         }
     } else {
         connection->SetDefinedDuringInit(connection);
     }
+
+    return RETURN_OK;
 }
 
 static McxStatus ConnectionEnterInitializationMode(Connection * connection) {
diff --git a/src/core/connections/Connection.h b/src/core/connections/Connection.h
index f4736b9..648ed86 100644
--- a/src/core/connections/Connection.h
+++ b/src/core/connections/Connection.h
@@ -62,7 +62,7 @@ typedef void (* fConnectionSetVoid)(Connection * connection);
 
 typedef void (* fConnectionUpdateFromInput)(Connection * connection, TimeInterval * time);
 
-typedef void (* fConnectionUpdateToOutput)(Connection * connection, TimeInterval * time);
+typedef McxStatus (* fConnectionUpdateToOutput)(Connection * connection, TimeInterval * time);
 
 typedef McxStatus (* fConnectionUpdateInitialValue)(Connection * connection);
 
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 79aa80a..3d8a1d3 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -114,8 +114,8 @@ static ChannelFilter * FilteredConnectionGetFilter(FilteredConnection * connecti
     return connection->data->filter;
 }
 
-static void FilteredConnectionSetResult(FilteredConnection * connection, const void * value) {
-    ChannelValueSetFromReference(&connection->data->store, value);
+static McxStatus FilteredConnectionSetResult(FilteredConnection * connection, const void * value) {
+    return ChannelValueSetFromReference(&connection->data->store, value);
 }
 
 static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInterval * time) {
@@ -136,7 +136,7 @@ static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInter
     }
 }
 
-static void FilteredConnectionUpdateToOutput(Connection * connection, TimeInterval * time) {
+static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeInterval * time) {
     FilteredConnection * filteredConnection = (FilteredConnection *) connection;
 
     ChannelFilter * filter = NULL;
@@ -156,7 +156,9 @@ static void FilteredConnectionUpdateToOutput(Connection * connection, TimeInterv
         double value = 0.0;
 
         value = p->fn(time, p->env);
-        filteredConnection->SetResult(filteredConnection, &value);
+        if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
+            return RETURN_ERROR;
+        }
     } else {
         // only filter if time is not negative (negative time means filter disabled)
         if (filteredConnection->GetReadFilter(filteredConnection) && time->startTime >= 0) {
@@ -165,9 +167,13 @@ static void FilteredConnectionUpdateToOutput(Connection * connection, TimeInterv
             filter = filteredConnection->GetReadFilter(filteredConnection);
             value = filter->GetValue(filter, time->startTime);
 
-            filteredConnection->SetResult(filteredConnection, &value);
+            if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
+                return RETURN_ERROR;
+            }
         }
     }
+
+    return RETURN_OK;
 }
 
 static McxStatus AddFilter(Connection * connection) {
diff --git a/src/core/connections/FilteredConnection.h b/src/core/connections/FilteredConnection.h
index ef2f335..00dc94a 100644
--- a/src/core/connections/FilteredConnection.h
+++ b/src/core/connections/FilteredConnection.h
@@ -22,7 +22,7 @@ typedef struct FilteredConnection FilteredConnection;
 
 typedef struct ChannelFilter * (* fConnectionGetFilter)(FilteredConnection * connection);
 
-typedef void (* fFilteredConnectionSetResult)(FilteredConnection * connection, const void * value);
+typedef McxStatus (* fFilteredConnectionSetResult)(FilteredConnection * connection, const void * value);
 
 extern const struct ObjectClass _FilteredConnection;
 
diff --git a/src/core/connections/filters/DiscreteFilter.c b/src/core/connections/filters/DiscreteFilter.c
index ad80218..279ca3a 100644
--- a/src/core/connections/filters/DiscreteFilter.c
+++ b/src/core/connections/filters/DiscreteFilter.c
@@ -18,7 +18,9 @@ static McxStatus DiscreteFilterSetValue(ChannelFilter * filter, double time, Cha
     DiscreteFilter * discreteFilter = (DiscreteFilter *) filter;
 
     if (InCommunicationMode != * filter->state) {
-        ChannelValueSetFromReference(&discreteFilter->lastCouplingStepValue, &value);
+        if (RETURN_OK != ChannelValueSetFromReference(&discreteFilter->lastCouplingStepValue, &value)) {
+            return RETURN_ERROR;
+        }
     }
 
     return RETURN_OK;
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index aa15aaf..dc5c8ab 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -208,7 +208,9 @@ static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData
         break;
     case fmi2_base_type_str: {
         const char * buffer = fmi2_import_get_string_variable_start(fmi2_import_get_variable_as_string(data->data.scalar));
-        ChannelValueSetFromReference(&v->val, &buffer);
+        if (RETURN_OK != ChannelValueSetFromReference(&v->val, &buffer)) {
+            return RETURN_ERROR;
+        }
         break;
     }
     case fmi2_base_type_enum:
diff --git a/src/fmu/common_fmu1.c b/src/fmu/common_fmu1.c
index dc72d00..94bbf97 100644
--- a/src/fmu/common_fmu1.c
+++ b/src/fmu/common_fmu1.c
@@ -283,7 +283,9 @@ Fmu1Value * Fmu1ReadParamValue(ScalarParameterInput * input, fmi1_import_t * imp
     }
 
     ChannelValueInit(&chVal, input->type);
-    ChannelValueSetFromReference(&chVal, &input->value.value);
+    if (RETURN_OK != ChannelValueSetFromReference(&chVal, &input->value.value)) {
+        return NULL;
+    }
 
     var = fmi1_import_get_variable_by_name(import, input->name);
     if (!var) {
@@ -381,11 +383,15 @@ static ObjectContainer * Fmu1ReadArrayParamValues(const char * name,
 
             if (input->type == CHANNEL_DOUBLE) {
                 ChannelValueInit(&chVal, CHANNEL_DOUBLE);
-                ChannelValueSetFromReference(&chVal, &((double *)input->values)[index]);
+                if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
+                    return RETURN_ERROR;
+                }
             }
             else { // integer
                 ChannelValueInit(&chVal, CHANNEL_INTEGER);
-                ChannelValueSetFromReference(&chVal, &((int *)input->values)[index]);
+                if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
+                    return RETURN_ERROR;
+                }
             }
 
             retVal = val->SetFromChannelValue(val, &chVal);
@@ -652,7 +658,9 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
         char * buffer = NULL;
 
         status = fmi1_import_get_string(fmu->fmiImport, vr, 1, (fmi1_string_t *)&buffer);
-        ChannelValueSetFromReference(chVal, &buffer);
+        if (RETURN_OK != ChannelValueSetFromReference(chVal, &buffer)) {
+            return RETURN_ERROR;
+        }
         break;
     }
     default:
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index f0c39d4..c6c7e3f 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -299,7 +299,9 @@ Fmu2Value * Fmu2ReadParamValue(ScalarParameterInput * input,
     }
 
     ChannelValueInit(&chVal, input->type);
-    ChannelValueSetFromReference(&chVal, &input->value.value);
+    if (RETURN_OK != ChannelValueSetFromReference(&chVal, &input->value.value)) {
+        return NULL;
+    }
 
     var = fmi2_import_get_variable_by_name(import, input->name);
     if (!var) {
@@ -389,10 +391,16 @@ static ObjectContainer* Fmu2ReadArrayParamValues(const char * name,
 
             if (input->type == CHANNEL_DOUBLE) {
                 ChannelValueInit(&chVal, CHANNEL_DOUBLE);
-                ChannelValueSetFromReference(&chVal, &((double *)input->values)[index]);
+                if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
+                    retVal = RETURN_ERROR;
+                    goto fmu2_read_array_param_values_for_cleanup;
+                }
             } else { // integer
                 ChannelValueInit(&chVal, CHANNEL_INTEGER);
-                ChannelValueSetFromReference(&chVal, &((int *)input->values)[index]);
+                if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
+                    retVal = RETURN_ERROR;
+                    goto fmu2_read_array_param_values_for_cleanup;
+                }
             }
 
             retVal = val->SetFromChannelValue(val, &chVal);
@@ -818,7 +826,9 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
         char * buffer = NULL;
 
         status = fmi2_import_get_string(fmu->fmiImport, vr, 1, (fmi2_string_t *) &buffer);
-        ChannelValueSetFromReference(chVal, &buffer);
+        if (RETURN_OK != ChannelValueSetFromReference(chVal, &buffer)) {
+            return RETURN_ERROR;
+        }
 
         break;
     }
@@ -839,7 +849,9 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
         binary.len = vs[2];
         binary.data = (char *) ((((long long)vs[1] & 0xffffffff) << 32) | (vs[0] & 0xffffffff));
 
-        ChannelValueSetFromReference(chVal, &binary);
+        if (RETURN_OK != ChannelValueSetFromReference(chVal, &binary)) {
+            return RETURN_ERROR;
+        }
 
         break;
     }
diff --git a/src/reader/model/ports/ScalarPortInput.c b/src/reader/model/ports/ScalarPortInput.c
index 50be17d..38d4b18 100644
--- a/src/reader/model/ports/ScalarPortInput.c
+++ b/src/reader/model/ports/ScalarPortInput.c
@@ -81,37 +81,49 @@ static McxStatus CopyFrom(ScalarPortInput * self, ScalarPortInput * src) {
     self->min.defined = src->min.defined;
     if (self->min.defined) {
         ChannelValueDataInit(&self->min.value, self->type);
-        ChannelValueDataSetFromReference(&self->min.value, self->type, &src->min.value);
+        if (RETURN_OK != ChannelValueDataSetFromReference(&self->min.value, self->type, &src->min.value)) {
+            return RETURN_ERROR;
+        }
     }
 
     self->max.defined = src->max.defined;
     if (self->max.defined) {
         ChannelValueDataInit(&self->max.value, self->type);
-        ChannelValueDataSetFromReference(&self->max.value, self->type, &src->max.value);
+        if (RETURN_OK != ChannelValueDataSetFromReference(&self->max.value, self->type, &src->max.value)) {
+            return RETURN_ERROR;
+        }
     }
 
     self->scale.defined = src->scale.defined;
     if (self->scale.defined) {
         ChannelValueDataInit(&self->scale.value, self->type);
-        ChannelValueDataSetFromReference(&self->scale.value, self->type, &src->scale.value);
+        if (RETURN_OK != ChannelValueDataSetFromReference(&self->scale.value, self->type, &src->scale.value)) {
+            return RETURN_ERROR;
+        }
     }
 
     self->offset.defined = src->offset.defined;
     if (self->offset.defined) {
         ChannelValueDataInit(&self->offset.value, self->type);
-        ChannelValueDataSetFromReference(&self->offset.value, self->type, &src->offset.value);
+        if (RETURN_OK != ChannelValueDataSetFromReference(&self->offset.value, self->type, &src->offset.value)) {
+            return RETURN_ERROR;
+        }
     }
 
     self->default_.defined = src->default_.defined;
     if (self->default_.defined) {
         ChannelValueDataInit(&self->default_.value, self->type);
-        ChannelValueDataSetFromReference(&self->default_.value, self->type, &src->default_.value);
+        if (RETURN_OK != ChannelValueDataSetFromReference(&self->default_.value, self->type, &src->default_.value)) {
+            return RETURN_ERROR;
+        }
     }
 
     self->initial.defined = src->initial.defined;
     if (self->initial.defined) {
         ChannelValueDataInit(&self->initial.value, self->type);
-        ChannelValueDataSetFromReference(&self->initial.value, self->type, &src->initial.value);
+        if (RETURN_OK != ChannelValueDataSetFromReference(&self->initial.value, self->type, &src->initial.value)) {
+            return RETURN_ERROR;
+        }
     }
 
     self->writeResults = src->writeResults;
diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index 7cf8f14..538e86b 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -156,7 +156,9 @@ static McxStatus ChannelStorageSetValueFromReferenceAt(ChannelStorage * channelS
         ChannelValueInit(&channelStore->values[row * colNum + col], info->type);
     }
 
-    ChannelValueSetFromReference(&channelStore->values[row * colNum + col], reference);
+    if (RETURN_OK != ChannelValueSetFromReference(&channelStore->values[row * colNum + col], reference)) {
+        return RETURN_ERROR;
+    }
 
     return RETURN_OK;
 }

From 677217527ad7cd9e9c3a3fee2657d10d38329f9e Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 5 Jul 2021 13:40:53 +0200
Subject: [PATCH 009/166] channel: Add return value to SetToReference

---
 src/core/channels/ChannelValue.c | 4 +++-
 src/core/channels/ChannelValue.h | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 7ec6d04..1685e7f 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -301,7 +301,7 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
     return RETURN_OK;
 }
 
-void ChannelValueSetToReference(ChannelValue * value, void * reference) {
+McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
     switch (value->type) {
     case CHANNEL_DOUBLE:
         * (double *) reference = value->value.d;
@@ -347,6 +347,8 @@ void ChannelValueSetToReference(ChannelValue * value, void * reference) {
     default:
         break;
     }
+
+    return RETURN_OK;
 }
 #ifdef __cplusplus
 size_t ChannelValueTypeSize(ChannelType type) {
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index bc280c6..2b40d11 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -70,7 +70,7 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType type);
 McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference);
 
 McxStatus ChannelValueSetFromReference(ChannelValue * value, const void * reference);
-void ChannelValueSetToReference(ChannelValue * value, void * reference);
+McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference);
 
 McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source);
 

From 06e75558f5acc9efd53201b854cf772ec3d05d9b Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 5 Jul 2021 08:42:12 +0200
Subject: [PATCH 010/166] channel: Add CHANNEL_ARRAY

---
 src/core/channels/ChannelValue.c | 155 +++++++++++++++++++++++++++++++
 src/core/channels/ChannelValue.h |  33 +++++--
 2 files changed, 178 insertions(+), 10 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 1685e7f..5411d42 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -15,6 +15,58 @@
 extern "C" {
 #endif /* __cplusplus */
 
+
+McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType type) {
+    a->numDims = numDims;
+    a->dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
+    if (!a->dims) {
+        return RETURN_ERROR;
+    }
+    memcpy(a->dims, dims, sizeof(size_t) * numDims);
+
+    a->type = type;
+    a->data = (void *) mcx_calloc(ChannelValueTypeSize(type), array_num_elements(a));
+    if (!a->data) {
+        return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
+int array_dims_match(array * a, array * b) {
+    size_t i = 0;
+
+    if (a->numDims != b->numDims) {
+        return 0;
+    }
+    if (a->dims == NULL || b->dims == NULL) {
+        return 0;
+    }
+
+    for (i = 0; i < a->numDims; i++) {
+        if (a->dims[i] != b->dims[i]) {
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+size_t array_num_elements(array * a) {
+    size_t i = 0;
+    size_t n = 1;
+
+    if (a->numDims == 0) {
+        return 0;
+    }
+
+    for (i = 0; i < a->numDims; i++) {
+        n *= a->dims[i];
+    }
+
+    return n;
+}
+
 void ChannelValueInit(ChannelValue * value, ChannelType type) {
     value->type = type;
     ChannelValueDataInit(&value->value, type);
@@ -33,6 +85,15 @@ void ChannelValueDataDestructor(ChannelValueData * data, ChannelType type) {
         }
     } else if (type == CHANNEL_BINARY_REFERENCE) {
         // do not free references to binary, they are not owned by the ChannelValueData
+    } else if (type == CHANNEL_ARRAY) {
+        if (data->a.dims) {
+            mcx_free(data->a.dims);
+            data->a.dims = NULL;
+        }
+        if (data->a.data) {
+            mcx_free(data->a.data);
+            data->a.data = NULL;
+        }
     }
 }
 
@@ -111,6 +172,9 @@ char * ChannelValueToString(ChannelValue * value) {
             }
         }
         break;
+    case CHANNEL_ARRAY:
+        mcx_log(LOG_ERROR, "TODO: ChannelValueToString unimplemented for CHANNEL_ARRAY");
+        return NULL;
     default:
         return NULL;
     }
@@ -184,6 +248,9 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
             }
         }
         break;
+    case CHANNEL_ARRAY:
+        mcx_log(LOG_ERROR, "TODO: ChannelValueToString unimplemented for CHANNEL_ARRAY");
+        return RETURN_ERROR;
     default:
         mcx_log(LOG_DEBUG, "Port value to string: Unknown type");
         return RETURN_ERROR;
@@ -227,6 +294,11 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType type) {
             data->b.len = 0;
             data->b.data = NULL;
             break;
+        case CHANNEL_ARRAY:
+            data->a.numDims = 0;
+            data->a.dims = NULL;
+            data->a.data = NULL;
+            break;
         case CHANNEL_UNKNOWN:
         default:
             break;
@@ -275,6 +347,28 @@ McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType
             data->b.data = ((binary_string *) reference)->data;
         }
         break;
+    case CHANNEL_ARRAY:
+        if (NULL != reference) {
+            array * a = (array *) reference;
+
+            // The first call to SetFromReference fixes the dimensions
+            if (!data->a.numDims && a->numDims) {
+                if (RETURN_OK != array_init(&data->a, a->numDims, a->dims, a->type)) {
+                    return RETURN_ERROR;
+                }
+            }
+
+            // Arrays do not support multiplexing (yet)
+            if (!array_dims_match(&data->a, a)) {
+                return RETURN_ERROR;
+            }
+
+            if (a->data == NULL || data->a.data == NULL) {
+                return RETURN_ERROR;
+            }
+
+            memcpy(data->a.data, a->data, ChannelValueTypeSize(a->type) * array_num_elements(a));
+        }
     case CHANNEL_UNKNOWN:
     default:
         break;
@@ -343,6 +437,29 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
             ((binary_string *) reference)->data = value->value.b.data;
         }
         break;
+    case CHANNEL_ARRAY:
+        if (NULL != reference) {
+            array * a = (array *) reference;
+
+            // First Set fixes the dimensions
+            if (value->value.a.numDims && !a->numDims) {
+                if (RETURN_OK != array_init(a, value->value.a.numDims, value->value.a.dims, value->value.a.type)) {
+                    return RETURN_ERROR;
+                }
+            }
+
+            // Arrays do not support multiplexing (yet)
+            if (!array_dims_match(a, &value->value.a)) {
+                return RETURN_ERROR;
+            }
+
+            if (value->value.a.data == NULL || a->data == NULL) {
+                return RETURN_ERROR;
+            }
+
+            memcpy(a->data, value->value.a.data, ChannelValueTypeSize(a->type) * array_num_elements(a));
+        }
+        break;
     case CHANNEL_UNKNOWN:
     default:
         break;
@@ -350,6 +467,8 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
 
     return RETURN_OK;
 }
+
+// TODO: invalid size should be (-1)
 #ifdef __cplusplus
 size_t ChannelValueTypeSize(ChannelType type) {
     switch (type) {
@@ -361,6 +480,11 @@ size_t ChannelValueTypeSize(ChannelType type) {
         return sizeof(ChannelValueData::i);
     case CHANNEL_STRING:
         return sizeof(ChannelValueData::s);
+    case CHANNEL_BINARY:
+    case CHANNEL_BINARY_REFERENCE:
+        return sizeof(ChannelValueData::b);
+    case CHANNEL_ARRAY:
+        return sizeof(ChannelValueData::a);
     }
     return 0;
 }
@@ -376,6 +500,11 @@ size_t ChannelValueTypeSize(ChannelType type) {
         return sizeof(value.i);
     case CHANNEL_STRING:
         return sizeof(value.s);
+    case CHANNEL_BINARY:
+    case CHANNEL_BINARY_REFERENCE:
+        return sizeof(value.b);
+    case CHANNEL_ARRAY:
+        return sizeof(value.a);
     }
     return 0;
 }
@@ -396,6 +525,8 @@ const char * ChannelTypeToString(ChannelType type) {
     case CHANNEL_BINARY:
     case CHANNEL_BINARY_REFERENCE:
         return "Binary";
+    case CHANNEL_ARRAY:
+        return "Array";
     default:
         return "";
     }
@@ -427,6 +558,10 @@ int ChannelValueLeq(ChannelValue * val1, ChannelValue * val2) {
         return val1->value.d <= val2->value.d;
     case CHANNEL_INTEGER:
         return val1->value.i <= val2->value.i;
+    case CHANNEL_ARRAY:
+        // TODO: val1 <= val1 <=> val1[i,j] <= val2[i,j] \forall i,j?
+        mcx_log(LOG_ERROR, "TODO: ChannelValueLeq unimplemented for CHANNEL_ARRAY");
+        exit(-1);
     default:
         return 0;
     }
@@ -442,6 +577,10 @@ int ChannelValueGeq(ChannelValue * val1, ChannelValue * val2) {
         return val1->value.d >= val2->value.d;
     case CHANNEL_INTEGER:
         return val1->value.i >= val2->value.i;
+    case CHANNEL_ARRAY:
+        // TODO: val1 >= val1 <=> val1[i,j] >= val2[i,j] \forall i,j?
+        mcx_log(LOG_ERROR, "TODO: ChannelValueGeq unimplemented for CHANNEL_ARRAY");
+        exit(-1);
     default:
         return 0;
     }
@@ -460,6 +599,10 @@ int ChannelValueEq(ChannelValue * val1, ChannelValue * val2) {
         return val1->value.i == val2->value.i;
     case CHANNEL_STRING:
         return !strcmp(val1->value.s, val2->value.s);
+    case CHANNEL_ARRAY:
+        // TODO: val1 == val1 <=> val1[i,j] == val2[i,j] \forall i,j?
+        mcx_log(LOG_ERROR, "TODO: ChannelValueEq unimplemented for CHANNEL_ARRAY");
+        exit(-1);
     default:
         return 0;
     }
@@ -479,6 +622,12 @@ McxStatus ChannelValueAddOffset(ChannelValue * val, ChannelValue * offset) {
     case CHANNEL_INTEGER:
         val->value.i += offset->value.i;
         return RETURN_OK;
+    case CHANNEL_ARRAY:
+        // TODO: val matrix, offset matrix
+        //       val matrix, offset scalar
+        // needs check above relaxed
+        mcx_log(LOG_ERROR, "TODO: ChannelValueAddOffset unimplemented for CHANNEL_ARRAY");
+        exit(-1);
     default:
         mcx_log(LOG_ERROR, "Port: Add offset: Type %s not allowed", ChannelTypeToString(ChannelValueType(val)));
         return RETURN_ERROR;
@@ -499,6 +648,12 @@ McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
     case CHANNEL_INTEGER:
         val->value.i *= factor->value.i;
         return RETURN_OK;
+    case CHANNEL_ARRAY:
+        // TODO: val matrix, offset scalar
+        //       val matrix, offset matrix: matrix multiplication?
+        // needs check above relaxed
+        mcx_log(LOG_ERROR, "TODO: ChannelValueScale unimplemented for CHANNEL_ARRAY");
+        exit(-1);
     default:
         mcx_log(LOG_ERROR, "Port: Scale: Type %s not allowed", ChannelTypeToString(ChannelValueType(val)));
         return RETURN_ERROR;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 2b40d11..7b4cccc 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -17,6 +17,18 @@
 extern "C" {
 #endif /* __cplusplus */
 
+// possible types of values that can be put on channels
+typedef enum ChannelType {
+    CHANNEL_UNKNOWN = 0,
+    CHANNEL_DOUBLE = 1,
+    CHANNEL_INTEGER = 2,
+    CHANNEL_BOOL = 3,
+    CHANNEL_STRING = 4,
+    CHANNEL_BINARY = 5,
+    CHANNEL_BINARY_REFERENCE = 6,
+    CHANNEL_ARRAY = 7,
+} ChannelType;
+
 typedef struct {
     double startTime;
     double endTime;
@@ -32,23 +44,24 @@ typedef struct {
     char * data;
 } binary_string;
 
-// possible types of values that can be put on channels
-typedef enum ChannelType {
-    CHANNEL_UNKNOWN = 0,
-    CHANNEL_DOUBLE = 1,
-    CHANNEL_INTEGER = 2,
-    CHANNEL_BOOL = 3,
-    CHANNEL_STRING = 4,
-    CHANNEL_BINARY = 5,
-    CHANNEL_BINARY_REFERENCE = 6,
-} ChannelType;
+typedef struct {
+    size_t numDims;
+    size_t * dims;
+    ChannelType type;
+    void * data;
+} array;
+
+int array_dims_match(array * a, array * b);
+size_t array_num_elements(array * a);
 
+// TODO: change concrete types to McxDouble, McxInteger, etc
 typedef union ChannelValueData {
     /* the order is significant. double needs to be the first entry for union initialization to work */
     double d;
     int i;
     char * s;
     binary_string b;
+    array a;
 } ChannelValueData;
 
 typedef struct ChannelValue {

From d2e4b57a87cab84956ad44822dfa6c9e5baf3655 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 6 Jul 2021 10:10:36 +0200
Subject: [PATCH 011/166] Add ChannelTypeMatch

---
 src/core/channels/ChannelValue.c | 10 ++++++++++
 src/core/channels/ChannelValue.h |  2 ++
 2 files changed, 12 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 5411d42..a25f20a 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -510,6 +510,16 @@ size_t ChannelValueTypeSize(ChannelType type) {
 }
 #endif //__cplusplus
 
+int ChannelTypeMatch(ChannelType a, ChannelType b) {
+    if ((CHANNEL_BINARY == a || CHANNEL_BINARY_REFERENCE == a) &&
+        (CHANNEL_BINARY == b || CHANNEL_BINARY_REFERENCE == b)) {
+        return 1;
+    } else {
+        return a == b;
+    }
+    // TODO: Ignores array dimensions
+}
+
 const char * ChannelTypeToString(ChannelType type) {
     switch (type) {
     case CHANNEL_UNKNOWN:
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 7b4cccc..30a6d25 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -88,6 +88,8 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference);
 McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source);
 
 size_t ChannelValueTypeSize(ChannelType type);
+int ChannelTypeMatch(ChannelType a, ChannelType b);
+
 
 ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType type);
 

From d848a9e54b8cabe39235878d7bac9044efe407ec Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 6 Jul 2021 10:11:10 +0200
Subject: [PATCH 012/166] channel: Use ChannelTypeMatch in
 ChannelInSetReference

---
 src/core/channels/Channel.c | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index a17b147..7bcde53 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -133,13 +133,9 @@ static McxStatus ChannelInSetReference(ChannelIn * in, void * reference, Channel
             mcx_log(LOG_ERROR, "Port %s: Set inport reference: Port not set up", ChannelInfoGetLogName(info));
             return RETURN_ERROR;
         }
-        if (info->type != type) {
-            if (ChannelInfoIsBinary(info) && (type == CHANNEL_BINARY || type == CHANNEL_BINARY_REFERENCE)) {
-                // ok
-            } else {
-                mcx_log(LOG_ERROR, "Port %s: Set inport reference: Mismatching types", ChannelInfoGetLogName(info));
-                return RETURN_ERROR;
-            }
+        if (!ChannelTypeMatch(info->type, type)) {
+            mcx_log(LOG_ERROR, "Port %s: Set inport reference: Mismatching types", ChannelInfoGetLogName(info));
+            return RETURN_ERROR;
         }
     }
 

From 133ae5675245fcac109b0f1ce80ce819d249016a Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 6 Jul 2021 10:11:43 +0200
Subject: [PATCH 013/166] channel: Use ChannelValueDataSetFromReference in
 ChannelInUpdate

---
 src/core/channels/Channel.c | 61 +++----------------------------------
 1 file changed, 4 insertions(+), 57 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 7bcde53..6fde510 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -242,65 +242,12 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         return RETURN_OK;
     }
 
-
-    switch (info->type) {
-    case CHANNEL_DOUBLE:
-#ifdef MCX_DEBUG
-        if (time->startTime < MCX_DEBUG_LOG_TIME) {
-            MCX_DEBUG_LOG("[%f] CH IN  (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, * (double *) channel->GetValueReference(channel));
-        }
-#endif // MCX_DEBUG
-        * (double *) in->data->reference = * (double *) channel->GetValueReference(channel);
-        break;
-    case CHANNEL_INTEGER:
-        * (int *) in->data->reference = * (int *) channel->GetValueReference(channel);
-        break;
-    case CHANNEL_BOOL:
-        * (int *) in->data->reference = * (int *) channel->GetValueReference(channel);
-        break;
-    case CHANNEL_STRING:
-    {
-        const void * reference = channel->GetValueReference(channel);
-
-        if (NULL != reference && NULL != * (const char * *) reference ) {
-            if (* (char * *) in->data->reference) {
-                mcx_free(* (char * *) in->data->reference);
-            }
-            * (char * *) in->data->reference = (char *) mcx_calloc(strlen(* (const char **) reference) + 1, sizeof(char));
-            if (* (char * *) in->data->reference) {
-                strncpy(* (char * *) in->data->reference, * (const char **)reference, strlen(* (const char **)reference) + 1);
-            }
-        }
-        break;
+    if (time->startTime < MCX_DEBUG_LOG_TIME && info->type == CHANNEL_DOUBLE) {
+        MCX_DEBUG_LOG("[%f] CH IN  (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, * (double *) channel->GetValueReference(channel));
     }
-    case CHANNEL_BINARY:
-    {
-        const void * reference = channel->GetValueReference(channel);
 
-        if (NULL != reference && NULL != ((const binary_string *) reference)->data) {
-            if (((binary_string *) in->data->reference)->data) {
-                mcx_free(((binary_string *) in->data->reference)->data);
-            }
-            ((binary_string *) in->data->reference)->len = ((const binary_string *) reference)->len;
-            ((binary_string *) in->data->reference)->data = (char *) mcx_malloc(((binary_string *) in->data->reference)->len);
-            if (((binary_string *) in->data->reference)->data) {
-                memcpy(((binary_string *) in->data->reference)->data, ((const binary_string *) reference)->data, ((binary_string *) in->data->reference)->len);
-            }
-        }
-        break;
-    }
-    case CHANNEL_BINARY_REFERENCE:
-    {
-        const void * reference = channel->GetValueReference(channel);
-
-        if (NULL != reference && NULL != ((binary_string *) reference)->data) {
-            ((binary_string *) in->data->reference)->len = ((binary_string *) reference)->len;
-            ((binary_string *) in->data->reference)->data = ((binary_string *) reference)->data;
-        }
-        break;
-    }
-    default:
-        break;
+    if (RETURN_OK != ChannelValueDataSetFromReference(in->data->reference, info->type, channel->GetValueReference(channel))) {
+        return RETURN_ERROR;
     }
 
     return RETURN_OK;

From d1c5545e2bfffb486693a202030764144dc37fd6 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 6 Jul 2021 11:40:18 +0200
Subject: [PATCH 014/166] channel: Add error messages

---
 src/core/channels/Channel.c               | 2 ++
 src/core/connections/FilteredConnection.c | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 6fde510..95a89b8 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -182,9 +182,11 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
 
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
+            mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection failed", info->GetLogName(info));
             return RETURN_ERROR;
         }
         if (RETURN_OK != ChannelValueSetFromReference(val, conn->GetValueReference(conn))) {
+            mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueSetFromReference failed", info->GetLogName(info));
             return RETURN_ERROR;
         }
 
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 3d8a1d3..cbf73ed 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -157,6 +157,7 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
 
         value = p->fn(time, p->env);
         if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
+            mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
             return RETURN_ERROR;
         }
     } else {
@@ -168,6 +169,7 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
             value = filter->GetValue(filter, time->startTime);
 
             if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
+                mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
                 return RETURN_ERROR;
             }
         }

From 92ccb83bdef99ef67e5da0dbd75768ef930cee0f Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 6 Jul 2021 11:47:33 +0200
Subject: [PATCH 015/166] channel: Remove unnecessary type checks

---
 src/core/channels/Channel.c | 60 ++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 95a89b8..9643db5 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -182,11 +182,11 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
 
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
-            mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection failed", info->GetLogName(info));
+            mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection failed", ChannelInfoGetLogName(info));
             return RETURN_ERROR;
         }
         if (RETURN_OK != ChannelValueSetFromReference(val, conn->GetValueReference(conn))) {
-            mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueSetFromReference failed", info->GetLogName(info));
+            mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueSetFromReference failed", ChannelInfoGetLogName(info));
             return RETURN_ERROR;
         }
 
@@ -199,42 +199,42 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
                 return RETURN_ERROR;
             }
         }
+    }
 
 
-        if (info->type == CHANNEL_DOUBLE) {
-            ChannelValue * val = &channel->value;
-            // unit
-            if (in->data->unitConversion) {
-                Conversion * conversion = (Conversion *) in->data->unitConversion;
-                retVal = conversion->convert(conversion, val);
-                if (RETURN_OK != retVal) {
-                    mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute unit conversion", ChannelInfoGetLogName(info));
-                    return RETURN_ERROR;
-                }
+    // Conversions
+    {
+        ChannelValue * val =  &channel->value;
+
+
+        // unit
+        if (in->data->unitConversion) {
+            Conversion * conversion = (Conversion *) in->data->unitConversion;
+            retVal = conversion->convert(conversion, val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute unit conversion", ChannelInfoGetLogName(info));
+                return RETURN_ERROR;
             }
         }
 
-        if (info->type == CHANNEL_DOUBLE || info->type == CHANNEL_INTEGER) {
-            ChannelValue * val = &channel->value;
 
-            // linear
-            if (in->data->linearConversion) {
-                Conversion * conversion = (Conversion *) in->data->linearConversion;
-                retVal = conversion->convert(conversion, val);
-                if (RETURN_OK != retVal) {
-                    mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute linear conversion", ChannelInfoGetLogName(info));
-                    return RETURN_ERROR;
-                }
+        // linear
+        if (in->data->linearConversion) {
+            Conversion * conversion = (Conversion *) in->data->linearConversion;
+            retVal = conversion->convert(conversion, val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute linear conversion", ChannelInfoGetLogName(info));
+                return RETURN_ERROR;
             }
+        }
 
-            // range
-            if (in->data->rangeConversion) {
-                Conversion * conversion = (Conversion *) in->data->rangeConversion;
-                retVal = conversion->convert(conversion, val);
-                if (RETURN_OK != retVal) {
-                    mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute range conversion", ChannelInfoGetLogName(info));
-                    return RETURN_ERROR;
-                }
+        // range
+        if (in->data->rangeConversion) {
+            Conversion * conversion = (Conversion *) in->data->rangeConversion;
+            retVal = conversion->convert(conversion, val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute range conversion", ChannelInfoGetLogName(info));
+                return RETURN_ERROR;
             }
         }
     }

From 36065ec07d58742d2bf88dd3f2d2becfca20d372 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 6 Jul 2021 14:05:25 +0200
Subject: [PATCH 016/166] channel: Add nameInModel to ChannelInfoInit

---
 src/core/Databus.c              | 2 +-
 src/core/channels/ChannelInfo.c | 5 +++++
 src/core/channels/ChannelInfo.h | 1 +
 src/storage/ChannelStorage.c    | 2 +-
 4 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index d3901a9..327de97 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -1513,7 +1513,7 @@ static McxStatus DatabusAddLocalChannelInternal(Databus * db,
     }
 
     uniqueName = DatabusGetUniqueChannelName(db, name);
-    retVal = ChannelInfoSetup(&chInfo, uniqueName, NULL, unit, type, id);
+    retVal = ChannelInfoSetup(&chInfo, uniqueName, uniqueName, NULL, unit, type, id);
     if (RETURN_OK != retVal) {
         mcx_log(LOG_ERROR, "Ports: Set local-reference: Setting up ChannelInfo for %s failed", ChannelInfoGetName(&chInfo));
         goto cleanup;
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index 41e4baf..7db9b5f 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -102,6 +102,7 @@ McxStatus ChannelInfoSetVector(ChannelInfo * info, VectorChannelInfo * vector) {
 
 McxStatus ChannelInfoSetup(ChannelInfo * info,
                            const char * name,
+                           const char * nameInModel,
                            const char * descr,
                            const char * unit,
                            ChannelType  type,
@@ -110,6 +111,10 @@ McxStatus ChannelInfoSetup(ChannelInfo * info,
         mcx_log(LOG_DEBUG, "Port %s: Could not set name", name);
         return RETURN_ERROR;
     }
+    if (nameInModel && RETURN_OK != ChannelInfoSetNameInTool(info, nameInModel)) {
+        mcx_log(LOG_DEBUG, "Port %s: Could not set name in tool", name);
+        return RETURN_ERROR;
+    }
     if (descr && RETURN_OK != ChannelInfoSetDescription(info, descr)) {
         mcx_log(LOG_DEBUG, "Port %s: Could not set description", name);
         return RETURN_ERROR;
diff --git a/src/core/channels/ChannelInfo.h b/src/core/channels/ChannelInfo.h
index 9f8c0a0..a995413 100644
--- a/src/core/channels/ChannelInfo.h
+++ b/src/core/channels/ChannelInfo.h
@@ -73,6 +73,7 @@ int ChannelInfoIsBinary(const ChannelInfo * info);
 
 McxStatus ChannelInfoSetup(ChannelInfo * info,
                            const char * name,
+                           const char * nameInModel,
                            const char * descr,
                            const char * unit,
                            ChannelType  type,
diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index 538e86b..cfda2e6 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -83,7 +83,7 @@ static McxStatus ChannelStorageSetup(ChannelStorage * channelStore, int fullStor
         goto cleanup;
     }
 
-    retVal = ChannelInfoSetup(&timeInfo, "Time", "", GetTimeUnitString(), CHANNEL_DOUBLE, "");
+    retVal = ChannelInfoSetup(&timeInfo, "Time", "Time", "", GetTimeUnitString(), CHANNEL_DOUBLE, "");
     if (RETURN_ERROR == retVal) {
         mcx_log(LOG_ERROR, "Results: Setup port storage: Could not set up time port data");
         goto cleanup;

From b43a7e9e6ff985b79be96cb8ee992168d62e0e54 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Wed, 7 Jul 2021 09:14:40 +0200
Subject: [PATCH 017/166] Add ChannelValueDestroy to free ChannelValues on heap

---
 src/core/channels/ChannelValue.c | 6 ++++++
 src/core/channels/ChannelValue.h | 1 +
 2 files changed, 7 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index a25f20a..b227785 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -670,6 +670,12 @@ McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
     }
 }
 
+void ChannelValueDestroy(ChannelValue ** value) {
+    ChannelValueDestructor(*value);
+    mcx_free(*value);
+    *value = NULL;
+}
+
 ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType type) {
     ChannelValue ** array = NULL;
 
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 30a6d25..e1b21c0 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -90,6 +90,7 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source);
 size_t ChannelValueTypeSize(ChannelType type);
 int ChannelTypeMatch(ChannelType a, ChannelType b);
 
+void ChannelValueDestroy(ChannelValue ** value);
 
 ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType type);
 

From 56e5bb5d62a125c60d4bef7900c42c005c8c87ab Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Wed, 7 Jul 2021 10:05:38 +0200
Subject: [PATCH 018/166] channel: Use writeResults as scalar for vectors

---
 src/core/Databus.c                       | 11 +++--------
 src/reader/model/ports/VectorPortInput.c | 23 +++++++++++------------
 src/reader/model/ports/VectorPortInput.h |  2 +-
 3 files changed, 15 insertions(+), 21 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 327de97..3e1882a 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -98,7 +98,6 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         ChannelValue ** offsets = NULL;
         ChannelValue ** defaults = NULL;
         ChannelValue ** initials = NULL;
-        int * writeResults = NULL;
 
         int startIndex = 0;
         int endIndex   = 0;
@@ -173,8 +172,6 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             goto cleanup_1;
         }
 
-        writeResults = vectorPortInput->writeResults;
-
         for (i = startIndex; i <= endIndex; i++) {
             char * name       = NULL;
             char * nameInTool = NULL;
@@ -239,8 +236,9 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             if (initials) {
                 copy.initialValue = initials[i - startIndex];
             }
-            if (writeResults) {
-                copy.writeResult = writeResults[i - startIndex];
+
+            if (vectorPortInput->writeResults.defined) {
+                copy.writeResult = vectorPortInput->writeResults.value;
             }
 
             list->PushBack(list, &copy);
@@ -287,9 +285,6 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         if (initials) {
             mcx_free(initials);
         }
-        if (writeResults) {
-            // writeResults was taken from vectorPortInput
-        }
 
         if (RETURN_ERROR == retVal) {
             goto cleanup_0;
diff --git a/src/reader/model/ports/VectorPortInput.c b/src/reader/model/ports/VectorPortInput.c
index bd74ebc..5461096 100644
--- a/src/reader/model/ports/VectorPortInput.c
+++ b/src/reader/model/ports/VectorPortInput.c
@@ -144,15 +144,7 @@ static McxStatus CopyFrom(VectorPortInput * self, VectorPortInput * src) {
         self->default_ = NULL;
     }
 
-    if (src->writeResults) {
-        self->writeResults = (int *) mcx_calloc(len, sizeof(int));
-        if (!self->writeResults) {
-            return RETURN_ERROR;
-        }
-        memcpy(self->writeResults, src->writeResults, len * sizeof(int));
-    } else {
-        self->writeResults = NULL;
-    }
+    self->writeResults = src->writeResults;
 
     return RETURN_OK;
 }
@@ -187,6 +179,14 @@ static void PrintVec(char * prefix, ChannelType type, size_t len, void * value)
     mcx_log(LOG_DEBUG, "%s", buffer);
 }
 
+static void PrintOptionalInt(char * prefix, OPTIONAL_VALUE(int) value) {
+    if (value.defined) {
+        mcx_log(LOG_DEBUG, "%s%d,", prefix, value.value);
+    } else {
+        mcx_log(LOG_DEBUG, "%s-,", prefix);
+    }
+}
+
 void VectorPortInputPrint(VectorPortInput * input) {
     size_t len = input->endIndex - input->startIndex + 1;
 
@@ -205,7 +205,7 @@ void VectorPortInputPrint(VectorPortInput * input) {
     PrintVec("  .default: ", input->type, len, input->default_);
     PrintVec("  .initial: ", input->type, len, input->initial);
 
-    PrintVec("  .writeResults: ", input->type, len, input->writeResults);
+    PrintOptionalInt("  .writeResults: ", input->writeResults);
     mcx_log(LOG_DEBUG, "}");
 }
 
@@ -221,7 +221,6 @@ static void VectorPortInputDestructor(VectorPortInput * input) {
     if (input->offset) { mcx_free(input->offset); }
     if (input->default_) { mcx_free(input->default_); }
     if (input->initial) { mcx_free(input->initial); }
-    if (input->writeResults) { mcx_free(input->writeResults); }
 }
 
 static VectorPortInput * VectorPortInputCreate(VectorPortInput * input) {
@@ -247,7 +246,7 @@ static VectorPortInput * VectorPortInputCreate(VectorPortInput * input) {
     input->default_ = NULL;
     input->initial = NULL;
 
-    input->writeResults = NULL;
+    OPTIONAL_UNSET(input->writeResults);
 
     inputElement->Clone = Clone;
     input->CopyFrom = CopyFrom;
diff --git a/src/reader/model/ports/VectorPortInput.h b/src/reader/model/ports/VectorPortInput.h
index 417767b..9516e31 100644
--- a/src/reader/model/ports/VectorPortInput.h
+++ b/src/reader/model/ports/VectorPortInput.h
@@ -46,7 +46,7 @@ struct VectorPortInput {
     void * default_;
     void * initial;
 
-    int * writeResults;
+    OPTIONAL_VALUE(int) writeResults;
 
     fVectorPortInputCopyFrom CopyFrom;
 };

From 75a4c3a36e87bf62a04cfee4847760cd36521d6c Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 12 Jul 2021 10:28:25 +0200
Subject: [PATCH 019/166] channel: Make ChannelType a struct

---
 src/components/comp_fmu.c                     |  36 ++--
 src/components/comp_integrator.c              |   4 +-
 src/components/comp_vector_integrator.c       |   4 +-
 src/core/Component.c                          |   2 +-
 src/core/Conversion.c                         |  80 ++++-----
 src/core/Databus.c                            |  31 ++--
 src/core/Model.c                              |   8 +-
 src/core/channels/Channel.c                   |  44 ++---
 src/core/channels/ChannelInfo.c               |   8 +-
 src/core/channels/ChannelValue.c              | 155 ++++++++++--------
 src/core/channels/ChannelValue.h              |  40 ++++-
 src/core/connections/Connection.c             |   8 +-
 src/core/connections/ConnectionInfo.c         |  12 +-
 src/core/connections/FilteredConnection.c     |   2 +-
 src/core/connections/filters/DiscreteFilter.c |   4 +-
 src/core/connections/filters/MemoryFilter.c   |  10 +-
 src/core/parameters/ParameterProxies.c        |   6 +-
 src/fmu/Fmu1Value.c                           |   2 +-
 src/fmu/Fmu2Value.c                           |  16 +-
 src/fmu/common_fmu1.c                         |  22 +--
 src/fmu/common_fmu2.c                         |  26 +--
 .../components/specific_data/ConstantInput.c  |   4 +-
 .../model/parameters/ArrayParameterInput.c    |   4 +-
 .../model/parameters/ScalarParameterInput.c   |   4 +-
 src/reader/model/ports/ScalarPortInput.c      |   4 +-
 src/reader/model/ports/VectorPortInput.c      |   4 +-
 src/reader/ssp/Parameters.c                   |  37 +++--
 src/reader/ssp/Ports.c                        |  37 +++--
 src/reader/ssp/SpecificData.c                 |  31 ++--
 src/reader/ssp/Util.c                         |   4 +-
 src/storage/ChannelStorage.c                  |   2 +-
 src/storage/StorageBackendText.c              |   2 +-
 32 files changed, 363 insertions(+), 290 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index f58fc66..eedea53 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -68,7 +68,7 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
                 return RETURN_ERROR;
             }
 
-            if (info->type != Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))) {
+            if (!ChannelTypeEq(info->type, Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var)))) {
                 ComponentLog(comp, LOG_ERROR, "Variable types of %s do not match", channelName);
                 ComponentLog(comp, LOG_ERROR, "Expected: %s, Imported from FMU: %s",
                     ChannelTypeToString(info->type), ChannelTypeToString(Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))));
@@ -117,7 +117,7 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
             return RETURN_ERROR;
         }
 
-        if (info->type != Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))) {
+        if (!ChannelTypeEq(info->type, Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var)))) {
             ComponentLog(comp, LOG_ERROR, "Variable types of %s do not match", channelName);
             ComponentLog(comp, LOG_ERROR, "Expected: %s, Imported from FMU: %s",
                 ChannelTypeToString(info->type), ChannelTypeToString(Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))));
@@ -399,7 +399,7 @@ static McxStatus Fmu2SetupChannelIn(ObjectContainer /* Fmu2Values */ * vals, Dat
 
             val->SetChannel(val, info->channel);
 
-            if (val->val.type != info->type) {
+            if (!ChannelTypeEq(val->val.type, info->type)) {
                 ChannelValueInit(&val->val, info->type);
             }
             retVal = DatabusSetInReference(db, i,
@@ -437,7 +437,7 @@ static McxStatus Fmu2SetupChannelOut(ObjectContainer /* Fmu2Values */ * vals, Da
 
         val->SetChannel(val, info->channel);
 
-        if (val->val.type != info->type) {
+        if (!ChannelTypeEq(val->val.type, info->type)) {
             ChannelValueInit(&val->val, info->type);
         }
         retVal = DatabusSetOutReference(db, i,
@@ -552,24 +552,24 @@ static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Datab
                 return RETURN_ERROR;
             }
 
-            if (CHANNEL_INTEGER != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))) {
+            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelNameLo);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                             ChannelTypeToString(CHANNEL_INTEGER), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
+                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
                 return RETURN_ERROR;
             }
 
-            if (CHANNEL_INTEGER != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))) {
+            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelNameHi);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                             ChannelTypeToString(CHANNEL_INTEGER), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
+                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
                 return RETURN_ERROR;
             }
 
-            if (CHANNEL_INTEGER != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))) {
+            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelNameSize);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                             ChannelTypeToString(CHANNEL_INTEGER), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
+                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
                 return RETURN_ERROR;
             }
 
@@ -589,7 +589,7 @@ static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Datab
                 return RETURN_ERROR;
             }
 
-            if (info->type != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))) {
+            if (!ChannelTypeEq(info->type, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelName);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
                              ChannelTypeToString(info->type),
@@ -661,24 +661,24 @@ static McxStatus Fmu2ReadChannelOut(ObjectContainer /* Fmu2Value */ * vals, Data
                 return RETURN_ERROR;
             }
 
-            if (CHANNEL_INTEGER != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))) {
+            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelNameLo);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
-                    ChannelTypeToString(CHANNEL_INTEGER), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
+                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
                 return RETURN_ERROR;
             }
 
-            if (CHANNEL_INTEGER != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))) {
+            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelNameHi);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
-                    ChannelTypeToString(CHANNEL_INTEGER), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
+                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
                 return RETURN_ERROR;
             }
 
-            if (CHANNEL_INTEGER != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))) {
+            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelNameSize);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
-                    ChannelTypeToString(CHANNEL_INTEGER), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
+                    ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
                 return RETURN_ERROR;
             }
 
@@ -698,7 +698,7 @@ static McxStatus Fmu2ReadChannelOut(ObjectContainer /* Fmu2Value */ * vals, Data
                 return RETURN_ERROR;
             }
 
-            if (info->type != Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))) {
+            if (!ChannelTypeEq(info->type, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelName);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
                     ChannelTypeToString(info->type), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
diff --git a/src/components/comp_integrator.c b/src/components/comp_integrator.c
index 968c261..82fcc8f 100644
--- a/src/components/comp_integrator.c
+++ b/src/components/comp_integrator.c
@@ -56,13 +56,13 @@ static McxStatus Setup(Component * comp) {
     CompIntegrator * integrator = (CompIntegrator *) comp;
     McxStatus retVal = RETURN_OK;
 
-    retVal = DatabusSetInReference(comp->GetDatabus(comp), 0, &integrator->deriv, CHANNEL_DOUBLE);
+    retVal = DatabusSetInReference(comp->GetDatabus(comp), 0, &integrator->deriv, ChannelTypeDouble);
     if (RETURN_OK != retVal) {
         ComponentLog(comp, LOG_ERROR, "Could not register in channel reference");
         return RETURN_ERROR;
     }
 
-    retVal = DatabusSetOutReference(comp->GetDatabus(comp), 0, &integrator->state, CHANNEL_DOUBLE);
+    retVal = DatabusSetOutReference(comp->GetDatabus(comp), 0, &integrator->state, ChannelTypeDouble);
     if (RETURN_OK != retVal) {
         ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
         return RETURN_ERROR;
diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 57b6bc1..9002ee3 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -80,7 +80,7 @@ static McxStatus Setup(Component * comp) {
         size_t startIdx = vInfo->GetStartIndex(vInfo);
         size_t endIdx = vInfo->GetEndIndex(vInfo);
         size_t numCh = endIdx - startIdx;
-        retVal = DatabusSetInRefVector(db, i, startIdx, endIdx, integrator->deriv + nextIdx, CHANNEL_DOUBLE);
+        retVal = DatabusSetInRefVector(db, i, startIdx, endIdx, integrator->deriv + nextIdx, ChannelTypeDouble);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register in channel reference");
             return RETURN_ERROR;
@@ -94,7 +94,7 @@ static McxStatus Setup(Component * comp) {
         size_t startIdx = vInfo->GetStartIndex(vInfo);
         size_t endIdx = vInfo->GetEndIndex(vInfo);
         size_t numCh = endIdx - startIdx;
-        retVal = DatabusSetOutRefVector(db, i, startIdx, endIdx, integrator->state + nextIdx, CHANNEL_DOUBLE);
+        retVal = DatabusSetOutRefVector(db, i, startIdx, endIdx, integrator->state + nextIdx, ChannelTypeDouble);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
             return RETURN_ERROR;
diff --git a/src/core/Component.c b/src/core/Component.c
index 5c595ac..25d188c 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -216,7 +216,7 @@ static McxStatus DefineTimingChannel(Component * comp, const char * chName, cons
         return RETURN_ERROR;
     }
 
-    retVal = DatabusAddRTFactorChannel(comp->data->databus, chName, id, unit, reference, CHANNEL_DOUBLE);
+    retVal = DatabusAddRTFactorChannel(comp->data->databus, chName, id, unit, reference, ChannelTypeDouble);
 
     mcx_free(id);
 
diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index a684987..18714be 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -42,7 +42,7 @@ McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * va
 
     McxStatus retVal = RETURN_OK;
 
-    if (value->type != CHANNEL_DOUBLE && value->type != CHANNEL_INTEGER) {
+    if (!ChannelTypeEq(value->type, ChannelTypeDouble) && !ChannelTypeEq(value->type, ChannelTypeInteger)) {
         return RETURN_OK;
     }
 
@@ -107,7 +107,7 @@ static McxStatus RangeConversionConvert(Conversion * conversion, ChannelValue *
 
     McxStatus retVal = RETURN_OK;
 
-    if (ChannelValueType(value) != rangeConversion->type) {
+    if (!ChannelTypeEq(ChannelValueType(value), rangeConversion->type)) {
         mcx_log(LOG_ERROR, "Range conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(rangeConversion->type));
         return RETURN_ERROR;
     }
@@ -134,7 +134,7 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
         return RETURN_OK;
     }
 
-    if (min && max && ChannelValueType(min) != ChannelValueType(max)) {
+    if (min && max && !ChannelTypeEq(ChannelValueType(min), ChannelValueType(max))) {
         mcx_log(LOG_ERROR, "Range conversion: Types of max value and min value do not match");
         return RETURN_ERROR;
     }
@@ -150,8 +150,8 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
         conversion->type = ChannelValueType(max);
     }
 
-    if (!(conversion->type == CHANNEL_DOUBLE
-          || conversion->type == CHANNEL_INTEGER)) {
+    if (!(ChannelTypeEq(conversion->type, ChannelTypeDouble)
+          || ChannelTypeEq(conversion->type, ChannelTypeInteger))) {
         mcx_log(LOG_ERROR, "Range conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -163,7 +163,7 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
 }
 
 static int RangeConversionIsEmpty(RangeConversion * conversion) {
-    switch (conversion->type) {
+    switch (conversion->type.con) {
     case CHANNEL_DOUBLE:
         return
             (!conversion->min || * (double *) ChannelValueReference(conversion->min) == (-DBL_MAX)) &&
@@ -194,7 +194,7 @@ static RangeConversion * RangeConversionCreate(RangeConversion * rangeConversion
     rangeConversion->Setup = RangeConversionSetup;
     rangeConversion->IsEmpty = RangeConversionIsEmpty;
 
-    rangeConversion->type = CHANNEL_UNKNOWN;
+    rangeConversion->type = ChannelTypeUnknown;
 
     rangeConversion->min = NULL;
     rangeConversion->max = NULL;
@@ -263,8 +263,8 @@ static McxStatus UnitConversionConvert(Conversion * conversion, ChannelValue * v
 
     double val = 0.0;
 
-    if (ChannelValueType(value) != CHANNEL_DOUBLE) {
-        mcx_log(LOG_ERROR, "Unit conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(CHANNEL_DOUBLE));
+    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeDouble)) {
+        mcx_log(LOG_ERROR, "Unit conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
@@ -353,7 +353,7 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 
     McxStatus retVal = RETURN_OK;
 
-    if (value->type != CHANNEL_DOUBLE && value->type != CHANNEL_INTEGER) {
+    if (!ChannelTypeEq(value->type, ChannelTypeDouble) && !ChannelTypeEq(value->type, ChannelTypeInteger)) {
         return RETURN_OK;
     }
 
@@ -442,7 +442,7 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
         return RETURN_OK;
     }
 
-    if (factor && offset && ChannelValueType(factor) != ChannelValueType(offset)) {
+    if (factor && offset && !ChannelTypeEq(ChannelValueType(factor), ChannelValueType(offset))) {
         mcx_log(LOG_WARNING, "Linear conversion: Types of factor value (%s) and offset value (%s) do not match",
             ChannelTypeToString(ChannelValueType(factor)), ChannelTypeToString(ChannelValueType(offset)));
         return RETURN_ERROR;
@@ -454,8 +454,8 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
         conversion->type = ChannelValueType(offset);
     }
 
-    if (!(conversion->type == CHANNEL_DOUBLE
-          || conversion->type == CHANNEL_INTEGER)) {
+    if (!(ChannelTypeEq(conversion->type, ChannelTypeDouble)
+          || ChannelTypeEq(conversion->type, ChannelTypeInteger))) {
         mcx_log(LOG_WARNING, "Linear conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -467,7 +467,7 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
 }
 
 static int LinearConversionIsEmpty(LinearConversion * conversion) {
-    switch (conversion->type) {
+    switch (conversion->type.con) {
     case CHANNEL_DOUBLE:
         return
             (!conversion->factor || * (double *) ChannelValueReference(conversion->factor) == 1.0) &&
@@ -497,7 +497,7 @@ static LinearConversion * LinearConversionCreate(LinearConversion * linearConver
     linearConversion->Setup = LinearConversionSetup;
     linearConversion->IsEmpty = LinearConversionIsEmpty;
 
-    linearConversion->type = CHANNEL_UNKNOWN;
+    linearConversion->type = ChannelTypeUnknown;
 
     linearConversion->factor = NULL;
     linearConversion->offset = NULL;
@@ -544,72 +544,72 @@ McxStatus ConvertType(ChannelType fromType, ChannelType toType, ChannelValue * v
 }
 
 static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValue * value) {
-    if (ChannelValueType(value) != CHANNEL_INTEGER) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(CHANNEL_INTEGER));
+    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeInteger)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeInteger));
         return RETURN_ERROR;
     }
 
-    value->type = CHANNEL_DOUBLE;
+    value->type = ChannelTypeDouble;
     value->value.d = (double)value->value.i;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertDoubleInt(Conversion * conversion, ChannelValue * value) {
-    if (ChannelValueType(value) != CHANNEL_DOUBLE) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(CHANNEL_DOUBLE));
+    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeDouble)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
-    value->type = CHANNEL_INTEGER;
+    value->type = ChannelTypeInteger;
     value->value.i = (int)floor(value->value.d + 0.5);
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertBoolDouble(Conversion * conversion, ChannelValue * value) {
-    if (ChannelValueType(value) != CHANNEL_BOOL) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(CHANNEL_BOOL));
+    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeBool)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeBool));
         return RETURN_ERROR;
     }
 
-    value->type = CHANNEL_DOUBLE;
+    value->type = ChannelTypeDouble;
     value->value.d = (value->value.i != 0) ? 1. : 0.;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertDoubleBool(Conversion * conversion, ChannelValue * value) {
-    if (ChannelValueType(value) != CHANNEL_DOUBLE) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(CHANNEL_DOUBLE));
+    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeDouble)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
-    value->type = CHANNEL_BOOL;
+    value->type = ChannelTypeBool;
     value->value.i = (value->value.d > 0) ? 1 : 0;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertBoolInteger(Conversion * conversion, ChannelValue * value) {
-    if (ChannelValueType(value) != CHANNEL_BOOL) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(CHANNEL_BOOL));
+    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeBool)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeBool));
         return RETURN_ERROR;
     }
 
-    value->type = CHANNEL_INTEGER;
+    value->type = ChannelTypeInteger;
     value->value.i = (value->value.i != 0) ? 1 : 0;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, ChannelValue * value) {
-    if (ChannelValueType(value) != CHANNEL_INTEGER) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(CHANNEL_INTEGER));
+    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeInteger)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeInteger));
         return RETURN_ERROR;
     }
 
-    value->type = CHANNEL_BOOL;
+    value->type = ChannelTypeBool;
     value->value.i = (value->value.i != 0) ? 1 : 0;
 
     return RETURN_OK;
@@ -624,19 +624,19 @@ static McxStatus TypeConversionSetup(TypeConversion * typeConversion,
                                      ChannelType toType) {
     Conversion * conversion = (Conversion *) typeConversion;
 
-    if (fromType == toType) {
+    if (ChannelTypeEq(fromType, toType)) {
         conversion->convert = TypeConversionConvertId;
-    } else if (fromType == CHANNEL_INTEGER && toType == CHANNEL_DOUBLE) {
+    } else if (ChannelTypeEq(fromType, ChannelTypeInteger) && ChannelTypeEq(toType, ChannelTypeDouble)) {
         conversion->convert = TypeConversionConvertIntDouble;
-    } else if (fromType == CHANNEL_DOUBLE && toType == CHANNEL_INTEGER) {
+    } else if (ChannelTypeEq(fromType, ChannelTypeDouble) && ChannelTypeEq(toType, ChannelTypeInteger)) {
         conversion->convert = TypeConversionConvertDoubleInt;
-    } else if (fromType == CHANNEL_BOOL && toType == CHANNEL_DOUBLE) {
+    } else if (ChannelTypeEq(fromType, ChannelTypeBool) && ChannelTypeEq(toType, ChannelTypeDouble)) {
         conversion->convert = TypeConversionConvertBoolDouble;
-    } else if (fromType == CHANNEL_DOUBLE && toType == CHANNEL_BOOL) {
+    } else if (ChannelTypeEq(fromType, ChannelTypeDouble) && ChannelTypeEq(toType, ChannelTypeBool)) {
         conversion->convert = TypeConversionConvertDoubleBool;
-    } else if (fromType == CHANNEL_BOOL && toType == CHANNEL_INTEGER) {
+    } else if (ChannelTypeEq(fromType, ChannelTypeBool) && ChannelTypeEq(toType, ChannelTypeInteger)) {
         conversion->convert = TypeConversionConvertBoolInteger;
-    } else if (fromType == CHANNEL_INTEGER && toType == CHANNEL_BOOL) {
+    } else if (ChannelTypeEq(fromType, ChannelTypeInteger) && ChannelTypeEq(toType, ChannelTypeBool)) {
         conversion->convert = TypeConversionConvertIntegerBool;
     } else {
         mcx_log(LOG_ERROR, "Setup type conversion: Illegal conversion selected");
diff --git a/src/core/Databus.c b/src/core/Databus.c
index 3e1882a..121aaf6 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -1151,10 +1151,10 @@ McxStatus DatabusSetOutReference(Databus * db, size_t channel, const void * refe
         return RETURN_ERROR;
     }
 
-    if (CHANNEL_UNKNOWN != type) {
+    if (ChannelTypeIsValid(type)) {
         ChannelInfo * info = &((Channel *)out)->info;
-        if (info->type != type) {
-            if (ChannelInfoIsBinary(info) && (type == CHANNEL_BINARY || type == CHANNEL_BINARY_REFERENCE)) {
+        if (!ChannelTypeEq(info->type, type)) {
+            if (ChannelInfoIsBinary(info) && ChannelTypeIsBinary(type)) {
                 // ok
             } else {
                 mcx_log(LOG_ERROR, "Ports: Set out reference: Port %s has mismatching type %s, given: %s",
@@ -1187,7 +1187,7 @@ McxStatus DatabusSetOutReferenceFunction(Databus * db, size_t channel, const voi
     }
 
     info = &((Channel *)out)->info;
-    if (info->type != type) {
+    if (!ChannelTypeEq(info->type, type)) {
         mcx_log(LOG_ERROR, "Ports: Set out reference function: Port %s has mismatching type %s, given: %s",
             ChannelInfoGetName(info), ChannelTypeToString(info->type), ChannelTypeToString(type));
         return RETURN_ERROR;
@@ -1212,7 +1212,7 @@ McxStatus DatabusSetOutRefVectorChannel(Databus * db, size_t channel,
         mcx_log(LOG_ERROR, "Ports: Set out reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
         return RETURN_ERROR;
     }
-    if (CHANNEL_UNKNOWN == type) {
+    if (!ChannelTypeIsValid(type)) {
         mcx_log(LOG_ERROR, "Ports: Set out reference vector: Type of vector needs to be specified");
         return RETURN_ERROR;
     }
@@ -1261,7 +1261,7 @@ McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
         mcx_log(LOG_ERROR, "Ports: Set out reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
         return RETURN_ERROR;
     }
-    if (CHANNEL_UNKNOWN == type) {
+    if (!ChannelTypeIsValid(type)) {
         mcx_log(LOG_ERROR, "Ports: Set out reference vector: Type of vector needs to be specified");
         return RETURN_ERROR;
     }
@@ -1287,7 +1287,7 @@ McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
             return RETURN_ERROR;
         }
         ii = i - startIdx;
-        switch (type) {
+        switch (type.con) {
         case CHANNEL_DOUBLE:
             ref = (const void *) (((double *) reference) + ii);
             break;
@@ -1335,10 +1335,11 @@ McxStatus DatabusSetInReference(Databus * db, size_t channel, void * reference,
         return RETURN_ERROR;
     }
 
-    if (CHANNEL_UNKNOWN != type) {
+    if (ChannelTypeIsValid(type)) {
         info = &((Channel *)in)->info;
-        if (info->type != type) {
-            if (ChannelInfoIsBinary(info) && (type == CHANNEL_BINARY || type == CHANNEL_BINARY_REFERENCE)) {
+        if (!ChannelTypeEq(info->type, type)) {
+            // TODO: Remove ChannelInfoIsBinary, use ChannelTypeIsBinary instead?
+            if (ChannelInfoIsBinary(info) && ChannelTypeIsBinary(type)) {
                 // ok
             } else {
                 mcx_log(LOG_ERROR, "Ports: Set in-reference: Port %s has mismatching type %s, given: %s",
@@ -1360,7 +1361,7 @@ McxStatus DatabusSetInRefVector(Databus * db, size_t channel, size_t startIdx, s
         mcx_log(LOG_ERROR, "Ports: Set in reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
         return RETURN_ERROR;
     }
-    if (CHANNEL_UNKNOWN == type) {
+    if (!ChannelTypeIsValid(type)) {
         mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector needs to be specified");
         return RETURN_ERROR;
     }
@@ -1385,11 +1386,11 @@ McxStatus DatabusSetInRefVector(Databus * db, size_t channel, size_t startIdx, s
             return RETURN_ERROR;
         }
         ii = i - startIdx;
-        if (CHANNEL_DOUBLE == type) {
+        if (ChannelTypeEq(ChannelTypeDouble, type)) {
             ref = (void *) (((double *) reference) + ii);
-        } else if (CHANNEL_INTEGER == type) {
+        } else if (ChannelTypeEq(ChannelTypeInteger, type)) {
             ref = (void *) (((int *) reference) + ii);
-        } else if (CHANNEL_BOOL == type) {
+        } else if (ChannelTypeEq(ChannelTypeBool, type)) {
             ref = (void *) (((int *) reference) + ii);
         } else {
             mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector not allowed");
@@ -1417,7 +1418,7 @@ McxStatus DatabusSetInRefVectorChannel(Databus * db, size_t channel,
         mcx_log(LOG_ERROR, "Ports: Set in reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
         return RETURN_ERROR;
     }
-    if (CHANNEL_UNKNOWN == type) {
+    if (!ChannelTypeIsValid(type)) {
         mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector needs to be specified");
         return RETURN_ERROR;
     }
diff --git a/src/core/Model.c b/src/core/Model.c
index 3c7246b..5894488 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -136,15 +136,15 @@ static void UpdateBinaryChannelTypes(Vector * connInfos, Task * task) {
             mcx_log(LOG_DEBUG, "Fast binary channel requirements fulfilled for connection %s", buffer);
             mcx_free(buffer);
 
-            trgInfo->type = CHANNEL_BINARY_REFERENCE;
-            srcInfo->type = CHANNEL_BINARY_REFERENCE;
+            trgInfo->type = ChannelTypeBinaryReference;
+            srcInfo->type = ChannelTypeBinaryReference;
         } else {
             char * buffer = ConnectionInfoConnectionString(info);
             mcx_log(LOG_DEBUG, "Using binary channels for connection %s", buffer);
             mcx_free(buffer);
 
-            trgInfo->type = CHANNEL_BINARY;
-            srcInfo->type = CHANNEL_BINARY;
+            trgInfo->type = ChannelTypeBinary;
+            srcInfo->type = ChannelTypeBinary;
         }
     }
 }
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 9643db5..56223fa 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -15,6 +15,7 @@
 
 #include "core/channels/ChannelInfo.h"
 #include "core/channels/Channel.h"
+#include "core/channels/ChannelValue.h"
 #include "core/channels/Channel_impl.h"
 
 #ifdef __cplusplus
@@ -58,7 +59,7 @@ static Channel * ChannelCreate(Channel * channel) {
 
     channel->isDefinedDuringInit = FALSE;
     channel->internalValue = NULL;
-    ChannelValueInit(&channel->value, CHANNEL_UNKNOWN);
+    ChannelValueInit(&channel->value, ChannelTypeUnknown);
 
     channel->Setup = ChannelSetup;
     channel->IsDefinedDuringInit = ChannelIsDefinedDuringInit;
@@ -128,7 +129,7 @@ static McxStatus ChannelInSetReference(ChannelIn * in, void * reference, Channel
         return RETURN_ERROR;
     }
 
-    if (CHANNEL_UNKNOWN != type) {
+    if (ChannelTypeIsValid(type)) {
         if (!info) {
             mcx_log(LOG_ERROR, "Port %s: Set inport reference: Port not set up", ChannelInfoGetLogName(info));
             return RETURN_ERROR;
@@ -244,7 +245,7 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         return RETURN_OK;
     }
 
-    if (time->startTime < MCX_DEBUG_LOG_TIME && info->type == CHANNEL_DOUBLE) {
+    if (time->startTime < MCX_DEBUG_LOG_TIME && ChannelTypeEq(info->type, ChannelTypeDouble)) {
         MCX_DEBUG_LOG("[%f] CH IN  (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, * (double *) channel->GetValueReference(channel));
     }
 
@@ -277,7 +278,7 @@ static int ChannelInIsDiscrete(ChannelIn * in) {
 }
 
 static int ChannelInIsConnected(Channel * channel) {
-    if (channel->info.type != CHANNEL_UNKNOWN && channel->info.connected) {
+    if (ChannelTypeIsValid(channel->info.type) && channel->info.connected) {
         return TRUE;
     } else {
         ChannelIn * in = (ChannelIn *) channel;
@@ -318,7 +319,7 @@ static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection,
     // setup unit conversion
     inInfo = &channel->info;
 
-    if (inInfo->type == CHANNEL_DOUBLE) {
+    if (ChannelTypeEq(inInfo->type, ChannelTypeDouble)) {
         in->data->unitConversion = (UnitConversion *) object_create(UnitConversion);
         retVal = in->data->unitConversion->Setup(in->data->unitConversion,
                                                  unit,
@@ -334,7 +335,7 @@ static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection,
     }
 
     // setup type conversion
-    if (inInfo->type != type) {
+    if (!ChannelTypeEq(inInfo->type, type)) {
         in->data->typeConversion = (TypeConversion *) object_create(TypeConversion);
         retVal = in->data->typeConversion->Setup(in->data->typeConversion,
                                                  type,
@@ -356,7 +357,7 @@ static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
     retVal = channel->Setup(channel, info); // call base-class function
 
     // types
-    if (info->type == CHANNEL_UNKNOWN) {
+    if (!ChannelTypeIsValid(info->type)) {
         mcx_log(LOG_ERROR, "Port %s: Setup inport: Unknown type", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
@@ -384,7 +385,8 @@ static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
     // unit conversion is setup when a connection is set
 
     // min/max conversions are only used for double types
-    if (info->type == CHANNEL_DOUBLE || info->type == CHANNEL_INTEGER)
+    if (ChannelTypeEq(info->type, ChannelTypeDouble)
+        || ChannelTypeEq(info->type, ChannelTypeInteger))
     {
         ChannelValue * min = info->min;
         ChannelValue * max = info->max;
@@ -509,7 +511,7 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
     retVal = channel->Setup(channel, info); // call base-class function
 
     // default value
-    if (info->type == CHANNEL_UNKNOWN) {
+    if (!ChannelTypeIsValid(info->type)) {
         mcx_log(LOG_ERROR, "Port %s: Setup outport: Unknown type", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
@@ -522,7 +524,8 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
 
 
     // min/max conversions are only used for double types
-    if (info->type == CHANNEL_DOUBLE || info->type == CHANNEL_INTEGER)
+    if (ChannelTypeEq(info->type, ChannelTypeDouble)
+        || ChannelTypeEq(info->type, ChannelTypeInteger))
     {
         out->data->rangeConversion = (RangeConversion *) object_create(RangeConversion);
         retVal = out->data->rangeConversion->Setup(out->data->rangeConversion, min, max);
@@ -624,9 +627,9 @@ static McxStatus ChannelOutSetReference(ChannelOut * out, const void * reference
         mcx_log(LOG_ERROR, "Port %s: Set outport reference: Reference already set", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
-    if (CHANNEL_UNKNOWN != type) {
-        if (info->type != type) {
-            if (ChannelInfoIsBinary(info) && (type == CHANNEL_BINARY || type == CHANNEL_BINARY_REFERENCE)) {
+    if (ChannelTypeIsValid(type)) {
+        if (!ChannelTypeEq(info->type, type)) {
+            if (ChannelInfoIsBinary(info) && ChannelTypeIsBinary(type)) {
                 // ok
             } else {
                 mcx_log(LOG_ERROR, "Port %s: Set outport reference: Mismatching types", ChannelInfoGetLogName(info));
@@ -649,8 +652,8 @@ static McxStatus ChannelOutSetReferenceFunction(ChannelOut * out, const proc * r
     }
 
     info = &channel->info;
-    if (CHANNEL_UNKNOWN != type) {
-        if (info->type != type) {
+    if (ChannelTypeIsValid(type)) {
+        if (!ChannelTypeEq(info->type, type)) {
             mcx_log(LOG_ERROR, "Port %s: Set outport function: Mismatching types", ChannelInfoGetLogName(info));
             return RETURN_ERROR;
         }
@@ -714,7 +717,7 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
         } else {
 #ifdef MCX_DEBUG
             if (time->startTime < MCX_DEBUG_LOG_TIME) {
-                if (CHANNEL_DOUBLE == info->type) {
+                if (ChannelTypeEq(ChannelTypeDouble, info->type)) {
                     MCX_DEBUG_LOG("[%f] CH OUT (%s) (%f, %f)",
                                   time->startTime,
                                   ChannelInfoGetLogName(info),
@@ -731,7 +734,8 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
         }
 
         // Apply conversion
-        if (info->type == CHANNEL_DOUBLE || info->type == CHANNEL_INTEGER) {
+        if (ChannelTypeEq(info->type, ChannelTypeDouble) ||
+            ChannelTypeEq(info->type, ChannelTypeInteger)) {
             ChannelValue * val = &channel->value;
 
             // range
@@ -767,7 +771,7 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
     }
 
 
-    if (CHANNEL_DOUBLE == info->type) {
+    if (ChannelTypeEq(ChannelTypeDouble, info->type)) {
         const double * val = NULL;
 
         {
@@ -882,8 +886,8 @@ static McxStatus ChannelLocalSetReference(ChannelLocal * local,
         mcx_log(LOG_ERROR, "Port %s: Set local value reference: Reference already set", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
-    if (CHANNEL_UNKNOWN != type) {
-        if (info->type != type) {
+    if (ChannelTypeIsValid(type)) {
+        if (!ChannelTypeEq(info->type, type)) {
             mcx_log(LOG_ERROR, "Port %s: Set local value reference: Mismatching types", ChannelInfoGetLogName(info));
             return RETURN_ERROR;
         }
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index 7db9b5f..e8c72ab 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -36,7 +36,7 @@ const char * ChannelInfoGetName(const ChannelInfo * info) {
 }
 
 int ChannelInfoIsBinary(const ChannelInfo * info) {
-    return info->type == CHANNEL_BINARY || info->type == CHANNEL_BINARY_REFERENCE;
+    return ChannelTypeIsBinary(info->type);
 }
 
 static McxStatus ChannelInfoSetString(char ** dst, const char * src) {
@@ -75,7 +75,7 @@ McxStatus ChannelInfoSetUnit(ChannelInfo * info, const char * name) {
 }
 
 McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType type) {
-    if (info->type != CHANNEL_UNKNOWN) {
+    if (ChannelTypeIsValid(info->type)) {
         mcx_log(LOG_ERROR, "Port %s: Type already set", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
@@ -277,7 +277,7 @@ void ChannelInfoDestroy(ChannelInfo * info) {
 
     info->channel = NULL;
     info->initialValueIsExact = FALSE;
-    info->type = CHANNEL_UNKNOWN;
+    info->type = ChannelTypeUnknown;
     info->connected = FALSE;
     info->writeResult = TRUE;
 }
@@ -300,7 +300,7 @@ McxStatus ChannelInfoInit(ChannelInfo * info) {
     info->scale = NULL;
     info->offset = NULL;
 
-    info->type = CHANNEL_UNKNOWN;
+    info->type = ChannelTypeUnknown;
     info->defaultValue = NULL;
     info->initialValue = NULL;
 
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index b227785..cecaf9c 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -16,7 +16,70 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType type) {
+ChannelType ChannelTypeUnknown = { CHANNEL_UNKNOWN, NULL};
+ChannelType ChannelTypeInteger = { CHANNEL_INTEGER, NULL};
+ChannelType ChannelTypeDouble = { CHANNEL_DOUBLE, NULL};
+ChannelType ChannelTypeBool = { CHANNEL_BOOL, NULL};
+ChannelType ChannelTypeString = { CHANNEL_STRING, NULL};
+ChannelType ChannelTypeBinary = { CHANNEL_BINARY, NULL};
+ChannelType ChannelTypeBinaryReference = { CHANNEL_BINARY_REFERENCE, NULL};
+
+ChannelType ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims) {
+    ChannelType array;
+
+    if (!inner) {
+        return ChannelTypeUnknown;
+    }
+
+    array.con = CHANNEL_ARRAY;
+    array.ty.a.inner = inner;
+    array.ty.a.numDims = numDims;
+    array.ty.a.dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
+    if (!array.ty.a.dims) {
+        return ChannelTypeUnknown;
+    }
+
+    memcpy(array.ty.a.dims, dims, sizeof(size_t)*numDims);
+
+    return array;
+}
+
+int ChannelTypeIsValid(ChannelType a) {
+    return a.con != CHANNEL_UNKNOWN;
+}
+
+int ChannelTypeIsScalar(ChannelType a) {
+    return a.con != CHANNEL_ARRAY;
+}
+
+int ChannelTypeIsArray(ChannelType a) {
+    return a.con == CHANNEL_ARRAY;
+}
+
+int ChannelTypeIsBinary(ChannelType a) {
+    return a.con == CHANNEL_BINARY || a.con == CHANNEL_BINARY_REFERENCE;
+}
+
+int ChannelTypeEq(ChannelType a, ChannelType b) {
+    if (a.con == CHANNEL_ARRAY && b.con == CHANNEL_ARRAY) {
+        size_t i = 0;
+        if (a.ty.a.numDims != b.ty.a.numDims) {
+            return 0;
+        }
+        for (i = 0; i < a.ty.a.numDims; i++) {
+            if (a.ty.a.dims[i] != b.ty.a.dims[i]) {
+                return 0;
+            }
+        }
+        return 1;
+    } else if ((a.con == CHANNEL_BINARY || a.con == CHANNEL_BINARY_REFERENCE) &&
+        (b.con == CHANNEL_BINARY || b.con == CHANNEL_BINARY_REFERENCE)) {
+    } else {
+        return a.con == b.con;
+    }
+}
+
+McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType inner) {
     a->numDims = numDims;
     a->dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
     if (!a->dims) {
@@ -24,8 +87,8 @@ McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType type)
     }
     memcpy(a->dims, dims, sizeof(size_t) * numDims);
 
-    a->type = type;
-    a->data = (void *) mcx_calloc(ChannelValueTypeSize(type), array_num_elements(a));
+    a->type = inner;
+    a->data = (void *) mcx_calloc(ChannelValueTypeSize(inner), array_num_elements(a));
     if (!a->data) {
         return RETURN_ERROR;
     }
@@ -73,19 +136,19 @@ void ChannelValueInit(ChannelValue * value, ChannelType type) {
 }
 
 void ChannelValueDataDestructor(ChannelValueData * data, ChannelType type) {
-    if (type == CHANNEL_STRING) {
+    if (type.con == CHANNEL_STRING) {
         if (data->s) {
             mcx_free(data->s);
             data->s = NULL;
         }
-    } else if (type == CHANNEL_BINARY) {
+    } else if (type.con == CHANNEL_BINARY) {
         if (data->b.data) {
             mcx_free(data->b.data);
             data->b.data = NULL;
         }
-    } else if (type == CHANNEL_BINARY_REFERENCE) {
+    } else if (type.con == CHANNEL_BINARY_REFERENCE) {
         // do not free references to binary, they are not owned by the ChannelValueData
-    } else if (type == CHANNEL_ARRAY) {
+    } else if (type.con == CHANNEL_ARRAY) {
         if (data->a.dims) {
             mcx_free(data->a.dims);
             data->a.dims = NULL;
@@ -113,7 +176,7 @@ char * ChannelValueToString(ChannelValue * value) {
     const uint32_t digits_of_exp = 4; // = (mcx_digits10(DBL_MAX_10_EXP) + 1 /* sign */
     char * buffer = NULL;
 
-    switch (value->type) {
+    switch (value->type.con) {
     case CHANNEL_DOUBLE:
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         buffer = (char *) mcx_malloc(sizeof(char) * length);
@@ -172,9 +235,6 @@ char * ChannelValueToString(ChannelValue * value) {
             }
         }
         break;
-    case CHANNEL_ARRAY:
-        mcx_log(LOG_ERROR, "TODO: ChannelValueToString unimplemented for CHANNEL_ARRAY");
-        return NULL;
     default:
         return NULL;
     }
@@ -189,7 +249,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
     const uint32_t digits_of_exp = 4; // = (mcx_digits10(DBL_MAX_10_EXP) + 1 /* sign */
     const char * doubleFmt = "%*.*E";
 
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         if (len < length) {
@@ -248,9 +308,6 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
             }
         }
         break;
-    case CHANNEL_ARRAY:
-        mcx_log(LOG_ERROR, "TODO: ChannelValueToString unimplemented for CHANNEL_ARRAY");
-        return RETURN_ERROR;
     default:
         mcx_log(LOG_DEBUG, "Port value to string: Unknown type");
         return RETURN_ERROR;
@@ -268,7 +325,7 @@ ChannelType ChannelValueType(ChannelValue * value) {
 }
 
 void * ChannelValueReference(ChannelValue * value) {
-    if (value->type == CHANNEL_UNKNOWN) {
+    if (value->type.con == CHANNEL_UNKNOWN) {
         return NULL;
     } else {
         return &value->value;
@@ -276,7 +333,7 @@ void * ChannelValueReference(ChannelValue * value) {
 }
 
 void ChannelValueDataInit(ChannelValueData * data, ChannelType type) {
-    switch (type) {
+    switch (type.con) {
         case CHANNEL_DOUBLE:
             data->d = 0.0;
             break;
@@ -308,7 +365,7 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType type) {
 McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference) {
     if (!reference) { return RETURN_OK; } // TODO: change to ERROR
 
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         data->d = * (double *) reference;
         break;
@@ -382,7 +439,7 @@ McxStatus ChannelValueSetFromReference(ChannelValue * value, const void * refere
 }
 
 McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
-    if (value->type != source->type) {
+    if (!ChannelTypeEq(value->type, source->type)) {
         mcx_log(LOG_ERROR, "Port: Set: Mismatching types. Source type: %s, target type: %s",
             ChannelTypeToString(source->type), ChannelTypeToString(value->type));
         return RETURN_ERROR;
@@ -396,7 +453,7 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
 }
 
 McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
-    switch (value->type) {
+    switch (value->type.con) {
     case CHANNEL_DOUBLE:
         * (double *) reference = value->value.d;
         break;
@@ -471,7 +528,7 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
 // TODO: invalid size should be (-1)
 #ifdef __cplusplus
 size_t ChannelValueTypeSize(ChannelType type) {
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         return sizeof(ChannelValueData::d);
     case CHANNEL_INTEGER:
@@ -491,7 +548,7 @@ size_t ChannelValueTypeSize(ChannelType type) {
 #else //__cplusplus
 size_t ChannelValueTypeSize(ChannelType type) {
     ChannelValueData value;
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         return sizeof(value.d);
     case CHANNEL_INTEGER:
@@ -511,17 +568,11 @@ size_t ChannelValueTypeSize(ChannelType type) {
 #endif //__cplusplus
 
 int ChannelTypeMatch(ChannelType a, ChannelType b) {
-    if ((CHANNEL_BINARY == a || CHANNEL_BINARY_REFERENCE == a) &&
-        (CHANNEL_BINARY == b || CHANNEL_BINARY_REFERENCE == b)) {
-        return 1;
-    } else {
-        return a == b;
-    }
-    // TODO: Ignores array dimensions
+    return ChannelTypeEq(a, b);
 }
 
 const char * ChannelTypeToString(ChannelType type) {
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_UNKNOWN:
         return "Unknown";
     case CHANNEL_DOUBLE:
@@ -559,49 +610,41 @@ ChannelValue * ChannelValueClone(ChannelValue * value) {
 
 
 int ChannelValueLeq(ChannelValue * val1, ChannelValue * val2) {
-    if (ChannelValueType(val1) != ChannelValueType(val2)) {
+    if (!ChannelTypeEq(val1->type, val2->type)) {
         return 0;
     }
 
-    switch (ChannelValueType(val1)) {
+    switch (ChannelValueType(val1).con) {
     case CHANNEL_DOUBLE:
         return val1->value.d <= val2->value.d;
     case CHANNEL_INTEGER:
         return val1->value.i <= val2->value.i;
-    case CHANNEL_ARRAY:
-        // TODO: val1 <= val1 <=> val1[i,j] <= val2[i,j] \forall i,j?
-        mcx_log(LOG_ERROR, "TODO: ChannelValueLeq unimplemented for CHANNEL_ARRAY");
-        exit(-1);
     default:
         return 0;
     }
 }
 
 int ChannelValueGeq(ChannelValue * val1, ChannelValue * val2) {
-    if (ChannelValueType(val1) != ChannelValueType(val2)) {
+    if (!ChannelTypeEq(val1->type, val2->type)) {
         return 0;
     }
 
-    switch (ChannelValueType(val1)) {
+    switch (ChannelValueType(val1).con) {
     case CHANNEL_DOUBLE:
         return val1->value.d >= val2->value.d;
     case CHANNEL_INTEGER:
         return val1->value.i >= val2->value.i;
-    case CHANNEL_ARRAY:
-        // TODO: val1 >= val1 <=> val1[i,j] >= val2[i,j] \forall i,j?
-        mcx_log(LOG_ERROR, "TODO: ChannelValueGeq unimplemented for CHANNEL_ARRAY");
-        exit(-1);
     default:
         return 0;
     }
 }
 
 int ChannelValueEq(ChannelValue * val1, ChannelValue * val2) {
-    if (ChannelValueType(val1) != ChannelValueType(val2)) {
+    if (!ChannelTypeEq(val1->type, val2->type)) {
         return 0;
     }
 
-    switch (ChannelValueType(val1)) {
+    switch (ChannelValueType(val1).con) {
     case CHANNEL_DOUBLE:
         return val1->value.d == val2->value.d;
     case CHANNEL_BOOL:
@@ -609,35 +652,25 @@ int ChannelValueEq(ChannelValue * val1, ChannelValue * val2) {
         return val1->value.i == val2->value.i;
     case CHANNEL_STRING:
         return !strcmp(val1->value.s, val2->value.s);
-    case CHANNEL_ARRAY:
-        // TODO: val1 == val1 <=> val1[i,j] == val2[i,j] \forall i,j?
-        mcx_log(LOG_ERROR, "TODO: ChannelValueEq unimplemented for CHANNEL_ARRAY");
-        exit(-1);
     default:
         return 0;
     }
 }
 
 McxStatus ChannelValueAddOffset(ChannelValue * val, ChannelValue * offset) {
-    if (ChannelValueType(val) != ChannelValueType(offset)) {
+    if (!ChannelTypeEq(val->type, offset->type)) {
         mcx_log(LOG_ERROR, "Port: Add offset: Mismatching types. Value type: %s, offset type: %s",
             ChannelTypeToString(ChannelValueType(val)), ChannelTypeToString(ChannelValueType(offset)));
         return RETURN_ERROR;
     }
 
-    switch (ChannelValueType(val)) {
+    switch (ChannelValueType(val).con) {
     case CHANNEL_DOUBLE:
         val->value.d += offset->value.d;
         return RETURN_OK;
     case CHANNEL_INTEGER:
         val->value.i += offset->value.i;
         return RETURN_OK;
-    case CHANNEL_ARRAY:
-        // TODO: val matrix, offset matrix
-        //       val matrix, offset scalar
-        // needs check above relaxed
-        mcx_log(LOG_ERROR, "TODO: ChannelValueAddOffset unimplemented for CHANNEL_ARRAY");
-        exit(-1);
     default:
         mcx_log(LOG_ERROR, "Port: Add offset: Type %s not allowed", ChannelTypeToString(ChannelValueType(val)));
         return RETURN_ERROR;
@@ -645,25 +678,19 @@ McxStatus ChannelValueAddOffset(ChannelValue * val, ChannelValue * offset) {
 }
 
 McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
-    if (ChannelValueType(val) != ChannelValueType(factor)) {
+    if (!ChannelTypeEq(val->type, factor->type)) {
         mcx_log(LOG_ERROR, "Port: Scale: Mismatching types. Value type: %s, factor type: %s",
             ChannelTypeToString(ChannelValueType(val)), ChannelTypeToString(ChannelValueType(factor)));
         return RETURN_ERROR;
     }
 
-    switch (ChannelValueType(val)) {
+    switch (ChannelValueType(val).con) {
     case CHANNEL_DOUBLE:
         val->value.d *= factor->value.d;
         return RETURN_OK;
     case CHANNEL_INTEGER:
         val->value.i *= factor->value.i;
         return RETURN_OK;
-    case CHANNEL_ARRAY:
-        // TODO: val matrix, offset scalar
-        //       val matrix, offset matrix: matrix multiplication?
-        // needs check above relaxed
-        mcx_log(LOG_ERROR, "TODO: ChannelValueScale unimplemented for CHANNEL_ARRAY");
-        exit(-1);
     default:
         mcx_log(LOG_ERROR, "Port: Scale: Type %s not allowed", ChannelTypeToString(ChannelValueType(val)));
         return RETURN_ERROR;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index e1b21c0..c0ba1aa 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -12,13 +12,14 @@
 #define MCX_CORE_CHANNELS_CHANNEL_VALUE_H
 
 #include "CentralParts.h"
+#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
 // possible types of values that can be put on channels
-typedef enum ChannelType {
+typedef enum ChannelTypeConstructor {
     CHANNEL_UNKNOWN = 0,
     CHANNEL_DOUBLE = 1,
     CHANNEL_INTEGER = 2,
@@ -27,8 +28,44 @@ typedef enum ChannelType {
     CHANNEL_BINARY = 5,
     CHANNEL_BINARY_REFERENCE = 6,
     CHANNEL_ARRAY = 7,
+} ChannelTypeConstructor;
+
+typedef struct ChannelTypeArrayType {
+    struct ChannelType * inner;
+    size_t numDims;
+    size_t * dims;
+} ChannelTypeArrayType;
+
+typedef struct ChannelType {
+    ChannelTypeConstructor con;
+    union {
+        ChannelTypeArrayType a;
+    } ty;
 } ChannelType;
 
+// pre-defined types
+extern ChannelType ChannelTypeUnknown;
+extern ChannelType ChannelTypeInteger;
+extern ChannelType ChannelTypeDouble;
+extern ChannelType ChannelTypeBool;
+extern ChannelType ChannelTypeString;
+extern ChannelType ChannelTypeBinary;
+extern ChannelType ChannelTypeBinaryReference;
+ChannelType ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims);
+
+int ChannelTypeIsValid(ChannelType a);
+int ChannelTypeIsScalar(ChannelType a);
+int ChannelTypeIsArray(ChannelType a);
+int ChannelTypeIsBinary(ChannelType a);
+
+int ChannelTypeEq(ChannelType a, ChannelType b);
+
+typedef struct MapStringChannelType {
+    const char * key;
+    ChannelType * value;
+} MapStringChannelType;
+
+
 typedef struct {
     double startTime;
     double endTime;
@@ -51,6 +88,7 @@ typedef struct {
     void * data;
 } array;
 
+McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType type);
 int array_dims_match(array * a, array * b);
 size_t array_num_elements(array * a);
 
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 3787984..1e6e0d3 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -976,7 +976,7 @@ ChannelFilter * FilterFactory(Connection * connection) {
     Task * task = model->GetTask(model);
     int useInputsAtEndTime = task->useInputsAtEndTime;
 
-    if (ConnectionInfoGetType(info) == CHANNEL_DOUBLE) {
+    if (ChannelTypeEq(ConnectionInfoGetType(info), ChannelTypeDouble)) {
         if (!(INTERVAL_COUPLING == params->interpolationInterval && INTERVAL_SYNCHRONIZATION == params->extrapolationInterval)) {
             mcx_log(LOG_WARNING, "The use of inter/extrapolation interval settings for double is not supported");
         }
@@ -1061,7 +1061,7 @@ ChannelFilter * FilterFactory(Connection * connection) {
         filter = (ChannelFilter *) discreteFilter;
     }
 
-    if (NULL == filter && ConnectionInfoGetType(info) == CHANNEL_DOUBLE) {
+    if (NULL == filter && ChannelTypeEq(ConnectionInfoGetType(info), ChannelTypeDouble)) {
         // TODO: add a check to avoid filters for non-multirate cases
 
         size_t memFilterHist = MemoryFilterHistorySize(info, 0);
@@ -1170,7 +1170,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
         // If the value is taken from the in channel, the value must be converted.
         // TODO: It might be a better idea to use the type of the in channel as type of the connection.
         // Such a change might be more complex to implement.
-        if (inValue->type != store->type) {
+        if (!ChannelTypeEq(inValue->type, store->type)) {
             TypeConversion * typeConv = (TypeConversion *) object_create(TypeConversion);
             Conversion * conv = (Conversion *) typeConv;
             retVal = typeConv->Setup(typeConv, inValue->type, store->type);
@@ -1410,7 +1410,7 @@ static Connection * ConnectionCreate(Connection * connection) {
 
     connection->isActiveDependency_ = TRUE;
 
-    ChannelValueInit(&connection->store_, CHANNEL_UNKNOWN);
+    ChannelValueInit(&connection->store_, ChannelTypeUnknown);
 
     connection->state_ = InCommunicationMode;
 
diff --git a/src/core/connections/ConnectionInfo.c b/src/core/connections/ConnectionInfo.c
index c5e7fba..298091e 100644
--- a/src/core/connections/ConnectionInfo.c
+++ b/src/core/connections/ConnectionInfo.c
@@ -34,34 +34,34 @@ ChannelType ConnectionInfoGetType(ConnectionInfo * info) {
     Databus * db = NULL;
     ChannelInfo * outInfo = NULL;
 
-    if (CHANNEL_UNKNOWN != info->connType_) {
+    if (ChannelTypeIsValid(info->connType_)) {
         return info->connType_;
     }
 
     if (NULL == info) {
         mcx_log(LOG_DEBUG, "ConnectionInfo: GetType: no info available");
-        return CHANNEL_UNKNOWN;
+        return ChannelTypeUnknown;
     }
     source = info->sourceComponent;
     if (NULL == source) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_DEBUG, "ConnectionInfo '%s': GetType: no source available", buffer);
         mcx_free(buffer);
-        return CHANNEL_UNKNOWN;
+        return ChannelTypeUnknown;
     }
     db = source->GetDatabus(source);
     if (NULL == db) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_DEBUG, "ConnectionInfo '%s': GetType: no databus available", buffer);
         mcx_free(buffer);
-        return CHANNEL_UNKNOWN;
+        return ChannelTypeUnknown;
     }
     outInfo = DatabusInfoGetChannel(DatabusGetOutInfo(db), info->sourceChannel);
     if (!outInfo) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_DEBUG, "ConnectionInfo '%s': GetType: no outinfo available", buffer);
         mcx_free(buffer);
-        return CHANNEL_UNKNOWN;
+        return ChannelTypeUnknown;
     }
 
     info->connType_ = outInfo->type;
@@ -158,7 +158,7 @@ McxStatus ConnectionInfoInit(ConnectionInfo * info) {
 
     info->hasDiscreteTarget = FALSE;
 
-    info->connType_ = CHANNEL_UNKNOWN;
+    info->connType_ = ChannelTypeUnknown;
 
     return RETURN_OK;
 }
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index cbf73ed..507a314 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -23,7 +23,7 @@ extern "C" {
 static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionData * data) {
     data->filter = NULL;
 
-    ChannelValueInit(&data->store, CHANNEL_UNKNOWN);
+    ChannelValueInit(&data->store, ChannelTypeUnknown);
 
     return data;
 }
diff --git a/src/core/connections/filters/DiscreteFilter.c b/src/core/connections/filters/DiscreteFilter.c
index 279ca3a..a9e25b7 100644
--- a/src/core/connections/filters/DiscreteFilter.c
+++ b/src/core/connections/filters/DiscreteFilter.c
@@ -69,8 +69,8 @@ static DiscreteFilter * DiscreteFilterCreate(DiscreteFilter * discreteFilter) {
 
     discreteFilter->Setup = DiscreteFilterSetup;
 
-    ChannelValueInit(&discreteFilter->lastSynchronizationStepValue, CHANNEL_UNKNOWN);
-    ChannelValueInit(&discreteFilter->lastCouplingStepValue, CHANNEL_UNKNOWN);
+    ChannelValueInit(&discreteFilter->lastSynchronizationStepValue, ChannelTypeUnknown);
+    ChannelValueInit(&discreteFilter->lastCouplingStepValue, ChannelTypeUnknown);
 
     return discreteFilter;
 }
diff --git a/src/core/connections/filters/MemoryFilter.c b/src/core/connections/filters/MemoryFilter.c
index b4fddd0..b5bf3b3 100644
--- a/src/core/connections/filters/MemoryFilter.c
+++ b/src/core/connections/filters/MemoryFilter.c
@@ -39,7 +39,7 @@ static McxStatus MemoryFilterSetValue(ChannelFilter * filter, double time, Chann
 
 #ifdef MCX_DEBUG
         if (time < MCX_DEBUG_LOG_TIME) {
-            if (memoryFilter->valueHistoryWrite[0].type == CHANNEL_DOUBLE) {
+            if (ChannelTypeEq(memoryFilter->valueHistoryWrite[0].type, ChannelTypeDouble)) {
                 MCX_DEBUG_LOG("MemoryFilter: F SET (%x) (%f, %f)", filter, time, value.d);
             } else {
                 MCX_DEBUG_LOG("MemoryFilter: F SET (%x) (%f, -)", filter, time);
@@ -62,7 +62,7 @@ static ChannelValueData MemoryFilterGetValueReverse(ChannelFilter * filter, doub
         if (double_eq(memoryFilter->timeHistoryRead[i], time)) {
 #ifdef MCX_DEBUG
             if (time < MCX_DEBUG_LOG_TIME) {
-                if (memoryFilter->valueHistoryRead[i].type == CHANNEL_DOUBLE) {
+                if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
                 } else {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, -)", filter, time);
@@ -95,7 +95,7 @@ static ChannelValueData MemoryFilterGetValueReverse(ChannelFilter * filter, doub
 
 #ifdef MCX_DEBUG
     if (time < MCX_DEBUG_LOG_TIME) {
-        if (memoryFilter->valueHistoryRead[i].type == CHANNEL_DOUBLE) {
+        if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
         } else {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, -)", filter, time);
@@ -116,7 +116,7 @@ static ChannelValueData MemoryFilterGetValue(ChannelFilter * filter, double time
         if (double_eq(memoryFilter->timeHistoryRead[i], time)) {
 #ifdef MCX_DEBUG
             if (time < MCX_DEBUG_LOG_TIME) {
-                if (memoryFilter->valueHistoryRead[i].type == CHANNEL_DOUBLE) {
+                if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
                 } else {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, -)", filter, time);
@@ -149,7 +149,7 @@ static ChannelValueData MemoryFilterGetValue(ChannelFilter * filter, double time
 
 #ifdef MCX_DEBUG
     if (time < MCX_DEBUG_LOG_TIME) {
-        if (memoryFilter->valueHistoryRead[i].type == CHANNEL_DOUBLE) {
+        if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
         } else {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, -)", filter, time);
diff --git a/src/core/parameters/ParameterProxies.c b/src/core/parameters/ParameterProxies.c
index 107daae..cf491f4 100644
--- a/src/core/parameters/ParameterProxies.c
+++ b/src/core/parameters/ParameterProxies.c
@@ -25,7 +25,7 @@ static ChannelType ScalarParameterProxyGetType(ScalarParameterProxy * proxy) {
         return ChannelValueType(&proxy->value_->val);
     }
 
-    return CHANNEL_UNKNOWN;
+    return ChannelTypeUnknown;
 }
 
 static Fmu2Value * ScalarParameterProxyGetValue(ScalarParameterProxy * proxy) {
@@ -57,7 +57,7 @@ static McxStatus ArrayParameterProxyAddValue(ArrayParameterProxy * proxy, Fmu2Va
         Fmu2Value * val = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
 
         // check that data types match
-        if (ChannelValueType(&val->val) != ChannelValueType(&value->val)) {
+        if (!ChannelTypeEq(ChannelValueType(&val->val), ChannelValueType(&value->val))) {
             mcx_log(LOG_ERROR, "Adding value of '%s' to array proxy '%s' failed: Data type mismatch", value->name, proxy->name_);
             return RETURN_ERROR;
         }
@@ -142,7 +142,7 @@ static ChannelType ArrayParameterProxyGetType(ArrayParameterProxy * proxy) {
         return ChannelValueType(&value->val);
     }
 
-    return CHANNEL_UNKNOWN;
+    return ChannelTypeUnknown;
 }
 
 static void ArrayParameterProxyDestructor(ArrayParameterProxy * proxy) {
diff --git a/src/fmu/Fmu1Value.c b/src/fmu/Fmu1Value.c
index f5cc149..1b1266d 100644
--- a/src/fmu/Fmu1Value.c
+++ b/src/fmu/Fmu1Value.c
@@ -37,7 +37,7 @@ Fmu1Value * Fmu1ValueCreate(Fmu1Value * v) {
     v->name = NULL;
     v->var = NULL;
     v->channel = NULL;
-    ChannelValueInit(&v->val, CHANNEL_UNKNOWN);
+    ChannelValueInit(&v->val, ChannelTypeUnknown);
 
     return v;
 }
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index dc5c8ab..1d71551 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -52,34 +52,34 @@ Fmu2VariableInfo * Fmu2VariableInfoMake(fmi2_import_variable_t * var) {
 
         switch (type) {
             case fmi2_base_type_real:
-                info->type = CHANNEL_DOUBLE;
+                info->type = ChannelTypeDouble;
                 min.d = fmi2_import_get_real_variable_min(fmi2_import_get_variable_as_real(var));
                 minDefined = min.d != -DBL_MAX;
                 max.d = fmi2_import_get_real_variable_max(fmi2_import_get_variable_as_real(var));
                 maxDefined = max.d != DBL_MAX;
                 break;
             case fmi2_base_type_int:
-                info->type = CHANNEL_INTEGER;
+                info->type = ChannelTypeInteger;
                 min.i = fmi2_import_get_integer_variable_min(fmi2_import_get_variable_as_integer(var));
                 minDefined = min.i != -INT_MIN;
                 max.i = fmi2_import_get_integer_variable_max(fmi2_import_get_variable_as_integer(var));
                 maxDefined = max.i != INT_MAX;
                 break;
             case fmi2_base_type_enum:
-                info->type = CHANNEL_INTEGER;
+                info->type = ChannelTypeInteger;
                 min.i = fmi2_import_get_enum_variable_min(fmi2_import_get_variable_as_enum(var));
                 minDefined = min.i != -INT_MIN;
                 max.i = fmi2_import_get_enum_variable_max(fmi2_import_get_variable_as_enum(var));
                 maxDefined = max.i != INT_MAX;
                 break;
             case fmi2_base_type_str:
-                info->type = CHANNEL_STRING;
+                info->type = ChannelTypeString;
                 break;
             case fmi2_base_type_bool:
-                info->type = CHANNEL_BOOL;
+                info->type = ChannelTypeBool;
                 break;
             default:
-                info->type = CHANNEL_UNKNOWN;
+                info->type = ChannelTypeUnknown;
                 break;
         }
 
@@ -121,7 +121,7 @@ static void Fmu2VariableInfoDestructor(Fmu2VariableInfo * info) {
 }
 
 static Fmu2VariableInfo * Fmu2VariableInfoCreate(Fmu2VariableInfo * info) {
-    info->type = CHANNEL_UNKNOWN;
+    info->type = ChannelTypeUnknown;
 
     info->min = NULL;
     info->max = NULL;
@@ -253,7 +253,7 @@ static Fmu2Value * Fmu2ValueCreate(Fmu2Value * v) {
     v->channel = NULL;
     v->info = NULL;
 
-    ChannelValueInit(&v->val, CHANNEL_UNKNOWN);
+    ChannelValueInit(&v->val, ChannelTypeUnknown);
 
     return v;
 }
diff --git a/src/fmu/common_fmu1.c b/src/fmu/common_fmu1.c
index 94bbf97..e9a9e18 100644
--- a/src/fmu/common_fmu1.c
+++ b/src/fmu/common_fmu1.c
@@ -114,17 +114,17 @@ static fmi1_callback_functions_t fmi1Callbacks = {
 ChannelType Fmi1TypeToChannelType(fmi1_base_type_enu_t type) {
     switch (type) {
     case fmi1_base_type_real:
-        return CHANNEL_DOUBLE;
+        return ChannelTypeDouble;
     case fmi1_base_type_int:
-        return CHANNEL_INTEGER;
+        return ChannelTypeInteger;
     case fmi1_base_type_bool:
-        return CHANNEL_BOOL;
+        return ChannelTypeBool;
     case fmi1_base_type_str:
-        return CHANNEL_STRING;
+        return ChannelTypeString;
     case fmi1_base_type_enum:
-        return CHANNEL_INTEGER;
+        return ChannelTypeInteger;
     default:
-        return CHANNEL_UNKNOWN;
+        return ChannelTypeUnknown;
     }
 }
 
@@ -381,14 +381,14 @@ static ObjectContainer * Fmu1ReadArrayParamValues(const char * name,
                 goto cleanup_1;
             }
 
-            if (input->type == CHANNEL_DOUBLE) {
-                ChannelValueInit(&chVal, CHANNEL_DOUBLE);
+            if (ChannelTypeEq(input->type, ChannelTypeDouble)) {
+                ChannelValueInit(&chVal, ChannelTypeDouble);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
                     return RETURN_ERROR;
                 }
             }
             else { // integer
-                ChannelValueInit(&chVal, CHANNEL_INTEGER);
+                ChannelValueInit(&chVal, ChannelTypeInteger);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
                     return RETURN_ERROR;
                 }
@@ -550,7 +550,7 @@ McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     ChannelValue * const chVal = &fmuVal->val;
     ChannelType type = ChannelValueType(chVal);
 
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
     {
         double value = chVal->value.d;
@@ -634,7 +634,7 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     ChannelValue * const chVal = &fmuVal->val;
     ChannelType type = ChannelValueType(chVal);
 
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         status = fmi1_import_get_real(fmu->fmiImport, vr, 1, (fmi1_real_t *)ChannelValueReference(chVal));
         if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index c6c7e3f..9af68d4 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -32,7 +32,7 @@ extern "C" {
 
 
 fmi2_base_type_enu_t ChannelTypeToFmi2Type(ChannelType type) {
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         return fmi2_base_type_real;
     case CHANNEL_INTEGER:
@@ -49,17 +49,17 @@ fmi2_base_type_enu_t ChannelTypeToFmi2Type(ChannelType type) {
 ChannelType Fmi2TypeToChannelType(fmi2_base_type_enu_t type) {
     switch (type) {
     case fmi2_base_type_real:
-        return CHANNEL_DOUBLE;
+        return ChannelTypeDouble;
     case fmi2_base_type_int:
-        return CHANNEL_INTEGER;
+        return ChannelTypeInteger;
     case fmi2_base_type_bool:
-        return CHANNEL_BOOL;
+        return ChannelTypeBool;
     case fmi2_base_type_str:
-        return CHANNEL_STRING;
+        return ChannelTypeString;
     case fmi2_base_type_enum:
-        return CHANNEL_INTEGER;
+        return ChannelTypeInteger;
     default:
-        return CHANNEL_UNKNOWN;
+        return ChannelTypeUnknown;
     }
 }
 
@@ -389,14 +389,14 @@ static ObjectContainer* Fmu2ReadArrayParamValues(const char * name,
                 goto fmu2_read_array_param_values_for_cleanup;
             }
 
-            if (input->type == CHANNEL_DOUBLE) {
-                ChannelValueInit(&chVal, CHANNEL_DOUBLE);
+            if (ChannelTypeEq(input->type, ChannelTypeDouble)) {
+                ChannelValueInit(&chVal, ChannelTypeDouble);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
                     retVal = RETURN_ERROR;
                     goto fmu2_read_array_param_values_for_cleanup;
                 }
             } else { // integer
-                ChannelValueInit(&chVal, CHANNEL_INTEGER);
+                ChannelValueInit(&chVal, ChannelTypeInteger);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
                     retVal = RETURN_ERROR;
                     goto fmu2_read_array_param_values_for_cleanup;
@@ -683,7 +683,7 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     ChannelValue * const chVal = &fmuVal->val;
     ChannelType type = ChannelValueType(chVal);
 
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
     {
         fmi2_value_reference_t vr[] = {fmuVal->data->vr.scalar};
@@ -792,7 +792,7 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
 
     ChannelType type = ChannelValueType(chVal);
 
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
@@ -935,7 +935,7 @@ McxStatus Fmi2RegisterLocalChannelsAtDatabus(ObjectContainer * vals, const char
         const char * unitName;
         ChannelType type = ChannelValueType(&val->val);
 
-        if (CHANNEL_DOUBLE == type) {
+        if (ChannelTypeEq(ChannelTypeDouble, type)) {
             unit = fmi2_import_get_real_variable_unit(fmi2_import_get_variable_as_real(val->data->data.scalar));
         }
         if (unit) {
diff --git a/src/reader/model/components/specific_data/ConstantInput.c b/src/reader/model/components/specific_data/ConstantInput.c
index c14a354..415cc72 100644
--- a/src/reader/model/components/specific_data/ConstantInput.c
+++ b/src/reader/model/components/specific_data/ConstantInput.c
@@ -19,7 +19,7 @@ static void ScalarConstantValueInputDestructor(ScalarConstantValueInput * input)
 }
 
 static ScalarConstantValueInput * ScalarConstantValueInputCreate(ScalarConstantValueInput * input) {
-    input->type = CHANNEL_UNKNOWN;
+    input->type = ChannelTypeUnknown;
     input->value.d = 0.0;
 
     return input;
@@ -32,7 +32,7 @@ static void ArrayConstantValueInputDestructor(ArrayConstantValueInput * input) {
 }
 
 static ArrayConstantValueInput * ArrayConstantValueInputCreate(ArrayConstantValueInput * input) {
-    input->type = CHANNEL_UNKNOWN;
+    input->type = ChannelTypeUnknown;
 
     input->numValues = 0;
     input->values = NULL;
diff --git a/src/reader/model/parameters/ArrayParameterInput.c b/src/reader/model/parameters/ArrayParameterInput.c
index 203c426..d8681b6 100644
--- a/src/reader/model/parameters/ArrayParameterInput.c
+++ b/src/reader/model/parameters/ArrayParameterInput.c
@@ -29,7 +29,7 @@ static void ArrayParameterInputDestructor(ArrayParameterInput * input) {
     }
 
     if (input->values) {
-        if (input->type == CHANNEL_STRING) {
+        if (ChannelTypeEq(input->type, ChannelTypeString)) {
             size_t i = 0;
 
             for (i = 0; i < input->numValues; i++) {
@@ -47,7 +47,7 @@ static ArrayParameterInput * ArrayParameterInputCreate(ArrayParameterInput * inp
     input->numDims = 0;
     input->dims = NULL;
 
-    input->type = CHANNEL_UNKNOWN;
+    input->type = ChannelTypeUnknown;
 
     input->numValues = 0;
     input->values = NULL;
diff --git a/src/reader/model/parameters/ScalarParameterInput.c b/src/reader/model/parameters/ScalarParameterInput.c
index 6b217c6..22783d6 100644
--- a/src/reader/model/parameters/ScalarParameterInput.c
+++ b/src/reader/model/parameters/ScalarParameterInput.c
@@ -19,7 +19,7 @@ static void ScalarParameterInputDestructor(ScalarParameterInput * input) {
 
     if (input->unit) { mcx_free(input->unit); }
 
-    if (input->type == CHANNEL_STRING && input->value.defined && input->value.value.s) {
+    if (ChannelTypeEq(input->type, ChannelTypeString) && input->value.defined && input->value.value.s) {
         mcx_free(input->value.value.s);
     }
 }
@@ -27,7 +27,7 @@ static void ScalarParameterInputDestructor(ScalarParameterInput * input) {
 static ScalarParameterInput * ScalarParameterInputCreate(ScalarParameterInput * input) {
     input->name = NULL;
 
-    input->type = CHANNEL_UNKNOWN;
+    input->type = ChannelTypeUnknown;
     OPTIONAL_UNSET(input->value);
 
     input->unit = NULL;
diff --git a/src/reader/model/ports/ScalarPortInput.c b/src/reader/model/ports/ScalarPortInput.c
index 38d4b18..96d732e 100644
--- a/src/reader/model/ports/ScalarPortInput.c
+++ b/src/reader/model/ports/ScalarPortInput.c
@@ -133,7 +133,7 @@ static McxStatus CopyFrom(ScalarPortInput * self, ScalarPortInput * src) {
 
 
 static void PrintOptionalChannelValueData(char * prefix, ChannelType type, OPTIONAL_VALUE(ChannelValueData) value) {
-    switch(type) {
+    switch(type.con) {
     case CHANNEL_DOUBLE:
         if (value.defined) {
             mcx_log(LOG_DEBUG, "%s%f,", prefix, value.value.d);
@@ -208,7 +208,7 @@ static ScalarPortInput * ScalarPortInputCreate(ScalarPortInput * input) {
     input->id = NULL;
     input->unit = NULL;
 
-    input->type = CHANNEL_UNKNOWN;
+    input->type = ChannelTypeUnknown;
 
     OPTIONAL_UNSET(input->min);
     OPTIONAL_UNSET(input->max);
diff --git a/src/reader/model/ports/VectorPortInput.c b/src/reader/model/ports/VectorPortInput.c
index 5461096..a90b53f 100644
--- a/src/reader/model/ports/VectorPortInput.c
+++ b/src/reader/model/ports/VectorPortInput.c
@@ -159,7 +159,7 @@ static void PrintVec(char * prefix, ChannelType type, size_t len, void * value)
 
     if (value) {
         for (i = 0; i < len; i++) {
-            switch(type) {
+            switch(type.con) {
             case CHANNEL_DOUBLE:
                 num += sprintf(buffer + num, " %f", ((double*)value)[i]);
                 break;
@@ -235,7 +235,7 @@ static VectorPortInput * VectorPortInputCreate(VectorPortInput * input) {
     input->id = NULL;
     input->unit = NULL;
 
-    input->type = CHANNEL_UNKNOWN;
+    input->type = ChannelTypeUnknown;
 
     input->min = NULL;
     input->max = NULL;
diff --git a/src/reader/ssp/Parameters.c b/src/reader/ssp/Parameters.c
index 03963d7..1269e58 100644
--- a/src/reader/ssp/Parameters.c
+++ b/src/reader/ssp/Parameters.c
@@ -25,6 +25,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+
 typedef struct SSDParameterValue SSDParameterValue;
 
 typedef McxStatus(*fSSDParameterValueSetup)(SSDParameterValue * paramValue, xmlNodePtr node, ObjectContainer * units);
@@ -614,12 +615,12 @@ static McxStatus CollectParameterValues(xmlNodePtr paramBindingsNode, ObjectCont
     return RETURN_OK;
 }
 
-static MapStringInt _typeMappingScalar[] = {
-    {"Real",        CHANNEL_DOUBLE},
-    {"Integer",     CHANNEL_INTEGER},
-    {"Boolean",     CHANNEL_BOOL},
-    {"String",      CHANNEL_STRING},
-    {NULL,          0},
+static MapStringChannelType _typeMappingScalar[] = {
+    {"Real",        &ChannelTypeDouble},
+    {"Integer",     &ChannelTypeInteger},
+    {"Boolean",     &ChannelTypeBool},
+    {"String",      &ChannelTypeString},
+    {NULL,          &ChannelTypeUnknown},
 };
 
 static ScalarParameterInput * SSDReadScalarParameter(SSDParameter * parameter) {
@@ -671,12 +672,12 @@ static ScalarParameterInput * SSDReadScalarParameter(SSDParameter * parameter) {
 
         for (i = 0; _typeMappingScalar[i].key; i++) {
             if (!strcmp(connectorType, _typeMappingScalar[i].key)) {
-                input->type = _typeMappingScalar[i].value;
+                input->type = *_typeMappingScalar[i].value;
                 break;
             }
         }
 
-        if (input->type == CHANNEL_UNKNOWN) {
+        if (!ChannelTypeIsValid(input->type)) {
             retVal = xml_error_unsupported_node(connectorTypeNode);
             goto cleanup;
         }
@@ -705,11 +706,11 @@ static ScalarParameterInput * SSDReadScalarParameter(SSDParameter * parameter) {
     return input;
 }
 
-static MapStringInt _typeMappingArray[] = {
-    {"Real",        CHANNEL_DOUBLE},
-    {"Integer",     CHANNEL_INTEGER},
-    {"Boolean",     CHANNEL_BOOL},
-    {NULL,          0},
+static MapStringChannelType _typeMappingArray[] = {
+    {"Real",        &ChannelTypeDouble},
+    {"Integer",     &ChannelTypeInteger},
+    {"Boolean",     &ChannelTypeBool},
+    {NULL,          &ChannelTypeUnknown},
 };
 
 static ArrayParameterDimensionInput * SSDReadArrayParameterDimension(xmlNodePtr node) {
@@ -749,7 +750,7 @@ static ArrayParameterDimensionInput * SSDReadArrayParameterDimension(xmlNodePtr
 static McxStatus AllocateMemory(SSDParameter * parameter, ChannelType type, size_t numValues, void ** dest) {
     size_t size = 0;
 
-    switch (type) {
+    switch (type.con) {
         case CHANNEL_DOUBLE:
             size = sizeof(double);
             break;
@@ -825,7 +826,7 @@ static McxStatus SSDReadDimensionlessArrayParameter(SSDParameter * parameter, Ar
             continue;
         }
 
-        switch (input->type) {
+        switch (input->type.con) {
             case CHANNEL_DOUBLE:
                 retVal = xml_attr_double(paramTypeNode, "value", (double*)input->values + paramValue->idx1, SSD_MANDATORY);
                 break;
@@ -911,7 +912,7 @@ static McxStatus SSDReadDimensionArrayParameter(SSDParameter * parameter, ArrayP
             index = (paramValue->idx1 - input->dims[0]->start) * (input->dims[1]->end - input->dims[1]->start + 1) + paramValue->idx2 - input->dims[1]->start;
         }
 
-        switch (input->type) {
+        switch (input->type.con) {
             case CHANNEL_DOUBLE:
                 retVal = xml_attr_double(paramTypeNode, "value", (double*)input->values + index, SSD_MANDATORY);
                 break;
@@ -1020,12 +1021,12 @@ static ArrayParameterInput * SSDReadArrayParameter(SSDParameter * parameter) {
 
         for (i = 0; _typeMappingArray[i].key; i++) {
             if (!strcmp(connectorType, _typeMappingArray[i].key)) {
-                input->type = _typeMappingArray[i].value;
+                input->type = *_typeMappingArray[i].value;
                 break;
             }
         }
 
-        if (input->type == CHANNEL_UNKNOWN) {
+        if (!ChannelTypeIsValid(input->type)) {
             retVal = xml_error_unsupported_node(connectorTypeNode);
             goto cleanup;
         }
diff --git a/src/reader/ssp/Ports.c b/src/reader/ssp/Ports.c
index 8c03a63..c5f03c1 100644
--- a/src/reader/ssp/Ports.c
+++ b/src/reader/ssp/Ports.c
@@ -17,6 +17,7 @@
 #include "reader/model/ports/ScalarPortInput.h"
 #include "reader/model/ports/VectorPortInput.h"
 
+#include "core/channels/ChannelValue.h"
 #include "util/string.h"
 
 
@@ -24,20 +25,20 @@
 extern "C" {
 #endif /* __cplusplus */
 
-static MapStringInt _typeMapping[] = {
-    {"Real",        CHANNEL_DOUBLE},
-    {"Integer",     CHANNEL_INTEGER},
-    {"Boolean",     CHANNEL_BOOL},
-    {"String",      CHANNEL_STRING},
-    {"Binary",      CHANNEL_BINARY},
-    {NULL,          0},
+static MapStringChannelType _typeMapping[] = {
+    {"Real",        &ChannelTypeDouble},
+    {"Integer",     &ChannelTypeInteger},
+    {"Boolean",     &ChannelTypeBool},
+    {"String",      &ChannelTypeString},
+    {"Binary",      &ChannelTypeBinary},
+    {NULL,          &ChannelTypeUnknown},
 };
 
-static MapStringInt _vectorTypeMapping[] = {
-    {"RealVector",    CHANNEL_DOUBLE},
-    {"IntegerVector", CHANNEL_INTEGER},
-    {"BooleanVector", CHANNEL_BOOL},
-    {NULL,          0},
+static MapStringChannelType _vectorTypeMapping[] = {
+    {"RealVector",    &ChannelTypeDouble},
+    {"IntegerVector", &ChannelTypeInteger},
+    {"BooleanVector", &ChannelTypeBool},
+    {NULL,            &ChannelTypeUnknown},
 };
 
 
@@ -136,11 +137,11 @@ VectorPortInput * SSDReadComponentVectorPort(xmlNodePtr connectorNode, const cha
 
             for (i = 0; _typeMapping[i].key; i++) {
                 if (!strcmp(typeName, _typeMapping[i].key)) {
-                    vectorPortInput->type = _typeMapping[i].value;
+                    vectorPortInput->type = *_typeMapping[i].value;
                     break;
                 }
             }
-            if (vectorPortInput->type == CHANNEL_UNKNOWN) {
+            if (!ChannelTypeIsValid(vectorPortInput->type)) {
                 retVal = xml_error_unsupported_node(typeNode);
                 goto cleanup;
             }
@@ -172,7 +173,7 @@ VectorPortInput * SSDReadComponentVectorPort(xmlNodePtr connectorNode, const cha
                     xmlNodePtr vectorNode = NULL;
                     size_t num = 0;
 
-                    switch (vectorPortInput->type) {
+                    switch (vectorPortInput->type.con) {
                     case CHANNEL_DOUBLE:
                         vectorNode = xml_child(portNode, "RealVector");
                         break;
@@ -350,11 +351,11 @@ ScalarPortInput * SSDReadComponentScalarPort(xmlNodePtr connectorNode, const cha
 
             for (i = 0; _typeMapping[i].key; i++) {
                 if (!strcmp(typeName, _typeMapping[i].key)) {
-                    scalarPortInput->type = _typeMapping[i].value;
+                    scalarPortInput->type = *_typeMapping[i].value;
                     break;
                 }
             }
-            if (scalarPortInput->type == CHANNEL_UNKNOWN) {
+            if (!ChannelTypeIsValid(scalarPortInput->type)) {
                 retVal = xml_error_unsupported_node(typeNode);
                 goto cleanup;
             }
@@ -386,7 +387,7 @@ ScalarPortInput * SSDReadComponentScalarPort(xmlNodePtr connectorNode, const cha
                     xmlNodePtr scalarNode = NULL;
                     size_t num = 0;
 
-                    switch (scalarPortInput->type) {
+                    switch (scalarPortInput->type.con) {
                     case CHANNEL_DOUBLE:
                         scalarNode = xml_child(portNode, "Real");
                         break;
diff --git a/src/reader/ssp/SpecificData.c b/src/reader/ssp/SpecificData.c
index 1af4a25..530693d 100644
--- a/src/reader/ssp/SpecificData.c
+++ b/src/reader/ssp/SpecificData.c
@@ -17,6 +17,7 @@
 #include "reader/model/components/specific_data/VectorIntegratorInput.h"
 #include "reader/model/components/specific_data/ConstantInput.h"
 
+#include "core/channels/ChannelValue.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -150,12 +151,12 @@ McxStatus SSDReadVectorIntegratorData(xmlNodePtr componentNode, xmlNodePtr speci
     return RETURN_OK;
 }
 
-static MapStringInt _scalarConstantTypeMapping[] = {
-    {"Real", CHANNEL_DOUBLE},
-    {"Integer", CHANNEL_INTEGER},
-    {"String", CHANNEL_STRING},
-    {"Boolean", CHANNEL_BOOL},
-    {NULL, CHANNEL_UNKNOWN}
+static MapStringChannelType _scalarConstantTypeMapping[] = {
+    {"Real", &ChannelTypeDouble},
+    {"Integer", &ChannelTypeInteger},
+    {"String", &ChannelTypeString},
+    {"Boolean", &ChannelTypeBool},
+    {NULL, &ChannelTypeUnknown}
 };
 
 static ScalarConstantValueInput * SSDReadScalarConstantValue(xmlNodePtr node) {
@@ -176,12 +177,12 @@ static ScalarConstantValueInput * SSDReadScalarConstantValue(xmlNodePtr node) {
 
         for (i = 0; _scalarConstantTypeMapping[i].key; i++) {
             if (!strcmp(xml_node_get_name(node), _scalarConstantTypeMapping[i].key)) {
-                input->type = _scalarConstantTypeMapping[i].value;
+                input->type = *_scalarConstantTypeMapping[i].value;
                 break;
             }
         }
 
-        if (input->type == CHANNEL_UNKNOWN) {
+        if (!ChannelTypeIsValid(input->type)) {
             retVal = xml_error_unsupported_node(node);
             goto cleanup;
         }
@@ -201,10 +202,10 @@ static ScalarConstantValueInput * SSDReadScalarConstantValue(xmlNodePtr node) {
     return input;
 }
 
-static MapStringInt _vectorConstantTypeMapping[] = {
-    {"RealVector", CHANNEL_DOUBLE},
-    {"IntegerVector", CHANNEL_INTEGER},
-    {NULL, CHANNEL_UNKNOWN}
+static MapStringChannelType _vectorConstantTypeMapping[] = {
+    {"RealVector", &ChannelTypeDouble},
+    {"IntegerVector", &ChannelTypeInteger},
+    {NULL, &ChannelTypeUnknown}
 };
 
 static ArrayConstantValueInput * SSDReadArrayConstantValue(xmlNodePtr node) {
@@ -225,18 +226,18 @@ static ArrayConstantValueInput * SSDReadArrayConstantValue(xmlNodePtr node) {
 
         for (i = 0; _vectorConstantTypeMapping[i].key; i++) {
             if (!strcmp(xml_node_get_name(node), _vectorConstantTypeMapping[i].key)) {
-                input->type = _vectorConstantTypeMapping[i].value;
+                input->type = *_vectorConstantTypeMapping[i].value;
                 break;
             }
         }
 
-        if (input->type == CHANNEL_UNKNOWN) {
+        if (!ChannelTypeIsValid(input->type)) {
             retVal = xml_error_unsupported_node(node);
             goto cleanup;
         }
     }
 
-    switch (input->type) {
+    switch (input->type.con) {
         case CHANNEL_DOUBLE:
             retVal = xml_attr_double_vec(node, "value", &input->numValues, (double**)&input->values, SSD_MANDATORY);
             break;
diff --git a/src/reader/ssp/Util.c b/src/reader/ssp/Util.c
index 2c8e76c..6186dc0 100644
--- a/src/reader/ssp/Util.c
+++ b/src/reader/ssp/Util.c
@@ -747,7 +747,7 @@ McxStatus xml_attr_enum_weak_ptr(xmlNodePtr node,
 }
 
 McxStatus xml_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType type, ChannelValueData * dest, SSDParamMode mode) {
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         return xml_attr_double(node, attribute_name, &dest->d, mode);
     case CHANNEL_INTEGER:
@@ -1209,7 +1209,7 @@ McxStatus xml_attr_vec_len(xmlNodePtr node, const char * attribute_name, Channel
         goto cleanup;
     }
 
-    switch (type) {
+    switch (type.con) {
     case CHANNEL_DOUBLE:
         ret_status = xml_attr_double_vec(node, attribute_name, &len, (double **) &values, mode);
         break;
diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index cfda2e6..4a8a3ff 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -83,7 +83,7 @@ static McxStatus ChannelStorageSetup(ChannelStorage * channelStore, int fullStor
         goto cleanup;
     }
 
-    retVal = ChannelInfoSetup(&timeInfo, "Time", "Time", "", GetTimeUnitString(), CHANNEL_DOUBLE, "");
+    retVal = ChannelInfoSetup(&timeInfo, "Time", "Time", "", GetTimeUnitString(), ChannelTypeDouble, "");
     if (RETURN_ERROR == retVal) {
         mcx_log(LOG_ERROR, "Results: Setup port storage: Could not set up time port data");
         goto cleanup;
diff --git a/src/storage/StorageBackendText.c b/src/storage/StorageBackendText.c
index 56c38b0..b7ca92f 100644
--- a/src/storage/StorageBackendText.c
+++ b/src/storage/StorageBackendText.c
@@ -215,7 +215,7 @@ static McxStatus WriteRow(FILE * file, ChannelValue * values, size_t numChannels
         if (channel == 0) { // leave out separator at the beginning
             sep = "";
         }
-        switch (ChannelValueType(&val)) {
+        switch (ChannelValueType(&val).con) {
         case CHANNEL_DOUBLE:
         case CHANNEL_INTEGER:
         case CHANNEL_BOOL:

From ea3030ce5889e3158a32e6ed5633747a12f5a08b Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 13 Jul 2021 15:36:03 +0200
Subject: [PATCH 020/166] channel: Use ChannelType only via references

---
 src/components/comp_fmu.c                     |  24 ++--
 src/components/comp_integrator.c              |   4 +-
 src/components/comp_vector_integrator.c       |   4 +-
 src/core/Component.c                          |   2 +-
 src/core/Conversion.c                         |  78 ++++++------
 src/core/Conversion.h                         |   8 +-
 src/core/Databus.c                            |  33 +++--
 src/core/Databus.h                            |  14 +--
 src/core/Model.c                              |   8 +-
 src/core/channels/Channel.c                   |  33 +++--
 src/core/channels/Channel.h                   |  10 +-
 src/core/channels/ChannelInfo.c               |   8 +-
 src/core/channels/ChannelInfo.h               |   7 +-
 src/core/channels/ChannelValue.c              | 119 +++++++++---------
 src/core/channels/ChannelValue.h              |  38 +++---
 src/core/connections/Connection.c             |   8 +-
 src/core/connections/ConnectionInfo.c         |  12 +-
 src/core/connections/ConnectionInfo.h         |   4 +-
 src/core/connections/FilteredConnection.c     |   2 +-
 src/core/connections/filters/DiscreteFilter.c |   6 +-
 src/core/connections/filters/DiscreteFilter.h |   2 +-
 src/core/connections/filters/MemoryFilter.c   |  12 +-
 src/core/connections/filters/MemoryFilter.h   |   2 +-
 src/core/parameters/ParameterProxies.c        |   8 +-
 src/core/parameters/ParameterProxies.h        |   4 +-
 src/fmu/Fmu1Value.c                           |   2 +-
 src/fmu/Fmu2Value.c                           |  16 +--
 src/fmu/Fmu2Value.h                           |   2 +-
 src/fmu/common_fmu1.c                         |  28 ++---
 src/fmu/common_fmu1.h                         |   2 +-
 src/fmu/common_fmu2.c                         |  40 +++---
 src/fmu/common_fmu2.h                         |   2 +-
 .../components/specific_data/ConstantInput.c  |   4 +-
 .../components/specific_data/ConstantInput.h  |   4 +-
 .../model/parameters/ArrayParameterInput.c    |   4 +-
 .../model/parameters/ArrayParameterInput.h    |   2 +-
 .../model/parameters/ScalarParameterInput.c   |   4 +-
 .../model/parameters/ScalarParameterInput.h   |   2 +-
 src/reader/model/ports/ScalarPortInput.c      |   6 +-
 src/reader/model/ports/ScalarPortInput.h      |   2 +-
 src/reader/model/ports/VectorPortInput.c      |   6 +-
 src/reader/model/ports/VectorPortInput.h      |   2 +-
 src/reader/ssp/Parameters.c                   |  12 +-
 src/reader/ssp/Ports.c                        |   8 +-
 src/reader/ssp/SpecificData.c                 |   6 +-
 src/reader/ssp/Util.c                         |  10 +-
 src/reader/ssp/Util.h                         |   6 +-
 src/storage/ChannelStorage.c                  |   2 +-
 src/storage/StorageBackendText.c              |   2 +-
 49 files changed, 315 insertions(+), 309 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index eedea53..eb9edd6 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -552,24 +552,24 @@ static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Datab
                 return RETURN_ERROR;
             }
 
-            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo)))) {
+            if (!ChannelTypeEq(&ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelNameLo);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
+                        ChannelTypeToString(&ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
                 return RETURN_ERROR;
             }
 
-            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi)))) {
+            if (!ChannelTypeEq(&ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelNameHi);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
+                        ChannelTypeToString(&ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
                 return RETURN_ERROR;
             }
 
-            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize)))) {
+            if (!ChannelTypeEq(&ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelNameSize);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
+                        ChannelTypeToString(&ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
                 return RETURN_ERROR;
             }
 
@@ -661,24 +661,24 @@ static McxStatus Fmu2ReadChannelOut(ObjectContainer /* Fmu2Value */ * vals, Data
                 return RETURN_ERROR;
             }
 
-            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo)))) {
+            if (!ChannelTypeEq(&ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelNameLo);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
-                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
+                        ChannelTypeToString(&ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varLo))));
                 return RETURN_ERROR;
             }
 
-            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi)))) {
+            if (!ChannelTypeEq(&ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelNameHi);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
-                        ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
+                        ChannelTypeToString(&ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varHi))));
                 return RETURN_ERROR;
             }
 
-            if (!ChannelTypeEq(ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize)))) {
+            if (!ChannelTypeEq(&ChannelTypeInteger, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize)))) {
                 mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelNameSize);
                 mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
-                    ChannelTypeToString(ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
+                    ChannelTypeToString(&ChannelTypeInteger), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(varSize))));
                 return RETURN_ERROR;
             }
 
diff --git a/src/components/comp_integrator.c b/src/components/comp_integrator.c
index 82fcc8f..c05c538 100644
--- a/src/components/comp_integrator.c
+++ b/src/components/comp_integrator.c
@@ -56,13 +56,13 @@ static McxStatus Setup(Component * comp) {
     CompIntegrator * integrator = (CompIntegrator *) comp;
     McxStatus retVal = RETURN_OK;
 
-    retVal = DatabusSetInReference(comp->GetDatabus(comp), 0, &integrator->deriv, ChannelTypeDouble);
+    retVal = DatabusSetInReference(comp->GetDatabus(comp), 0, &integrator->deriv, &ChannelTypeDouble);
     if (RETURN_OK != retVal) {
         ComponentLog(comp, LOG_ERROR, "Could not register in channel reference");
         return RETURN_ERROR;
     }
 
-    retVal = DatabusSetOutReference(comp->GetDatabus(comp), 0, &integrator->state, ChannelTypeDouble);
+    retVal = DatabusSetOutReference(comp->GetDatabus(comp), 0, &integrator->state, &ChannelTypeDouble);
     if (RETURN_OK != retVal) {
         ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
         return RETURN_ERROR;
diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 9002ee3..6eaeda6 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -80,7 +80,7 @@ static McxStatus Setup(Component * comp) {
         size_t startIdx = vInfo->GetStartIndex(vInfo);
         size_t endIdx = vInfo->GetEndIndex(vInfo);
         size_t numCh = endIdx - startIdx;
-        retVal = DatabusSetInRefVector(db, i, startIdx, endIdx, integrator->deriv + nextIdx, ChannelTypeDouble);
+        retVal = DatabusSetInRefVector(db, i, startIdx, endIdx, integrator->deriv + nextIdx, &ChannelTypeDouble);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register in channel reference");
             return RETURN_ERROR;
@@ -94,7 +94,7 @@ static McxStatus Setup(Component * comp) {
         size_t startIdx = vInfo->GetStartIndex(vInfo);
         size_t endIdx = vInfo->GetEndIndex(vInfo);
         size_t numCh = endIdx - startIdx;
-        retVal = DatabusSetOutRefVector(db, i, startIdx, endIdx, integrator->state + nextIdx, ChannelTypeDouble);
+        retVal = DatabusSetOutRefVector(db, i, startIdx, endIdx, integrator->state + nextIdx, &ChannelTypeDouble);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
             return RETURN_ERROR;
diff --git a/src/core/Component.c b/src/core/Component.c
index 25d188c..5bab659 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -216,7 +216,7 @@ static McxStatus DefineTimingChannel(Component * comp, const char * chName, cons
         return RETURN_ERROR;
     }
 
-    retVal = DatabusAddRTFactorChannel(comp->data->databus, chName, id, unit, reference, ChannelTypeDouble);
+    retVal = DatabusAddRTFactorChannel(comp->data->databus, chName, id, unit, reference, &ChannelTypeDouble);
 
     mcx_free(id);
 
diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 18714be..7adc2ab 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -42,7 +42,7 @@ McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * va
 
     McxStatus retVal = RETURN_OK;
 
-    if (!ChannelTypeEq(value->type, ChannelTypeDouble) && !ChannelTypeEq(value->type, ChannelTypeInteger)) {
+    if (!ChannelTypeEq(value->type, &ChannelTypeDouble) && !ChannelTypeEq(value->type, &ChannelTypeInteger)) {
         return RETURN_OK;
     }
 
@@ -150,8 +150,8 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
         conversion->type = ChannelValueType(max);
     }
 
-    if (!(ChannelTypeEq(conversion->type, ChannelTypeDouble)
-          || ChannelTypeEq(conversion->type, ChannelTypeInteger))) {
+    if (!(ChannelTypeEq(conversion->type, &ChannelTypeDouble)
+          || ChannelTypeEq(conversion->type, &ChannelTypeInteger))) {
         mcx_log(LOG_ERROR, "Range conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -163,7 +163,7 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
 }
 
 static int RangeConversionIsEmpty(RangeConversion * conversion) {
-    switch (conversion->type.con) {
+    switch (conversion->type->con) {
     case CHANNEL_DOUBLE:
         return
             (!conversion->min || * (double *) ChannelValueReference(conversion->min) == (-DBL_MAX)) &&
@@ -194,7 +194,7 @@ static RangeConversion * RangeConversionCreate(RangeConversion * rangeConversion
     rangeConversion->Setup = RangeConversionSetup;
     rangeConversion->IsEmpty = RangeConversionIsEmpty;
 
-    rangeConversion->type = ChannelTypeUnknown;
+    rangeConversion->type = &ChannelTypeUnknown;
 
     rangeConversion->min = NULL;
     rangeConversion->max = NULL;
@@ -263,8 +263,8 @@ static McxStatus UnitConversionConvert(Conversion * conversion, ChannelValue * v
 
     double val = 0.0;
 
-    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeDouble)) {
-        mcx_log(LOG_ERROR, "Unit conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeDouble));
+    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeDouble)) {
+        mcx_log(LOG_ERROR, "Unit conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
@@ -353,7 +353,7 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 
     McxStatus retVal = RETURN_OK;
 
-    if (!ChannelTypeEq(value->type, ChannelTypeDouble) && !ChannelTypeEq(value->type, ChannelTypeInteger)) {
+    if (!ChannelTypeEq(value->type, &ChannelTypeDouble) && !ChannelTypeEq(value->type, &ChannelTypeInteger)) {
         return RETURN_OK;
     }
 
@@ -454,8 +454,8 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
         conversion->type = ChannelValueType(offset);
     }
 
-    if (!(ChannelTypeEq(conversion->type, ChannelTypeDouble)
-          || ChannelTypeEq(conversion->type, ChannelTypeInteger))) {
+    if (!(ChannelTypeEq(conversion->type, &ChannelTypeDouble)
+          || ChannelTypeEq(conversion->type, &ChannelTypeInteger))) {
         mcx_log(LOG_WARNING, "Linear conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -467,7 +467,7 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
 }
 
 static int LinearConversionIsEmpty(LinearConversion * conversion) {
-    switch (conversion->type.con) {
+    switch (conversion->type->con) {
     case CHANNEL_DOUBLE:
         return
             (!conversion->factor || * (double *) ChannelValueReference(conversion->factor) == 1.0) &&
@@ -497,7 +497,7 @@ static LinearConversion * LinearConversionCreate(LinearConversion * linearConver
     linearConversion->Setup = LinearConversionSetup;
     linearConversion->IsEmpty = LinearConversionIsEmpty;
 
-    linearConversion->type = ChannelTypeUnknown;
+    linearConversion->type = &ChannelTypeUnknown;
 
     linearConversion->factor = NULL;
     linearConversion->offset = NULL;
@@ -511,7 +511,7 @@ OBJECT_CLASS(LinearConversion, Conversion);
 // ----------------------------------------------------------------------
 // Type Conversion
 
-McxStatus ConvertType(ChannelType fromType, ChannelType toType, ChannelValue * value) {
+McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue * value) {
     TypeConversion * typeConv = NULL;
     Conversion * conv = NULL;
 
@@ -544,72 +544,72 @@ McxStatus ConvertType(ChannelType fromType, ChannelType toType, ChannelValue * v
 }
 
 static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeInteger)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeInteger));
+    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeInteger)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeInteger));
         return RETURN_ERROR;
     }
 
-    value->type = ChannelTypeDouble;
+    value->type = &ChannelTypeDouble;
     value->value.d = (double)value->value.i;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertDoubleInt(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeDouble)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeDouble));
+    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeDouble)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
-    value->type = ChannelTypeInteger;
+    value->type = &ChannelTypeInteger;
     value->value.i = (int)floor(value->value.d + 0.5);
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertBoolDouble(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeBool)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeBool));
+    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeBool)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeBool));
         return RETURN_ERROR;
     }
 
-    value->type = ChannelTypeDouble;
+    value->type = &ChannelTypeDouble;
     value->value.d = (value->value.i != 0) ? 1. : 0.;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertDoubleBool(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeDouble)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeDouble));
+    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeDouble)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
-    value->type = ChannelTypeBool;
+    value->type = &ChannelTypeBool;
     value->value.i = (value->value.d > 0) ? 1 : 0;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertBoolInteger(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeBool)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeBool));
+    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeBool)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeBool));
         return RETURN_ERROR;
     }
 
-    value->type = ChannelTypeInteger;
+    value->type = &ChannelTypeInteger;
     value->value.i = (value->value.i != 0) ? 1 : 0;
 
     return RETURN_OK;
 }
 
 static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), ChannelTypeInteger)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(ChannelTypeInteger));
+    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeInteger)) {
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeInteger));
         return RETURN_ERROR;
     }
 
-    value->type = ChannelTypeBool;
+    value->type = &ChannelTypeBool;
     value->value.i = (value->value.i != 0) ? 1 : 0;
 
     return RETURN_OK;
@@ -620,23 +620,23 @@ static McxStatus TypeConversionConvertId(Conversion * conversion, ChannelValue *
 }
 
 static McxStatus TypeConversionSetup(TypeConversion * typeConversion,
-                                     ChannelType fromType,
-                                     ChannelType toType) {
+                                     ChannelType * fromType,
+                                     ChannelType * toType) {
     Conversion * conversion = (Conversion *) typeConversion;
 
     if (ChannelTypeEq(fromType, toType)) {
         conversion->convert = TypeConversionConvertId;
-    } else if (ChannelTypeEq(fromType, ChannelTypeInteger) && ChannelTypeEq(toType, ChannelTypeDouble)) {
+    } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
         conversion->convert = TypeConversionConvertIntDouble;
-    } else if (ChannelTypeEq(fromType, ChannelTypeDouble) && ChannelTypeEq(toType, ChannelTypeInteger)) {
+    } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
         conversion->convert = TypeConversionConvertDoubleInt;
-    } else if (ChannelTypeEq(fromType, ChannelTypeBool) && ChannelTypeEq(toType, ChannelTypeDouble)) {
+    } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
         conversion->convert = TypeConversionConvertBoolDouble;
-    } else if (ChannelTypeEq(fromType, ChannelTypeDouble) && ChannelTypeEq(toType, ChannelTypeBool)) {
+    } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeBool)) {
         conversion->convert = TypeConversionConvertDoubleBool;
-    } else if (ChannelTypeEq(fromType, ChannelTypeBool) && ChannelTypeEq(toType, ChannelTypeInteger)) {
+    } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
         conversion->convert = TypeConversionConvertBoolInteger;
-    } else if (ChannelTypeEq(fromType, ChannelTypeInteger) && ChannelTypeEq(toType, ChannelTypeBool)) {
+    } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeBool)) {
         conversion->convert = TypeConversionConvertIntegerBool;
     } else {
         mcx_log(LOG_ERROR, "Setup type conversion: Illegal conversion selected");
diff --git a/src/core/Conversion.h b/src/core/Conversion.h
index 1f542f2..90ab771 100644
--- a/src/core/Conversion.h
+++ b/src/core/Conversion.h
@@ -47,7 +47,7 @@ typedef struct RangeConversion {
     fRangeConversionSetup Setup;
     fRangeConversionIsEmpty IsEmpty;
 
-    ChannelType type;
+    ChannelType * type;
 
     ChannelValue * min;
     ChannelValue * max;
@@ -99,7 +99,7 @@ typedef struct LinearConversion {
     fLinearConversionSetup Setup;
     fLinearConversionIsEmpty IsEmpty;
 
-    ChannelType type;
+    ChannelType * type;
 
     ChannelValue * factor;
     ChannelValue * offset;
@@ -114,7 +114,7 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 
 typedef struct TypeConversion TypeConversion;
 
-typedef McxStatus (* fTypeConversionSetup)(TypeConversion * conversion, ChannelType fromType, ChannelType toType);
+typedef McxStatus (* fTypeConversionSetup)(TypeConversion * conversion, ChannelType * fromType, ChannelType * toType);
 typedef int (* fTypeConversionIsEmpty)(TypeConversion * conversion);
 
 extern const struct ObjectClass _TypeConversion;
@@ -126,7 +126,7 @@ struct TypeConversion {
     fTypeConversionIsEmpty IsEmpty;
 };
 
-McxStatus ConvertType(ChannelType fromType, ChannelType toType, ChannelValue * value);
+McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue * value);
 
 
 #ifdef __cplusplus
diff --git a/src/core/Databus.c b/src/core/Databus.c
index 121aaf6..739ef21 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -107,7 +107,7 @@ static Vector * DatabusReadPortInput(PortInput * input) {
         VectorPortInput * vectorPortInput = input->port.vectorPort;
         InputElement * vectorPortElement = (InputElement *) vectorPortInput;
 
-        ChannelType expectedType = vectorPortInput->type;
+        ChannelType * expectedType = vectorPortInput->type;
         size_t expectedLen = 0;
 
         if (!vector) {
@@ -310,8 +310,7 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             ChannelInfoSetUnit(&info, "-");
         }
 
-        ChannelType expectedType = info.type;
-
+        ChannelType * expectedType = info.type;
 
         ChannelValue value;
         ChannelValueInit(&value, expectedType);
@@ -1133,7 +1132,7 @@ size_t DatabusGetRTFactorChannelsNum(Databus * db) {
 }
 
 
-McxStatus DatabusSetOutReference(Databus * db, size_t channel, const void * reference, ChannelType type) {
+McxStatus DatabusSetOutReference(Databus * db, size_t channel, const void * reference, ChannelType * type) {
     ChannelOut * out = NULL;
 
     if (!db) {
@@ -1167,7 +1166,7 @@ McxStatus DatabusSetOutReference(Databus * db, size_t channel, const void * refe
     return out->SetReference(out, reference, type);
 }
 
-McxStatus DatabusSetOutReferenceFunction(Databus * db, size_t channel, const void * reference, ChannelType  type) {
+McxStatus DatabusSetOutReferenceFunction(Databus * db, size_t channel, const void * reference, ChannelType *  type) {
     ChannelOut * out = NULL;
     ChannelInfo * info = NULL;
 
@@ -1206,7 +1205,7 @@ McxStatus DatabusSetOutRefVectorChannel(Databus * db, size_t channel,
     VectorChannelInfo * vInfo = NULL;
     size_t i = 0;
     size_t ii = 0;
-    ChannelType type = ChannelValueType(value);
+    ChannelType * type = ChannelValueType(value);
 
     if (startIdx > endIdx) {
         mcx_log(LOG_ERROR, "Ports: Set out reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
@@ -1251,7 +1250,7 @@ McxStatus DatabusSetOutRefVectorChannel(Databus * db, size_t channel,
 }
 
 McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, const void * reference, ChannelType type)
+    size_t startIdx, size_t endIdx, const void * reference, ChannelType * type)
 {
     VectorChannelInfo * vInfo = NULL;
     size_t i = 0;
@@ -1287,7 +1286,7 @@ McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
             return RETURN_ERROR;
         }
         ii = i - startIdx;
-        switch (type.con) {
+        switch (type->con) {
         case CHANNEL_DOUBLE:
             ref = (const void *) (((double *) reference) + ii);
             break;
@@ -1316,7 +1315,7 @@ McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
     return RETURN_OK;
 }
 
-McxStatus DatabusSetInReference(Databus * db, size_t channel, void * reference, ChannelType  type) {
+McxStatus DatabusSetInReference(Databus * db, size_t channel, void * reference, ChannelType *  type) {
     ChannelIn * in = NULL;
     ChannelInfo * info = NULL;
 
@@ -1352,7 +1351,7 @@ McxStatus DatabusSetInReference(Databus * db, size_t channel, void * reference,
     return in->SetReference(in, reference, type);
 }
 
-McxStatus DatabusSetInRefVector(Databus * db, size_t channel, size_t startIdx, size_t endIdx, void * reference, ChannelType type)
+McxStatus DatabusSetInRefVector(Databus * db, size_t channel, size_t startIdx, size_t endIdx, void * reference, ChannelType * type)
 {
     VectorChannelInfo * vInfo = NULL;
     size_t i = 0;
@@ -1386,11 +1385,11 @@ McxStatus DatabusSetInRefVector(Databus * db, size_t channel, size_t startIdx, s
             return RETURN_ERROR;
         }
         ii = i - startIdx;
-        if (ChannelTypeEq(ChannelTypeDouble, type)) {
+        if (ChannelTypeEq(&ChannelTypeDouble, type)) {
             ref = (void *) (((double *) reference) + ii);
-        } else if (ChannelTypeEq(ChannelTypeInteger, type)) {
+        } else if (ChannelTypeEq(&ChannelTypeInteger, type)) {
             ref = (void *) (((int *) reference) + ii);
-        } else if (ChannelTypeEq(ChannelTypeBool, type)) {
+        } else if (ChannelTypeEq(&ChannelTypeBool, type)) {
             ref = (void *) (((int *) reference) + ii);
         } else {
             mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector not allowed");
@@ -1412,7 +1411,7 @@ McxStatus DatabusSetInRefVectorChannel(Databus * db, size_t channel,
     VectorChannelInfo * vInfo = NULL;
     size_t i = 0;
     size_t ii = 0;
-    ChannelType type = ChannelValueType(value);
+    ChannelType * type = ChannelValueType(value);
 
     if (startIdx > endIdx) {
         mcx_log(LOG_ERROR, "Ports: Set in reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
@@ -1491,7 +1490,7 @@ static McxStatus DatabusAddLocalChannelInternal(Databus * db,
                                                 const char * id,
                                                 const char * unit,
                                                 const void * reference,
-                                                ChannelType type) {
+                                                ChannelType * type) {
     ChannelInfo chInfo = { 0 };
     ChannelLocal * local = NULL;
     Channel * channel = NULL;
@@ -1563,7 +1562,7 @@ McxStatus DatabusAddLocalChannel(Databus * db,
                                  const char * id,
                                  const char * unit,
                                  const void * reference,
-                                 ChannelType type) {
+                                 ChannelType * type) {
     DatabusData * dbData = db->data;
     DatabusInfoData * infoData = dbData->localInfo->data;
 
@@ -1592,7 +1591,7 @@ McxStatus DatabusAddRTFactorChannel(Databus * db,
                                     const char * id,
                                     const char * unit,
                                     const void * reference,
-                                    ChannelType type) {
+                                    ChannelType * type) {
     DatabusData * dbData = db->data;
     DatabusInfoData * infoData = dbData->rtfactorInfo->data;
 
diff --git a/src/core/Databus.h b/src/core/Databus.h
index 70cda7e..dad4d21 100644
--- a/src/core/Databus.h
+++ b/src/core/Databus.h
@@ -86,13 +86,13 @@ size_t DatabusGetRTFactorChannelsNum(struct Databus * db);
 McxStatus DatabusSetOutReference(struct Databus * db,
                                  size_t           channel,
                                  const void     * reference,
-                                 ChannelType      type);
+                                 ChannelType    * type);
 
 
 McxStatus DatabusSetOutReferenceFunction(struct Databus * db,
                                          size_t           channel,
                                          const void     * reference,
-                                         ChannelType      type);
+                                         ChannelType    * type);
 
 /**
  * Connects a variable of type \a type at \a reference to the in channel \a channel
@@ -101,7 +101,7 @@ McxStatus DatabusSetOutReferenceFunction(struct Databus * db,
  *
  * \return \c RETURN_OK on success, or \c RETURN_ERROR otherwise.
  */
-McxStatus DatabusSetInReference(struct Databus * db, size_t channel, void * reference, ChannelType type);
+McxStatus DatabusSetInReference(struct Databus * db, size_t channel, void * reference, ChannelType * type);
 
 /**
  * Adds a local channel of type \a type at \a reference to the databus \a db.
@@ -111,7 +111,7 @@ McxStatus DatabusAddLocalChannel(Databus * db,
                                  const char * id,
                                  const char * unit,
                                  const void * reference,
-                                 ChannelType type);
+                                 ChannelType * type);
 
 /**
  * Adds a rtfactor channel of type \a type at \a reference to the databus \a db.
@@ -121,7 +121,7 @@ McxStatus DatabusAddRTFactorChannel(Databus * db,
                                    const char * id,
                                    const char * unit,
                                    const void * reference,
-                                   ChannelType type);
+                                   ChannelType * type);
 
 /* vector channel functions */
 
@@ -133,13 +133,13 @@ size_t DatabusGetInVectorChannelsNum(Databus * db);
 size_t DatabusGetOutVectorChannelsNum(Databus * db);
 
 McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, const void * reference, ChannelType type);
+    size_t startIdx, size_t endIdx, const void * reference, ChannelType * type);
 
 McxStatus DatabusSetOutRefVectorChannel(Databus * db, size_t channel,
     size_t startIdx, size_t endIdx, ChannelValue * value);
 
 McxStatus DatabusSetInRefVector(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, void * reference, ChannelType type);
+    size_t startIdx, size_t endIdx, void * reference, ChannelType * type);
 McxStatus DatabusSetInRefVectorChannel(Databus * db, size_t channel,
     size_t startIdx, size_t endIdx, ChannelValue * value);
 
diff --git a/src/core/Model.c b/src/core/Model.c
index 5894488..8c9a786 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -136,15 +136,15 @@ static void UpdateBinaryChannelTypes(Vector * connInfos, Task * task) {
             mcx_log(LOG_DEBUG, "Fast binary channel requirements fulfilled for connection %s", buffer);
             mcx_free(buffer);
 
-            trgInfo->type = ChannelTypeBinaryReference;
-            srcInfo->type = ChannelTypeBinaryReference;
+            trgInfo->type = &ChannelTypeBinaryReference;
+            srcInfo->type = &ChannelTypeBinaryReference;
         } else {
             char * buffer = ConnectionInfoConnectionString(info);
             mcx_log(LOG_DEBUG, "Using binary channels for connection %s", buffer);
             mcx_free(buffer);
 
-            trgInfo->type = ChannelTypeBinary;
-            srcInfo->type = ChannelTypeBinary;
+            trgInfo->type = &ChannelTypeBinary;
+            srcInfo->type = &ChannelTypeBinary;
         }
     }
 }
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 56223fa..58c281b 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -59,7 +59,7 @@ static Channel * ChannelCreate(Channel * channel) {
 
     channel->isDefinedDuringInit = FALSE;
     channel->internalValue = NULL;
-    ChannelValueInit(&channel->value, ChannelTypeUnknown);
+    ChannelValueInit(&channel->value, &ChannelTypeUnknown);
 
     channel->Setup = ChannelSetup;
     channel->IsDefinedDuringInit = ChannelIsDefinedDuringInit;
@@ -116,7 +116,7 @@ OBJECT_CLASS(ChannelInData, Object);
 
 
 
-static McxStatus ChannelInSetReference(ChannelIn * in, void * reference, ChannelType type) {
+static McxStatus ChannelInSetReference(ChannelIn * in, void * reference, ChannelType * type) {
     Channel * ch = (Channel *) in;
     ChannelInfo * info = &ch->info;
 
@@ -245,7 +245,7 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         return RETURN_OK;
     }
 
-    if (time->startTime < MCX_DEBUG_LOG_TIME && ChannelTypeEq(info->type, ChannelTypeDouble)) {
+    if (time->startTime < MCX_DEBUG_LOG_TIME && ChannelTypeEq(info->type, &ChannelTypeDouble)) {
         MCX_DEBUG_LOG("[%f] CH IN  (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, * (double *) channel->GetValueReference(channel));
     }
 
@@ -306,8 +306,7 @@ static Connection * ChannelInGetConnection(ChannelIn * in) {
     }
 }
 
-static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection, const char * unit, ChannelType type
-) {
+static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection, const char * unit, ChannelType * type) {
     Channel * channel = (Channel *) in;
     ChannelInfo * inInfo = NULL;
 
@@ -319,7 +318,7 @@ static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection,
     // setup unit conversion
     inInfo = &channel->info;
 
-    if (ChannelTypeEq(inInfo->type, ChannelTypeDouble)) {
+    if (ChannelTypeEq(inInfo->type, &ChannelTypeDouble)) {
         in->data->unitConversion = (UnitConversion *) object_create(UnitConversion);
         retVal = in->data->unitConversion->Setup(in->data->unitConversion,
                                                  unit,
@@ -385,8 +384,8 @@ static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
     // unit conversion is setup when a connection is set
 
     // min/max conversions are only used for double types
-    if (ChannelTypeEq(info->type, ChannelTypeDouble)
-        || ChannelTypeEq(info->type, ChannelTypeInteger))
+    if (ChannelTypeEq(info->type, &ChannelTypeDouble)
+        || ChannelTypeEq(info->type, &ChannelTypeInteger))
     {
         ChannelValue * min = info->min;
         ChannelValue * max = info->max;
@@ -524,8 +523,8 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
 
 
     // min/max conversions are only used for double types
-    if (ChannelTypeEq(info->type, ChannelTypeDouble)
-        || ChannelTypeEq(info->type, ChannelTypeInteger))
+    if (ChannelTypeEq(info->type, &ChannelTypeDouble)
+        || ChannelTypeEq(info->type, &ChannelTypeInteger))
     {
         out->data->rangeConversion = (RangeConversion *) object_create(RangeConversion);
         retVal = out->data->rangeConversion->Setup(out->data->rangeConversion, min, max);
@@ -609,7 +608,7 @@ static int ChannelOutIsConnected(Channel * channel) {
     return FALSE;
 }
 
-static McxStatus ChannelOutSetReference(ChannelOut * out, const void * reference, ChannelType type) {
+static McxStatus ChannelOutSetReference(ChannelOut * out, const void * reference, ChannelType * type) {
     Channel * channel = (Channel *) out;
     ChannelInfo * info = NULL;
 
@@ -643,7 +642,7 @@ static McxStatus ChannelOutSetReference(ChannelOut * out, const void * reference
     return RETURN_OK;
 }
 
-static McxStatus ChannelOutSetReferenceFunction(ChannelOut * out, const proc * reference, ChannelType type) {
+static McxStatus ChannelOutSetReferenceFunction(ChannelOut * out, const proc * reference, ChannelType * type) {
     Channel * channel = (Channel *) out;
     ChannelInfo * info = NULL;
     if (!out) {
@@ -717,7 +716,7 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
         } else {
 #ifdef MCX_DEBUG
             if (time->startTime < MCX_DEBUG_LOG_TIME) {
-                if (ChannelTypeEq(ChannelTypeDouble, info->type)) {
+                if (ChannelTypeEq(&ChannelTypeDouble, info->type)) {
                     MCX_DEBUG_LOG("[%f] CH OUT (%s) (%f, %f)",
                                   time->startTime,
                                   ChannelInfoGetLogName(info),
@@ -734,8 +733,8 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
         }
 
         // Apply conversion
-        if (ChannelTypeEq(info->type, ChannelTypeDouble) ||
-            ChannelTypeEq(info->type, ChannelTypeInteger)) {
+        if (ChannelTypeEq(info->type, &ChannelTypeDouble) ||
+            ChannelTypeEq(info->type, &ChannelTypeInteger)) {
             ChannelValue * val = &channel->value;
 
             // range
@@ -771,7 +770,7 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
     }
 
 
-    if (ChannelTypeEq(ChannelTypeDouble, info->type)) {
+    if (ChannelTypeEq(&ChannelTypeDouble, info->type)) {
         const double * val = NULL;
 
         {
@@ -872,7 +871,7 @@ static int ChannelLocalIsValid(Channel * channel) {
 // TODO: Unify with ChannelOutsetReference (similar code)
 static McxStatus ChannelLocalSetReference(ChannelLocal * local,
                                           const void * reference,
-                                          ChannelType type) {
+                                          ChannelType * type) {
     Channel * channel = (Channel *) local;
     ChannelInfo * info = NULL;
 
diff --git a/src/core/channels/Channel.h b/src/core/channels/Channel.h
index 9847dc1..e022dfb 100644
--- a/src/core/channels/Channel.h
+++ b/src/core/channels/Channel.h
@@ -113,7 +113,7 @@ typedef McxStatus (* fChannelInSetup)(ChannelIn * in, struct ChannelInfo * info)
 
 typedef McxStatus  (* fChannelInSetReference) (ChannelIn   * in,
                                                void        * reference,
-                                               ChannelType   type);
+                                               ChannelType * type);
 
 typedef struct ConnectionInfo * (* fChannelInGetConnectionInfo)(ChannelIn * in);
 
@@ -122,7 +122,7 @@ typedef struct Connection * (* fChannelInGetConnection)(ChannelIn * in);
 typedef McxStatus (* fChannelInSetConnection)(ChannelIn * in,
                                               struct Connection * connection,
                                               const char * unit,
-                                              ChannelType type);
+                                              ChannelType * type);
 
 typedef int (*fChannelInIsDiscrete)(ChannelIn * in);
 typedef void (*fChannelInSetDiscrete)(ChannelIn * in);
@@ -184,10 +184,10 @@ typedef McxStatus (* fChannelOutSetup)(ChannelOut * out,
 
 typedef McxStatus (* fChannelOutSetReference) (ChannelOut * out,
                                                const void * reference,
-                                               ChannelType  type);
+                                               ChannelType * type);
 typedef McxStatus (* fChannelOutSetReferenceFunction) (ChannelOut * out,
                                                        const proc * reference,
-                                                       ChannelType  type);
+                                                       ChannelType * type);
 
 typedef McxStatus (* fChannelOutRegisterConnection)(struct ChannelOut * out,
                                                     struct Connection * connection);
@@ -252,7 +252,7 @@ typedef McxStatus (* fChannelLocalSetup)(ChannelLocal * local, struct ChannelInf
 
 typedef McxStatus (* fChannelLocalSetReference) (ChannelLocal * local,
                                                  const void * reference,
-                                                 ChannelType  type);
+                                                 ChannelType * type);
 
 extern const struct ObjectClass _ChannelLocal;
 
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index e8c72ab..14e0fbe 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -74,7 +74,7 @@ McxStatus ChannelInfoSetUnit(ChannelInfo * info, const char * name) {
     return ChannelInfoSetString(&info->unitString, name);
 }
 
-McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType type) {
+McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType * type) {
     if (ChannelTypeIsValid(info->type)) {
         mcx_log(LOG_ERROR, "Port %s: Type already set", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
@@ -105,7 +105,7 @@ McxStatus ChannelInfoSetup(ChannelInfo * info,
                            const char * nameInModel,
                            const char * descr,
                            const char * unit,
-                           ChannelType  type,
+                           ChannelType * type,
                            const char * id) {
     if (name && RETURN_OK != ChannelInfoSetName(info, name)) {
         mcx_log(LOG_DEBUG, "Port %s: Could not set name", name);
@@ -277,7 +277,7 @@ void ChannelInfoDestroy(ChannelInfo * info) {
 
     info->channel = NULL;
     info->initialValueIsExact = FALSE;
-    info->type = ChannelTypeUnknown;
+    info->type = &ChannelTypeUnknown;
     info->connected = FALSE;
     info->writeResult = TRUE;
 }
@@ -300,7 +300,7 @@ McxStatus ChannelInfoInit(ChannelInfo * info) {
     info->scale = NULL;
     info->offset = NULL;
 
-    info->type = ChannelTypeUnknown;
+    info->type = &ChannelTypeUnknown;
     info->defaultValue = NULL;
     info->initialValue = NULL;
 
diff --git a/src/core/channels/ChannelInfo.h b/src/core/channels/ChannelInfo.h
index a995413..ab26336 100644
--- a/src/core/channels/ChannelInfo.h
+++ b/src/core/channels/ChannelInfo.h
@@ -44,10 +44,11 @@ typedef struct ChannelInfo {
     ChannelValue * max;
     ChannelValue * scale;
     ChannelValue * offset;
+
     ChannelValue * defaultValue;
     ChannelValue * initialValue;
 
-    ChannelType type;
+    ChannelType * type;
 
     int connected;
     int initialValueIsExact;
@@ -66,7 +67,7 @@ McxStatus ChannelInfoSetNameInTool(ChannelInfo * info, const char * name);
 McxStatus ChannelInfoSetID(ChannelInfo * info, const char * name);
 McxStatus ChannelInfoSetDescription(ChannelInfo * info, const char * name);
 McxStatus ChannelInfoSetUnit(ChannelInfo * info, const char * name);
-McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType type);
+McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType * type);
 McxStatus ChannelInfoSetVector(ChannelInfo * info, VectorChannelInfo * vector);
 
 int ChannelInfoIsBinary(const ChannelInfo * info);
@@ -76,7 +77,7 @@ McxStatus ChannelInfoSetup(ChannelInfo * info,
                            const char * nameInModel,
                            const char * descr,
                            const char * unit,
-                           ChannelType  type,
+                           ChannelType * type,
                            const char * id);
 
 McxStatus ChannelInfoSetFrom(ChannelInfo * info, const ChannelInfo * other);
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index cecaf9c..5c0e6f2 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -24,62 +24,67 @@ ChannelType ChannelTypeString = { CHANNEL_STRING, NULL};
 ChannelType ChannelTypeBinary = { CHANNEL_BINARY, NULL};
 ChannelType ChannelTypeBinaryReference = { CHANNEL_BINARY_REFERENCE, NULL};
 
-ChannelType ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims) {
-    ChannelType array;
+ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims) {
+    ChannelType * array = NULL;
 
     if (!inner) {
-        return ChannelTypeUnknown;
+        return &ChannelTypeUnknown;
     }
 
-    array.con = CHANNEL_ARRAY;
-    array.ty.a.inner = inner;
-    array.ty.a.numDims = numDims;
-    array.ty.a.dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
-    if (!array.ty.a.dims) {
-        return ChannelTypeUnknown;
+    array = (ChannelType *) mcx_malloc(sizeof(ChannelType));
+    if (!array) {
+        return &ChannelTypeUnknown;
     }
 
-    memcpy(array.ty.a.dims, dims, sizeof(size_t)*numDims);
+    array->con = CHANNEL_ARRAY;
+    array->ty.a.inner = inner;
+    array->ty.a.numDims = numDims;
+    array->ty.a.dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
+    if (!array->ty.a.dims) {
+        return &ChannelTypeUnknown;
+    }
+
+    memcpy(array->ty.a.dims, dims, sizeof(size_t)*numDims);
 
     return array;
 }
 
-int ChannelTypeIsValid(ChannelType a) {
-    return a.con != CHANNEL_UNKNOWN;
+int ChannelTypeIsValid(ChannelType * a) {
+    return a->con != CHANNEL_UNKNOWN;
 }
 
-int ChannelTypeIsScalar(ChannelType a) {
-    return a.con != CHANNEL_ARRAY;
+int ChannelTypeIsScalar(ChannelType * a) {
+    return a->con != CHANNEL_ARRAY;
 }
 
-int ChannelTypeIsArray(ChannelType a) {
-    return a.con == CHANNEL_ARRAY;
+int ChannelTypeIsArray(ChannelType * a) {
+    return a->con == CHANNEL_ARRAY;
 }
 
-int ChannelTypeIsBinary(ChannelType a) {
-    return a.con == CHANNEL_BINARY || a.con == CHANNEL_BINARY_REFERENCE;
+int ChannelTypeIsBinary(ChannelType * a) {
+    return a->con == CHANNEL_BINARY || a->con == CHANNEL_BINARY_REFERENCE;
 }
 
-int ChannelTypeEq(ChannelType a, ChannelType b) {
-    if (a.con == CHANNEL_ARRAY && b.con == CHANNEL_ARRAY) {
+int ChannelTypeEq(ChannelType * a, ChannelType * b) {
+    if (a->con == CHANNEL_ARRAY && b->con == CHANNEL_ARRAY) {
         size_t i = 0;
-        if (a.ty.a.numDims != b.ty.a.numDims) {
+        if (a->ty.a.numDims != b->ty.a.numDims) {
             return 0;
         }
-        for (i = 0; i < a.ty.a.numDims; i++) {
-            if (a.ty.a.dims[i] != b.ty.a.dims[i]) {
+        for (i = 0; i < a->ty.a.numDims; i++) {
+            if (a->ty.a.dims[i] != b->ty.a.dims[i]) {
                 return 0;
             }
         }
         return 1;
-    } else if ((a.con == CHANNEL_BINARY || a.con == CHANNEL_BINARY_REFERENCE) &&
-        (b.con == CHANNEL_BINARY || b.con == CHANNEL_BINARY_REFERENCE)) {
+    } else if ((a->con == CHANNEL_BINARY || a->con == CHANNEL_BINARY_REFERENCE) &&
+        (b->con == CHANNEL_BINARY || b->con == CHANNEL_BINARY_REFERENCE)) {
     } else {
-        return a.con == b.con;
+        return a->con == b->con;
     }
 }
 
-McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType inner) {
+McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * inner) {
     a->numDims = numDims;
     a->dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
     if (!a->dims) {
@@ -130,25 +135,25 @@ size_t array_num_elements(array * a) {
     return n;
 }
 
-void ChannelValueInit(ChannelValue * value, ChannelType type) {
+void ChannelValueInit(ChannelValue * value, ChannelType * type) {
     value->type = type;
     ChannelValueDataInit(&value->value, type);
 }
 
-void ChannelValueDataDestructor(ChannelValueData * data, ChannelType type) {
-    if (type.con == CHANNEL_STRING) {
+void ChannelValueDataDestructor(ChannelValueData * data, ChannelType * type) {
+    if (type->con == CHANNEL_STRING) {
         if (data->s) {
             mcx_free(data->s);
             data->s = NULL;
         }
-    } else if (type.con == CHANNEL_BINARY) {
+    } else if (type->con == CHANNEL_BINARY) {
         if (data->b.data) {
             mcx_free(data->b.data);
             data->b.data = NULL;
         }
-    } else if (type.con == CHANNEL_BINARY_REFERENCE) {
+    } else if (type->con == CHANNEL_BINARY_REFERENCE) {
         // do not free references to binary, they are not owned by the ChannelValueData
-    } else if (type.con == CHANNEL_ARRAY) {
+    } else if (type->con == CHANNEL_ARRAY) {
         if (data->a.dims) {
             mcx_free(data->a.dims);
             data->a.dims = NULL;
@@ -157,6 +162,8 @@ void ChannelValueDataDestructor(ChannelValueData * data, ChannelType type) {
             mcx_free(data->a.data);
             data->a.data = NULL;
         }
+        // other ChannelTypes are static
+        mcx_free(type);
     }
 }
 
@@ -176,7 +183,7 @@ char * ChannelValueToString(ChannelValue * value) {
     const uint32_t digits_of_exp = 4; // = (mcx_digits10(DBL_MAX_10_EXP) + 1 /* sign */
     char * buffer = NULL;
 
-    switch (value->type.con) {
+    switch (value->type->con) {
     case CHANNEL_DOUBLE:
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         buffer = (char *) mcx_malloc(sizeof(char) * length);
@@ -242,14 +249,14 @@ char * ChannelValueToString(ChannelValue * value) {
     return buffer;
 }
 
-McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, ChannelType type, char * buffer, size_t len) {
+McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, ChannelType * type, char * buffer, size_t len) {
     size_t i = 0;
     size_t length = 0;
     const size_t precision = 13;
     const uint32_t digits_of_exp = 4; // = (mcx_digits10(DBL_MAX_10_EXP) + 1 /* sign */
     const char * doubleFmt = "%*.*E";
 
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         if (len < length) {
@@ -320,20 +327,20 @@ McxStatus ChannelValueToStringBuffer(const ChannelValue * value, char * buffer,
     return ChannelValueDataToStringBuffer(&value->value, value->type, buffer, len);
 }
 
-ChannelType ChannelValueType(ChannelValue * value) {
+ChannelType * ChannelValueType(ChannelValue * value) {
     return value->type;
 }
 
 void * ChannelValueReference(ChannelValue * value) {
-    if (value->type.con == CHANNEL_UNKNOWN) {
+    if (value->type->con == CHANNEL_UNKNOWN) {
         return NULL;
     } else {
         return &value->value;
     }
 }
 
-void ChannelValueDataInit(ChannelValueData * data, ChannelType type) {
-    switch (type.con) {
+void ChannelValueDataInit(ChannelValueData * data, ChannelType * type) {
+    switch (type->con) {
         case CHANNEL_DOUBLE:
             data->d = 0.0;
             break;
@@ -362,10 +369,10 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType type) {
     }
 }
 
-McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference) {
+McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType * type, const void * reference) {
     if (!reference) { return RETURN_OK; } // TODO: change to ERROR
 
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         data->d = * (double *) reference;
         break;
@@ -453,7 +460,7 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
 }
 
 McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
-    switch (value->type.con) {
+    switch (value->type->con) {
     case CHANNEL_DOUBLE:
         * (double *) reference = value->value.d;
         break;
@@ -527,8 +534,8 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
 
 // TODO: invalid size should be (-1)
 #ifdef __cplusplus
-size_t ChannelValueTypeSize(ChannelType type) {
-    switch (type.con) {
+size_t ChannelValueTypeSize(ChannelType * type) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         return sizeof(ChannelValueData::d);
     case CHANNEL_INTEGER:
@@ -546,9 +553,9 @@ size_t ChannelValueTypeSize(ChannelType type) {
     return 0;
 }
 #else //__cplusplus
-size_t ChannelValueTypeSize(ChannelType type) {
+size_t ChannelValueTypeSize(ChannelType * type) {
     ChannelValueData value;
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         return sizeof(value.d);
     case CHANNEL_INTEGER:
@@ -567,12 +574,12 @@ size_t ChannelValueTypeSize(ChannelType type) {
 }
 #endif //__cplusplus
 
-int ChannelTypeMatch(ChannelType a, ChannelType b) {
+int ChannelTypeMatch(ChannelType * a, ChannelType * b) {
     return ChannelTypeEq(a, b);
 }
 
-const char * ChannelTypeToString(ChannelType type) {
-    switch (type.con) {
+const char * ChannelTypeToString(ChannelType * type) {
+    switch (type->con) {
     case CHANNEL_UNKNOWN:
         return "Unknown";
     case CHANNEL_DOUBLE:
@@ -614,7 +621,7 @@ int ChannelValueLeq(ChannelValue * val1, ChannelValue * val2) {
         return 0;
     }
 
-    switch (ChannelValueType(val1).con) {
+    switch (ChannelValueType(val1)->con) {
     case CHANNEL_DOUBLE:
         return val1->value.d <= val2->value.d;
     case CHANNEL_INTEGER:
@@ -629,7 +636,7 @@ int ChannelValueGeq(ChannelValue * val1, ChannelValue * val2) {
         return 0;
     }
 
-    switch (ChannelValueType(val1).con) {
+    switch (ChannelValueType(val1)->con) {
     case CHANNEL_DOUBLE:
         return val1->value.d >= val2->value.d;
     case CHANNEL_INTEGER:
@@ -644,7 +651,7 @@ int ChannelValueEq(ChannelValue * val1, ChannelValue * val2) {
         return 0;
     }
 
-    switch (ChannelValueType(val1).con) {
+    switch (ChannelValueType(val1)->con) {
     case CHANNEL_DOUBLE:
         return val1->value.d == val2->value.d;
     case CHANNEL_BOOL:
@@ -664,7 +671,7 @@ McxStatus ChannelValueAddOffset(ChannelValue * val, ChannelValue * offset) {
         return RETURN_ERROR;
     }
 
-    switch (ChannelValueType(val).con) {
+    switch (ChannelValueType(val)->con) {
     case CHANNEL_DOUBLE:
         val->value.d += offset->value.d;
         return RETURN_OK;
@@ -684,7 +691,7 @@ McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
         return RETURN_ERROR;
     }
 
-    switch (ChannelValueType(val).con) {
+    switch (ChannelValueType(val)->con) {
     case CHANNEL_DOUBLE:
         val->value.d *= factor->value.d;
         return RETURN_OK;
@@ -703,7 +710,7 @@ void ChannelValueDestroy(ChannelValue ** value) {
     *value = NULL;
 }
 
-ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType type) {
+ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType * type) {
     ChannelValue ** array = NULL;
 
     size_t size = ChannelValueTypeSize(type);
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index c0ba1aa..1830d0b 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -51,14 +51,14 @@ extern ChannelType ChannelTypeBool;
 extern ChannelType ChannelTypeString;
 extern ChannelType ChannelTypeBinary;
 extern ChannelType ChannelTypeBinaryReference;
-ChannelType ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims);
+ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims);
 
-int ChannelTypeIsValid(ChannelType a);
-int ChannelTypeIsScalar(ChannelType a);
-int ChannelTypeIsArray(ChannelType a);
-int ChannelTypeIsBinary(ChannelType a);
+int ChannelTypeIsValid(ChannelType * a);
+int ChannelTypeIsScalar(ChannelType * a);
+int ChannelTypeIsArray(ChannelType * a);
+int ChannelTypeIsBinary(ChannelType * a);
 
-int ChannelTypeEq(ChannelType a, ChannelType b);
+int ChannelTypeEq(ChannelType * a, ChannelType * b);
 
 typedef struct MapStringChannelType {
     const char * key;
@@ -84,11 +84,11 @@ typedef struct {
 typedef struct {
     size_t numDims;
     size_t * dims;
-    ChannelType type;
+    ChannelType * type;
     void * data;
 } array;
 
-McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType type);
+McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * type);
 int array_dims_match(array * a, array * b);
 size_t array_num_elements(array * a);
 
@@ -103,40 +103,40 @@ typedef union ChannelValueData {
 } ChannelValueData;
 
 typedef struct ChannelValue {
-    ChannelType type;
+    ChannelType * type;
     ChannelValueData value;
 } ChannelValue;
 
-void   ChannelValueInit(ChannelValue * value, ChannelType type);
+void   ChannelValueInit(ChannelValue * value, ChannelType * type);
 void ChannelValueDestructor(ChannelValue * value);
 char * ChannelValueToString(ChannelValue * value);
-McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, ChannelType type, char * buffer, size_t len);
+McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, ChannelType * type, char * buffer, size_t len);
 McxStatus ChannelValueToStringBuffer(const ChannelValue * value, char * buffer, size_t len);
 
-ChannelType ChannelValueType(ChannelValue * value);
+ChannelType * ChannelValueType(ChannelValue * value);
 void *      ChannelValueReference(ChannelValue * value);
 
-void ChannelValueDataDestructor(ChannelValueData * data, ChannelType type);
-void ChannelValueDataInit(ChannelValueData * data, ChannelType type);
-McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType type, const void * reference);
+void ChannelValueDataDestructor(ChannelValueData * data, ChannelType * type);
+void ChannelValueDataInit(ChannelValueData * data, ChannelType * type);
+McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType * type, const void * reference);
 
 McxStatus ChannelValueSetFromReference(ChannelValue * value, const void * reference);
 McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference);
 
 McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source);
 
-size_t ChannelValueTypeSize(ChannelType type);
-int ChannelTypeMatch(ChannelType a, ChannelType b);
+size_t ChannelValueTypeSize(ChannelType * type);
+int ChannelTypeMatch(ChannelType * a, ChannelType * b);
 
 void ChannelValueDestroy(ChannelValue ** value);
 
-ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType type);
+ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType * type);
 
 /*
  * Returns a string representation of ChannelType for use in log
  * messages.
  */
-const char * ChannelTypeToString(ChannelType type);
+const char * ChannelTypeToString(ChannelType * type);
 
 /*
  * Creates a copy of value. Allocates memory if needed, e.g. when
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 1e6e0d3..b914f2d 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -941,7 +941,7 @@ static size_t MemoryFilterHistorySize(ConnectionInfo * info, int extDegree) {
     return size + model->config->memFilterHistoryExtra;
 }
 
-static MemoryFilter * SetMemoryFilter(int reverseSearch, ChannelType sourceType, size_t historySize) {
+static MemoryFilter * SetMemoryFilter(int reverseSearch, ChannelType * sourceType, size_t historySize) {
     McxStatus retVal = RETURN_OK;
 
     MemoryFilter * filter = (MemoryFilter *)object_create(MemoryFilter);
@@ -976,7 +976,7 @@ ChannelFilter * FilterFactory(Connection * connection) {
     Task * task = model->GetTask(model);
     int useInputsAtEndTime = task->useInputsAtEndTime;
 
-    if (ChannelTypeEq(ConnectionInfoGetType(info), ChannelTypeDouble)) {
+    if (ChannelTypeEq(ConnectionInfoGetType(info), &ChannelTypeDouble)) {
         if (!(INTERVAL_COUPLING == params->interpolationInterval && INTERVAL_SYNCHRONIZATION == params->extrapolationInterval)) {
             mcx_log(LOG_WARNING, "The use of inter/extrapolation interval settings for double is not supported");
         }
@@ -1061,7 +1061,7 @@ ChannelFilter * FilterFactory(Connection * connection) {
         filter = (ChannelFilter *) discreteFilter;
     }
 
-    if (NULL == filter && ChannelTypeEq(ConnectionInfoGetType(info), ChannelTypeDouble)) {
+    if (NULL == filter && ChannelTypeEq(ConnectionInfoGetType(info), &ChannelTypeDouble)) {
         // TODO: add a check to avoid filters for non-multirate cases
 
         size_t memFilterHist = MemoryFilterHistorySize(info, 0);
@@ -1410,7 +1410,7 @@ static Connection * ConnectionCreate(Connection * connection) {
 
     connection->isActiveDependency_ = TRUE;
 
-    ChannelValueInit(&connection->store_, ChannelTypeUnknown);
+    ChannelValueInit(&connection->store_, &ChannelTypeUnknown);
 
     connection->state_ = InCommunicationMode;
 
diff --git a/src/core/connections/ConnectionInfo.c b/src/core/connections/ConnectionInfo.c
index 298091e..606fdb6 100644
--- a/src/core/connections/ConnectionInfo.c
+++ b/src/core/connections/ConnectionInfo.c
@@ -28,7 +28,7 @@ void ConnectionInfoSetDecoupled(ConnectionInfo * info) {
     info->isDecoupled_ = TRUE;
 }
 
-ChannelType ConnectionInfoGetType(ConnectionInfo * info) {
+ChannelType * ConnectionInfoGetType(ConnectionInfo * info) {
     //Return the data type of the corresponding outport of the source component
     Component * source = NULL;
     Databus * db = NULL;
@@ -40,28 +40,28 @@ ChannelType ConnectionInfoGetType(ConnectionInfo * info) {
 
     if (NULL == info) {
         mcx_log(LOG_DEBUG, "ConnectionInfo: GetType: no info available");
-        return ChannelTypeUnknown;
+        return &ChannelTypeUnknown;
     }
     source = info->sourceComponent;
     if (NULL == source) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_DEBUG, "ConnectionInfo '%s': GetType: no source available", buffer);
         mcx_free(buffer);
-        return ChannelTypeUnknown;
+        return &ChannelTypeUnknown;
     }
     db = source->GetDatabus(source);
     if (NULL == db) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_DEBUG, "ConnectionInfo '%s': GetType: no databus available", buffer);
         mcx_free(buffer);
-        return ChannelTypeUnknown;
+        return &ChannelTypeUnknown;
     }
     outInfo = DatabusInfoGetChannel(DatabusGetOutInfo(db), info->sourceChannel);
     if (!outInfo) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_DEBUG, "ConnectionInfo '%s': GetType: no outinfo available", buffer);
         mcx_free(buffer);
-        return ChannelTypeUnknown;
+        return &ChannelTypeUnknown;
     }
 
     info->connType_ = outInfo->type;
@@ -158,7 +158,7 @@ McxStatus ConnectionInfoInit(ConnectionInfo * info) {
 
     info->hasDiscreteTarget = FALSE;
 
-    info->connType_ = ChannelTypeUnknown;
+    info->connType_ = &ChannelTypeUnknown;
 
     return RETURN_OK;
 }
diff --git a/src/core/connections/ConnectionInfo.h b/src/core/connections/ConnectionInfo.h
index ec262c9..23cbff0 100644
--- a/src/core/connections/ConnectionInfo.h
+++ b/src/core/connections/ConnectionInfo.h
@@ -38,7 +38,7 @@ typedef struct ConnectionInfo {
 
     int hasDiscreteTarget;
 
-    ChannelType connType_;
+    ChannelType * connType_;
 
     InterExtrapolatingType isInterExtrapolating;
 
@@ -54,7 +54,7 @@ typedef struct ConnectionInfo {
 McxStatus ConnectionInfoInit(ConnectionInfo * info);
 
 
-ChannelType ConnectionInfoGetType(ConnectionInfo * info);
+ChannelType * ConnectionInfoGetType(ConnectionInfo * info);
 
 int ConnectionInfoIsDecoupled(ConnectionInfo * info);
 void ConnectionInfoSetDecoupled(ConnectionInfo * info);
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 507a314..e142869 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -23,7 +23,7 @@ extern "C" {
 static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionData * data) {
     data->filter = NULL;
 
-    ChannelValueInit(&data->store, ChannelTypeUnknown);
+    ChannelValueInit(&data->store, &ChannelTypeUnknown);
 
     return data;
 }
diff --git a/src/core/connections/filters/DiscreteFilter.c b/src/core/connections/filters/DiscreteFilter.c
index a9e25b7..42bdb84 100644
--- a/src/core/connections/filters/DiscreteFilter.c
+++ b/src/core/connections/filters/DiscreteFilter.c
@@ -46,7 +46,7 @@ static McxStatus DiscreteFilterEnterCommunicationMode(ChannelFilter * filter, do
     return RETURN_OK;
 }
 
-static McxStatus DiscreteFilterSetup(DiscreteFilter * filter, ChannelType type) {
+static McxStatus DiscreteFilterSetup(DiscreteFilter * filter, ChannelType * type) {
     ChannelValueInit(&filter->lastSynchronizationStepValue, type);
     ChannelValueInit(&filter->lastCouplingStepValue, type);
 
@@ -69,8 +69,8 @@ static DiscreteFilter * DiscreteFilterCreate(DiscreteFilter * discreteFilter) {
 
     discreteFilter->Setup = DiscreteFilterSetup;
 
-    ChannelValueInit(&discreteFilter->lastSynchronizationStepValue, ChannelTypeUnknown);
-    ChannelValueInit(&discreteFilter->lastCouplingStepValue, ChannelTypeUnknown);
+    ChannelValueInit(&discreteFilter->lastSynchronizationStepValue, &ChannelTypeUnknown);
+    ChannelValueInit(&discreteFilter->lastCouplingStepValue, &ChannelTypeUnknown);
 
     return discreteFilter;
 }
diff --git a/src/core/connections/filters/DiscreteFilter.h b/src/core/connections/filters/DiscreteFilter.h
index e98af60..cca3e6e 100644
--- a/src/core/connections/filters/DiscreteFilter.h
+++ b/src/core/connections/filters/DiscreteFilter.h
@@ -19,7 +19,7 @@ extern "C" {
 
 typedef struct DiscreteFilter DiscreteFilter;
 
-typedef McxStatus (* fDiscreteFilterSetup)(DiscreteFilter * filter, ChannelType type);
+typedef McxStatus (* fDiscreteFilterSetup)(DiscreteFilter * filter, ChannelType * type);
 
 extern const struct ObjectClass _DiscreteFilter;
 
diff --git a/src/core/connections/filters/MemoryFilter.c b/src/core/connections/filters/MemoryFilter.c
index b5bf3b3..d37e8c9 100644
--- a/src/core/connections/filters/MemoryFilter.c
+++ b/src/core/connections/filters/MemoryFilter.c
@@ -39,7 +39,7 @@ static McxStatus MemoryFilterSetValue(ChannelFilter * filter, double time, Chann
 
 #ifdef MCX_DEBUG
         if (time < MCX_DEBUG_LOG_TIME) {
-            if (ChannelTypeEq(memoryFilter->valueHistoryWrite[0].type, ChannelTypeDouble)) {
+            if (ChannelTypeEq(memoryFilter->valueHistoryWrite[0].type, &ChannelTypeDouble)) {
                 MCX_DEBUG_LOG("MemoryFilter: F SET (%x) (%f, %f)", filter, time, value.d);
             } else {
                 MCX_DEBUG_LOG("MemoryFilter: F SET (%x) (%f, -)", filter, time);
@@ -62,7 +62,7 @@ static ChannelValueData MemoryFilterGetValueReverse(ChannelFilter * filter, doub
         if (double_eq(memoryFilter->timeHistoryRead[i], time)) {
 #ifdef MCX_DEBUG
             if (time < MCX_DEBUG_LOG_TIME) {
-                if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
+                if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, &ChannelTypeDouble)) {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
                 } else {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, -)", filter, time);
@@ -95,7 +95,7 @@ static ChannelValueData MemoryFilterGetValueReverse(ChannelFilter * filter, doub
 
 #ifdef MCX_DEBUG
     if (time < MCX_DEBUG_LOG_TIME) {
-        if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
+        if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, &ChannelTypeDouble)) {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
         } else {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, -)", filter, time);
@@ -116,7 +116,7 @@ static ChannelValueData MemoryFilterGetValue(ChannelFilter * filter, double time
         if (double_eq(memoryFilter->timeHistoryRead[i], time)) {
 #ifdef MCX_DEBUG
             if (time < MCX_DEBUG_LOG_TIME) {
-                if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
+                if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, &ChannelTypeDouble)) {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
                 } else {
                     MCX_DEBUG_LOG("MemoryFilter: F GET (%x) (%f, -)", filter, time);
@@ -149,7 +149,7 @@ static ChannelValueData MemoryFilterGetValue(ChannelFilter * filter, double time
 
 #ifdef MCX_DEBUG
     if (time < MCX_DEBUG_LOG_TIME) {
-        if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, ChannelTypeDouble)) {
+        if (ChannelTypeEq(memoryFilter->valueHistoryRead[i].type, &ChannelTypeDouble)) {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, %f)", filter, time, memoryFilter->valueHistoryRead[i].value.d);
         } else {
             MCX_DEBUG_LOG("MemoryFilter: F GET CLOSEST (%x) (%f, -)", filter, time);
@@ -206,7 +206,7 @@ static McxStatus MemoryFilterEnterCommunicationMode(ChannelFilter * filter, doub
     return RETURN_OK;
 }
 
-static McxStatus MemoryFilterSetup(MemoryFilter * filter, ChannelType type, size_t historySize, int reverseSearch) {
+static McxStatus MemoryFilterSetup(MemoryFilter * filter, ChannelType * type, size_t historySize, int reverseSearch) {
     ChannelFilter * channelFilter = (ChannelFilter *)filter;
     size_t i = 0;
 
diff --git a/src/core/connections/filters/MemoryFilter.h b/src/core/connections/filters/MemoryFilter.h
index 7b97d4a..1561fe6 100644
--- a/src/core/connections/filters/MemoryFilter.h
+++ b/src/core/connections/filters/MemoryFilter.h
@@ -19,7 +19,7 @@ extern "C" {
 
 typedef struct MemoryFilter MemoryFilter;
 
-typedef McxStatus (* fMemoryFilterSetup)(MemoryFilter * filter, ChannelType type, size_t historySize, int reverseSearch);
+typedef McxStatus (* fMemoryFilterSetup)(MemoryFilter * filter, ChannelType * type, size_t historySize, int reverseSearch);
 
 extern const struct ObjectClass _MemoryFilter;
 
diff --git a/src/core/parameters/ParameterProxies.c b/src/core/parameters/ParameterProxies.c
index cf491f4..e48e4ae 100644
--- a/src/core/parameters/ParameterProxies.c
+++ b/src/core/parameters/ParameterProxies.c
@@ -20,12 +20,12 @@ static void ScalarParameterProxySetValue(ScalarParameterProxy * proxy, Fmu2Value
     proxy->value_ = value;
 }
 
-static ChannelType ScalarParameterProxyGetType(ScalarParameterProxy * proxy) {
+static ChannelType * ScalarParameterProxyGetType(ScalarParameterProxy * proxy) {
     if (proxy->value_) {
         return ChannelValueType(&proxy->value_->val);
     }
 
-    return ChannelTypeUnknown;
+    return &ChannelTypeUnknown;
 }
 
 static Fmu2Value * ScalarParameterProxyGetValue(ScalarParameterProxy * proxy) {
@@ -136,13 +136,13 @@ static size_t ArrayParameterProxyGetDim(ArrayParameterProxy * proxy, size_t idx)
     return proxy->dims_[idx];
 }
 
-static ChannelType ArrayParameterProxyGetType(ArrayParameterProxy * proxy) {
+static ChannelType * ArrayParameterProxyGetType(ArrayParameterProxy * proxy) {
     if (proxy->values_->Size(proxy->values_) > 0) {
         Fmu2Value * value = (Fmu2Value *)proxy->values_->At(proxy->values_, 0);
         return ChannelValueType(&value->val);
     }
 
-    return ChannelTypeUnknown;
+    return &ChannelTypeUnknown;
 }
 
 static void ArrayParameterProxyDestructor(ArrayParameterProxy * proxy) {
diff --git a/src/core/parameters/ParameterProxies.h b/src/core/parameters/ParameterProxies.h
index 3d96aec..f4cf7a8 100644
--- a/src/core/parameters/ParameterProxies.h
+++ b/src/core/parameters/ParameterProxies.h
@@ -26,7 +26,7 @@ struct ScalarParameterProxy;
 typedef struct ScalarParameterProxy ScalarParameterProxy;
 
 typedef void (*fScalarParameterProxySetValue)(ScalarParameterProxy * proxy, Fmu2Value * value);
-typedef ChannelType (*fScalarParameterProxyGetType)(ScalarParameterProxy * proxy);
+typedef ChannelType * (*fScalarParameterProxyGetType)(ScalarParameterProxy * proxy);
 typedef Fmu2Value * (*fScalarParameterProxyGetValue)(ScalarParameterProxy * proxy);
 
 extern const struct ObjectClass _ScalarParameterProxy;
@@ -53,7 +53,7 @@ typedef const char * (*fArrayParameterProxyGetUnit)(ArrayParameterProxy * proxy)
 typedef size_t (*fArrayParameterProxyGetNumDims)(ArrayParameterProxy * proxy);
 typedef size_t (*fArrayParameterProxyGetDim)(ArrayParameterProxy * proxy, size_t idx);
 typedef ObjectContainer * (*fArrayParameterProxyGetValues)(ArrayParameterProxy * proxy);
-typedef ChannelType (*fArrayParameterProxyGetType)(ArrayParameterProxy * proxy);
+typedef ChannelType * (*fArrayParameterProxyGetType)(ArrayParameterProxy * proxy);
 typedef fmi2_value_reference_t (*fArrayParameterProxyGetValueReference)(ArrayParameterProxy * proxy, size_t idx);
 typedef ChannelValueData * (*fArrayParameterProxyGetMin)(ArrayParameterProxy * proxy);
 typedef ChannelValueData * (*fArrayParameterProxyGetMax)(ArrayParameterProxy * proxy);
diff --git a/src/fmu/Fmu1Value.c b/src/fmu/Fmu1Value.c
index 1b1266d..e80de39 100644
--- a/src/fmu/Fmu1Value.c
+++ b/src/fmu/Fmu1Value.c
@@ -37,7 +37,7 @@ Fmu1Value * Fmu1ValueCreate(Fmu1Value * v) {
     v->name = NULL;
     v->var = NULL;
     v->channel = NULL;
-    ChannelValueInit(&v->val, ChannelTypeUnknown);
+    ChannelValueInit(&v->val, &ChannelTypeUnknown);
 
     return v;
 }
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index 1d71551..9be5076 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -52,34 +52,34 @@ Fmu2VariableInfo * Fmu2VariableInfoMake(fmi2_import_variable_t * var) {
 
         switch (type) {
             case fmi2_base_type_real:
-                info->type = ChannelTypeDouble;
+                info->type = &ChannelTypeDouble;
                 min.d = fmi2_import_get_real_variable_min(fmi2_import_get_variable_as_real(var));
                 minDefined = min.d != -DBL_MAX;
                 max.d = fmi2_import_get_real_variable_max(fmi2_import_get_variable_as_real(var));
                 maxDefined = max.d != DBL_MAX;
                 break;
             case fmi2_base_type_int:
-                info->type = ChannelTypeInteger;
+                info->type = &ChannelTypeInteger;
                 min.i = fmi2_import_get_integer_variable_min(fmi2_import_get_variable_as_integer(var));
                 minDefined = min.i != -INT_MIN;
                 max.i = fmi2_import_get_integer_variable_max(fmi2_import_get_variable_as_integer(var));
                 maxDefined = max.i != INT_MAX;
                 break;
             case fmi2_base_type_enum:
-                info->type = ChannelTypeInteger;
+                info->type = &ChannelTypeInteger;
                 min.i = fmi2_import_get_enum_variable_min(fmi2_import_get_variable_as_enum(var));
                 minDefined = min.i != -INT_MIN;
                 max.i = fmi2_import_get_enum_variable_max(fmi2_import_get_variable_as_enum(var));
                 maxDefined = max.i != INT_MAX;
                 break;
             case fmi2_base_type_str:
-                info->type = ChannelTypeString;
+                info->type = &ChannelTypeString;
                 break;
             case fmi2_base_type_bool:
-                info->type = ChannelTypeBool;
+                info->type = &ChannelTypeBool;
                 break;
             default:
-                info->type = ChannelTypeUnknown;
+                info->type = &ChannelTypeUnknown;
                 break;
         }
 
@@ -121,7 +121,7 @@ static void Fmu2VariableInfoDestructor(Fmu2VariableInfo * info) {
 }
 
 static Fmu2VariableInfo * Fmu2VariableInfoCreate(Fmu2VariableInfo * info) {
-    info->type = ChannelTypeUnknown;
+    info->type = &ChannelTypeUnknown;
 
     info->min = NULL;
     info->max = NULL;
@@ -253,7 +253,7 @@ static Fmu2Value * Fmu2ValueCreate(Fmu2Value * v) {
     v->channel = NULL;
     v->info = NULL;
 
-    ChannelValueInit(&v->val, ChannelTypeUnknown);
+    ChannelValueInit(&v->val, &ChannelTypeUnknown);
 
     return v;
 }
diff --git a/src/fmu/Fmu2Value.h b/src/fmu/Fmu2Value.h
index 004b277..f811c65 100644
--- a/src/fmu/Fmu2Value.h
+++ b/src/fmu/Fmu2Value.h
@@ -62,7 +62,7 @@ extern const struct ObjectClass _Fmu2VariableInfo;
 typedef struct Fmu2VariableInfo {
     Object _;
 
-    ChannelType type;
+    ChannelType * type;
 
     ChannelValueData * min;
     ChannelValueData * max;
diff --git a/src/fmu/common_fmu1.c b/src/fmu/common_fmu1.c
index e9a9e18..bb91efe 100644
--- a/src/fmu/common_fmu1.c
+++ b/src/fmu/common_fmu1.c
@@ -111,20 +111,20 @@ static fmi1_callback_functions_t fmi1Callbacks = {
     NULL
 };
 
-ChannelType Fmi1TypeToChannelType(fmi1_base_type_enu_t type) {
+ChannelType * Fmi1TypeToChannelType(fmi1_base_type_enu_t type) {
     switch (type) {
     case fmi1_base_type_real:
-        return ChannelTypeDouble;
+        return &ChannelTypeDouble;
     case fmi1_base_type_int:
-        return ChannelTypeInteger;
+        return &ChannelTypeInteger;
     case fmi1_base_type_bool:
-        return ChannelTypeBool;
+        return &ChannelTypeBool;
     case fmi1_base_type_str:
-        return ChannelTypeString;
+        return &ChannelTypeString;
     case fmi1_base_type_enum:
-        return ChannelTypeInteger;
+        return &ChannelTypeInteger;
     default:
-        return ChannelTypeUnknown;
+        return &ChannelTypeUnknown;
     }
 }
 
@@ -381,14 +381,14 @@ static ObjectContainer * Fmu1ReadArrayParamValues(const char * name,
                 goto cleanup_1;
             }
 
-            if (ChannelTypeEq(input->type, ChannelTypeDouble)) {
-                ChannelValueInit(&chVal, ChannelTypeDouble);
+            if (ChannelTypeEq(input->type, &ChannelTypeDouble)) {
+                ChannelValueInit(&chVal, &ChannelTypeDouble);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
                     return RETURN_ERROR;
                 }
             }
             else { // integer
-                ChannelValueInit(&chVal, ChannelTypeInteger);
+                ChannelValueInit(&chVal, &ChannelTypeInteger);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
                     return RETURN_ERROR;
                 }
@@ -548,9 +548,9 @@ McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     }
 
     ChannelValue * const chVal = &fmuVal->val;
-    ChannelType type = ChannelValueType(chVal);
+    ChannelType * type = ChannelValueType(chVal);
 
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
     {
         double value = chVal->value.d;
@@ -632,9 +632,9 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     fmi1_value_reference_t vr[] = { fmuVal->vr };
 
     ChannelValue * const chVal = &fmuVal->val;
-    ChannelType type = ChannelValueType(chVal);
+    ChannelType * type = ChannelValueType(chVal);
 
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         status = fmi1_import_get_real(fmu->fmiImport, vr, 1, (fmi1_real_t *)ChannelValueReference(chVal));
         if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
diff --git a/src/fmu/common_fmu1.h b/src/fmu/common_fmu1.h
index eed6676..945e655 100644
--- a/src/fmu/common_fmu1.h
+++ b/src/fmu/common_fmu1.h
@@ -36,7 +36,7 @@ typedef enum enum_VAR_TYPE {
     VAR_STRING
 } FMI_VAR_TYPE;
 
-ChannelType Fmi1TypeToChannelType(fmi1_base_type_enu_t type);
+ChannelType * Fmi1TypeToChannelType(fmi1_base_type_enu_t type);
 
 
 typedef struct Fmu1CommonStruct {
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 9af68d4..3d0df67 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -31,8 +31,8 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-fmi2_base_type_enu_t ChannelTypeToFmi2Type(ChannelType type) {
-    switch (type.con) {
+fmi2_base_type_enu_t ChannelTypeToFmi2Type(ChannelType * type) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         return fmi2_base_type_real;
     case CHANNEL_INTEGER:
@@ -46,20 +46,20 @@ fmi2_base_type_enu_t ChannelTypeToFmi2Type(ChannelType type) {
     }
 }
 
-ChannelType Fmi2TypeToChannelType(fmi2_base_type_enu_t type) {
+ChannelType * Fmi2TypeToChannelType(fmi2_base_type_enu_t type) {
     switch (type) {
     case fmi2_base_type_real:
-        return ChannelTypeDouble;
+        return &ChannelTypeDouble;
     case fmi2_base_type_int:
-        return ChannelTypeInteger;
+        return &ChannelTypeInteger;
     case fmi2_base_type_bool:
-        return ChannelTypeBool;
+        return &ChannelTypeBool;
     case fmi2_base_type_str:
-        return ChannelTypeString;
+        return &ChannelTypeString;
     case fmi2_base_type_enum:
-        return ChannelTypeInteger;
+        return &ChannelTypeInteger;
     default:
-        return ChannelTypeUnknown;
+        return &ChannelTypeUnknown;
     }
 }
 
@@ -389,14 +389,14 @@ static ObjectContainer* Fmu2ReadArrayParamValues(const char * name,
                 goto fmu2_read_array_param_values_for_cleanup;
             }
 
-            if (ChannelTypeEq(input->type, ChannelTypeDouble)) {
-                ChannelValueInit(&chVal, ChannelTypeDouble);
+            if (ChannelTypeEq(input->type, &ChannelTypeDouble)) {
+                ChannelValueInit(&chVal, &ChannelTypeDouble);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
                     retVal = RETURN_ERROR;
                     goto fmu2_read_array_param_values_for_cleanup;
                 }
             } else { // integer
-                ChannelValueInit(&chVal, ChannelTypeInteger);
+                ChannelValueInit(&chVal, &ChannelTypeInteger);
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
                     retVal = RETURN_ERROR;
                     goto fmu2_read_array_param_values_for_cleanup;
@@ -681,9 +681,9 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     }
 
     ChannelValue * const chVal = &fmuVal->val;
-    ChannelType type = ChannelValueType(chVal);
+    ChannelType * type = ChannelValueType(chVal);
 
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
     {
         fmi2_value_reference_t vr[] = {fmuVal->data->vr.scalar};
@@ -790,9 +790,9 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     char * const name = fmuVal->name;
     ChannelValue * const chVal = &fmuVal->val;
 
-    ChannelType type = ChannelValueType(chVal);
+    ChannelType * type = ChannelValueType(chVal);
 
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
@@ -933,9 +933,9 @@ McxStatus Fmi2RegisterLocalChannelsAtDatabus(ObjectContainer * vals, const char
         const char * name = val->name;
         fmi2_import_unit_t * unit = NULL;
         const char * unitName;
-        ChannelType type = ChannelValueType(&val->val);
+        ChannelType * type = ChannelValueType(&val->val);
 
-        if (ChannelTypeEq(ChannelTypeDouble, type)) {
+        if (ChannelTypeEq(&ChannelTypeDouble, type)) {
             unit = fmi2_import_get_real_variable_unit(fmi2_import_get_variable_as_real(val->data->data.scalar));
         }
         if (unit) {
@@ -974,7 +974,7 @@ ObjectContainer * Fmu2ValueScalarListFromVarList(fmi2_import_variable_list_t * v
     for (i = 0; i < num; i++) {
         fmi2_import_variable_t * var = fmi2_import_get_variable(vars, i);
         char * name = (char *)fmi2_import_get_variable_name(var);
-        ChannelType type = Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var));
+        ChannelType * type = Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var));
 
         Fmu2Value * value = Fmu2ValueScalarMake(name, var, NULL, NULL);
         if (value) {
@@ -1007,7 +1007,7 @@ ObjectContainer * Fmu2ValueScalarListFromValVarList(ObjectContainer * vals, fmi2
     for (i = 0; i < num; i++) {
         fmi2_import_variable_t * var = fmi2_import_get_variable(vars, i);
         char * name = (char *)fmi2_import_get_variable_name(var);
-        ChannelType type = Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var));
+        ChannelType * type = Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var));
         ChannelValue * chVal = (ChannelValue *) vals->At(vals, i);
         Fmu2Value * value = NULL;
 
diff --git a/src/fmu/common_fmu2.h b/src/fmu/common_fmu2.h
index 024d2ee..fe175bb 100644
--- a/src/fmu/common_fmu2.h
+++ b/src/fmu/common_fmu2.h
@@ -23,7 +23,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
-ChannelType Fmi2TypeToChannelType(fmi2_base_type_enu_t type);
+ChannelType * Fmi2TypeToChannelType(fmi2_base_type_enu_t type);
 const char * Fmi2TypeToString(fmi2_base_type_enu_t type);
 
 struct Fmu2CommonStruct;
diff --git a/src/reader/model/components/specific_data/ConstantInput.c b/src/reader/model/components/specific_data/ConstantInput.c
index 415cc72..a5b5559 100644
--- a/src/reader/model/components/specific_data/ConstantInput.c
+++ b/src/reader/model/components/specific_data/ConstantInput.c
@@ -19,7 +19,7 @@ static void ScalarConstantValueInputDestructor(ScalarConstantValueInput * input)
 }
 
 static ScalarConstantValueInput * ScalarConstantValueInputCreate(ScalarConstantValueInput * input) {
-    input->type = ChannelTypeUnknown;
+    input->type = &ChannelTypeUnknown;
     input->value.d = 0.0;
 
     return input;
@@ -32,7 +32,7 @@ static void ArrayConstantValueInputDestructor(ArrayConstantValueInput * input) {
 }
 
 static ArrayConstantValueInput * ArrayConstantValueInputCreate(ArrayConstantValueInput * input) {
-    input->type = ChannelTypeUnknown;
+    input->type = &ChannelTypeUnknown;
 
     input->numValues = 0;
     input->values = NULL;
diff --git a/src/reader/model/components/specific_data/ConstantInput.h b/src/reader/model/components/specific_data/ConstantInput.h
index 5a38b5b..6896fbd 100644
--- a/src/reader/model/components/specific_data/ConstantInput.h
+++ b/src/reader/model/components/specific_data/ConstantInput.h
@@ -25,7 +25,7 @@ extern const ObjectClass _ScalarConstantValueInput;
 typedef struct ScalarConstantValueInput {
     InputElement _;
 
-    ChannelType type;
+    ChannelType * type;
     ChannelValueData value;
 } ScalarConstantValueInput;
 
@@ -34,7 +34,7 @@ extern const ObjectClass _ArrayConstantValueInput;
 typedef struct ArrayConstantValueInput {
     InputElement _;
 
-    ChannelType type;
+    ChannelType * type;
 
     size_t numValues;
     void * values;
diff --git a/src/reader/model/parameters/ArrayParameterInput.c b/src/reader/model/parameters/ArrayParameterInput.c
index d8681b6..b12419a 100644
--- a/src/reader/model/parameters/ArrayParameterInput.c
+++ b/src/reader/model/parameters/ArrayParameterInput.c
@@ -29,7 +29,7 @@ static void ArrayParameterInputDestructor(ArrayParameterInput * input) {
     }
 
     if (input->values) {
-        if (ChannelTypeEq(input->type, ChannelTypeString)) {
+        if (ChannelTypeEq(input->type, &ChannelTypeString)) {
             size_t i = 0;
 
             for (i = 0; i < input->numValues; i++) {
@@ -47,7 +47,7 @@ static ArrayParameterInput * ArrayParameterInputCreate(ArrayParameterInput * inp
     input->numDims = 0;
     input->dims = NULL;
 
-    input->type = ChannelTypeUnknown;
+    input->type = &ChannelTypeUnknown;
 
     input->numValues = 0;
     input->values = NULL;
diff --git a/src/reader/model/parameters/ArrayParameterInput.h b/src/reader/model/parameters/ArrayParameterInput.h
index 8c45675..cf0a0dc 100644
--- a/src/reader/model/parameters/ArrayParameterInput.h
+++ b/src/reader/model/parameters/ArrayParameterInput.h
@@ -29,7 +29,7 @@ typedef struct ArrayParameterInput {
     size_t numDims;
     ArrayParameterDimensionInput ** dims;
 
-    ChannelType type;
+    ChannelType * type;
 
     size_t numValues;
     void * values;
diff --git a/src/reader/model/parameters/ScalarParameterInput.c b/src/reader/model/parameters/ScalarParameterInput.c
index 22783d6..1244cda 100644
--- a/src/reader/model/parameters/ScalarParameterInput.c
+++ b/src/reader/model/parameters/ScalarParameterInput.c
@@ -19,7 +19,7 @@ static void ScalarParameterInputDestructor(ScalarParameterInput * input) {
 
     if (input->unit) { mcx_free(input->unit); }
 
-    if (ChannelTypeEq(input->type, ChannelTypeString) && input->value.defined && input->value.value.s) {
+    if (ChannelTypeEq(input->type, &ChannelTypeString) && input->value.defined && input->value.value.s) {
         mcx_free(input->value.value.s);
     }
 }
@@ -27,7 +27,7 @@ static void ScalarParameterInputDestructor(ScalarParameterInput * input) {
 static ScalarParameterInput * ScalarParameterInputCreate(ScalarParameterInput * input) {
     input->name = NULL;
 
-    input->type = ChannelTypeUnknown;
+    input->type = &ChannelTypeUnknown;
     OPTIONAL_UNSET(input->value);
 
     input->unit = NULL;
diff --git a/src/reader/model/parameters/ScalarParameterInput.h b/src/reader/model/parameters/ScalarParameterInput.h
index b52d1ae..5be3ac0 100644
--- a/src/reader/model/parameters/ScalarParameterInput.h
+++ b/src/reader/model/parameters/ScalarParameterInput.h
@@ -24,7 +24,7 @@ typedef struct ScalarParameterInput {
 
     char * name;
 
-    ChannelType type;
+    ChannelType * type;
     OPTIONAL_VALUE(ChannelValueData) value;
 
     char * unit;
diff --git a/src/reader/model/ports/ScalarPortInput.c b/src/reader/model/ports/ScalarPortInput.c
index 96d732e..13e309b 100644
--- a/src/reader/model/ports/ScalarPortInput.c
+++ b/src/reader/model/ports/ScalarPortInput.c
@@ -132,8 +132,8 @@ static McxStatus CopyFrom(ScalarPortInput * self, ScalarPortInput * src) {
 }
 
 
-static void PrintOptionalChannelValueData(char * prefix, ChannelType type, OPTIONAL_VALUE(ChannelValueData) value) {
-    switch(type.con) {
+static void PrintOptionalChannelValueData(char * prefix, ChannelType * type, OPTIONAL_VALUE(ChannelValueData) value) {
+    switch(type->con) {
     case CHANNEL_DOUBLE:
         if (value.defined) {
             mcx_log(LOG_DEBUG, "%s%f,", prefix, value.value.d);
@@ -208,7 +208,7 @@ static ScalarPortInput * ScalarPortInputCreate(ScalarPortInput * input) {
     input->id = NULL;
     input->unit = NULL;
 
-    input->type = ChannelTypeUnknown;
+    input->type = &ChannelTypeUnknown;
 
     OPTIONAL_UNSET(input->min);
     OPTIONAL_UNSET(input->max);
diff --git a/src/reader/model/ports/ScalarPortInput.h b/src/reader/model/ports/ScalarPortInput.h
index 258e38e..1361328 100644
--- a/src/reader/model/ports/ScalarPortInput.h
+++ b/src/reader/model/ports/ScalarPortInput.h
@@ -32,7 +32,7 @@ struct ScalarPortInput {
     char * id;
     char * unit;
 
-    ChannelType type;
+    ChannelType * type;
 
     OPTIONAL_VALUE(ChannelValueData) min;
     OPTIONAL_VALUE(ChannelValueData) max;
diff --git a/src/reader/model/ports/VectorPortInput.c b/src/reader/model/ports/VectorPortInput.c
index a90b53f..a5d5ab4 100644
--- a/src/reader/model/ports/VectorPortInput.c
+++ b/src/reader/model/ports/VectorPortInput.c
@@ -149,7 +149,7 @@ static McxStatus CopyFrom(VectorPortInput * self, VectorPortInput * src) {
     return RETURN_OK;
 }
 
-static void PrintVec(char * prefix, ChannelType type, size_t len, void * value) {
+static void PrintVec(char * prefix, ChannelType * type, size_t len, void * value) {
     char buffer[4096] = { 0 };
 
     size_t num = 0;
@@ -159,7 +159,7 @@ static void PrintVec(char * prefix, ChannelType type, size_t len, void * value)
 
     if (value) {
         for (i = 0; i < len; i++) {
-            switch(type.con) {
+            switch(type->con) {
             case CHANNEL_DOUBLE:
                 num += sprintf(buffer + num, " %f", ((double*)value)[i]);
                 break;
@@ -235,7 +235,7 @@ static VectorPortInput * VectorPortInputCreate(VectorPortInput * input) {
     input->id = NULL;
     input->unit = NULL;
 
-    input->type = ChannelTypeUnknown;
+    input->type = &ChannelTypeUnknown;
 
     input->min = NULL;
     input->max = NULL;
diff --git a/src/reader/model/ports/VectorPortInput.h b/src/reader/model/ports/VectorPortInput.h
index 9516e31..8dacb80 100644
--- a/src/reader/model/ports/VectorPortInput.h
+++ b/src/reader/model/ports/VectorPortInput.h
@@ -35,7 +35,7 @@ struct VectorPortInput {
     char * id;
     char * unit;
 
-    ChannelType type;
+    ChannelType * type;
 
     void * min;
     void * max;
diff --git a/src/reader/ssp/Parameters.c b/src/reader/ssp/Parameters.c
index 1269e58..83b24b2 100644
--- a/src/reader/ssp/Parameters.c
+++ b/src/reader/ssp/Parameters.c
@@ -672,7 +672,7 @@ static ScalarParameterInput * SSDReadScalarParameter(SSDParameter * parameter) {
 
         for (i = 0; _typeMappingScalar[i].key; i++) {
             if (!strcmp(connectorType, _typeMappingScalar[i].key)) {
-                input->type = *_typeMappingScalar[i].value;
+                input->type = _typeMappingScalar[i].value;
                 break;
             }
         }
@@ -747,10 +747,10 @@ static ArrayParameterDimensionInput * SSDReadArrayParameterDimension(xmlNodePtr
     return input;
 }
 
-static McxStatus AllocateMemory(SSDParameter * parameter, ChannelType type, size_t numValues, void ** dest) {
+static McxStatus AllocateMemory(SSDParameter * parameter, ChannelType * type, size_t numValues, void ** dest) {
     size_t size = 0;
 
-    switch (type.con) {
+    switch (type->con) {
         case CHANNEL_DOUBLE:
             size = sizeof(double);
             break;
@@ -826,7 +826,7 @@ static McxStatus SSDReadDimensionlessArrayParameter(SSDParameter * parameter, Ar
             continue;
         }
 
-        switch (input->type.con) {
+        switch (input->type->con) {
             case CHANNEL_DOUBLE:
                 retVal = xml_attr_double(paramTypeNode, "value", (double*)input->values + paramValue->idx1, SSD_MANDATORY);
                 break;
@@ -912,7 +912,7 @@ static McxStatus SSDReadDimensionArrayParameter(SSDParameter * parameter, ArrayP
             index = (paramValue->idx1 - input->dims[0]->start) * (input->dims[1]->end - input->dims[1]->start + 1) + paramValue->idx2 - input->dims[1]->start;
         }
 
-        switch (input->type.con) {
+        switch (input->type->con) {
             case CHANNEL_DOUBLE:
                 retVal = xml_attr_double(paramTypeNode, "value", (double*)input->values + index, SSD_MANDATORY);
                 break;
@@ -1021,7 +1021,7 @@ static ArrayParameterInput * SSDReadArrayParameter(SSDParameter * parameter) {
 
         for (i = 0; _typeMappingArray[i].key; i++) {
             if (!strcmp(connectorType, _typeMappingArray[i].key)) {
-                input->type = *_typeMappingArray[i].value;
+                input->type = _typeMappingArray[i].value;
                 break;
             }
         }
diff --git a/src/reader/ssp/Ports.c b/src/reader/ssp/Ports.c
index c5f03c1..466520c 100644
--- a/src/reader/ssp/Ports.c
+++ b/src/reader/ssp/Ports.c
@@ -137,7 +137,7 @@ VectorPortInput * SSDReadComponentVectorPort(xmlNodePtr connectorNode, const cha
 
             for (i = 0; _typeMapping[i].key; i++) {
                 if (!strcmp(typeName, _typeMapping[i].key)) {
-                    vectorPortInput->type = *_typeMapping[i].value;
+                    vectorPortInput->type = _typeMapping[i].value;
                     break;
                 }
             }
@@ -173,7 +173,7 @@ VectorPortInput * SSDReadComponentVectorPort(xmlNodePtr connectorNode, const cha
                     xmlNodePtr vectorNode = NULL;
                     size_t num = 0;
 
-                    switch (vectorPortInput->type.con) {
+                    switch (vectorPortInput->type->con) {
                     case CHANNEL_DOUBLE:
                         vectorNode = xml_child(portNode, "RealVector");
                         break;
@@ -351,7 +351,7 @@ ScalarPortInput * SSDReadComponentScalarPort(xmlNodePtr connectorNode, const cha
 
             for (i = 0; _typeMapping[i].key; i++) {
                 if (!strcmp(typeName, _typeMapping[i].key)) {
-                    scalarPortInput->type = *_typeMapping[i].value;
+                    scalarPortInput->type = _typeMapping[i].value;
                     break;
                 }
             }
@@ -387,7 +387,7 @@ ScalarPortInput * SSDReadComponentScalarPort(xmlNodePtr connectorNode, const cha
                     xmlNodePtr scalarNode = NULL;
                     size_t num = 0;
 
-                    switch (scalarPortInput->type.con) {
+                    switch (scalarPortInput->type->con) {
                     case CHANNEL_DOUBLE:
                         scalarNode = xml_child(portNode, "Real");
                         break;
diff --git a/src/reader/ssp/SpecificData.c b/src/reader/ssp/SpecificData.c
index 530693d..b151743 100644
--- a/src/reader/ssp/SpecificData.c
+++ b/src/reader/ssp/SpecificData.c
@@ -177,7 +177,7 @@ static ScalarConstantValueInput * SSDReadScalarConstantValue(xmlNodePtr node) {
 
         for (i = 0; _scalarConstantTypeMapping[i].key; i++) {
             if (!strcmp(xml_node_get_name(node), _scalarConstantTypeMapping[i].key)) {
-                input->type = *_scalarConstantTypeMapping[i].value;
+                input->type = _scalarConstantTypeMapping[i].value;
                 break;
             }
         }
@@ -226,7 +226,7 @@ static ArrayConstantValueInput * SSDReadArrayConstantValue(xmlNodePtr node) {
 
         for (i = 0; _vectorConstantTypeMapping[i].key; i++) {
             if (!strcmp(xml_node_get_name(node), _vectorConstantTypeMapping[i].key)) {
-                input->type = *_vectorConstantTypeMapping[i].value;
+                input->type = _vectorConstantTypeMapping[i].value;
                 break;
             }
         }
@@ -237,7 +237,7 @@ static ArrayConstantValueInput * SSDReadArrayConstantValue(xmlNodePtr node) {
         }
     }
 
-    switch (input->type.con) {
+    switch (input->type->con) {
         case CHANNEL_DOUBLE:
             retVal = xml_attr_double_vec(node, "value", &input->numValues, (double**)&input->values, SSD_MANDATORY);
             break;
diff --git a/src/reader/ssp/Util.c b/src/reader/ssp/Util.c
index 6186dc0..7b883da 100644
--- a/src/reader/ssp/Util.c
+++ b/src/reader/ssp/Util.c
@@ -746,8 +746,8 @@ McxStatus xml_attr_enum_weak_ptr(xmlNodePtr node,
     return ret_status;
 }
 
-McxStatus xml_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType type, ChannelValueData * dest, SSDParamMode mode) {
-    switch (type.con) {
+McxStatus xml_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType * type, ChannelValueData * dest, SSDParamMode mode) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         return xml_attr_double(node, attribute_name, &dest->d, mode);
     case CHANNEL_INTEGER:
@@ -1160,7 +1160,7 @@ McxStatus xml_opt_attr_enum(xmlNodePtr node, const char * attribute_name, MapStr
     return RETURN_OK;
 }
 
-McxStatus xml_opt_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType type, OPTIONAL_VALUE(ChannelValueData) * dest) {
+McxStatus xml_opt_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType * type, OPTIONAL_VALUE(ChannelValueData) * dest) {
     McxStatus ret_val = xml_attr_channel_value_data(node, attribute_name, type, &dest->value, SSD_OPTIONAL);
 
     if (ret_val == RETURN_ERROR) {
@@ -1172,7 +1172,7 @@ McxStatus xml_opt_attr_channel_value_data(xmlNodePtr node, const char * attribut
     return RETURN_OK;
 }
 
-McxStatus xml_attr_vec_len(xmlNodePtr node, const char * attribute_name, ChannelType type, size_t expectedLen, void ** dest, SSDParamMode mode) {
+McxStatus xml_attr_vec_len(xmlNodePtr node, const char * attribute_name, ChannelType * type, size_t expectedLen, void ** dest, SSDParamMode mode) {
     McxStatus ret_status = RETURN_OK;
     int ret_val = 0;
     xmlChar * buffer = NULL;
@@ -1209,7 +1209,7 @@ McxStatus xml_attr_vec_len(xmlNodePtr node, const char * attribute_name, Channel
         goto cleanup;
     }
 
-    switch (type.con) {
+    switch (type->con) {
     case CHANNEL_DOUBLE:
         ret_status = xml_attr_double_vec(node, attribute_name, &len, (double **) &values, mode);
         break;
diff --git a/src/reader/ssp/Util.h b/src/reader/ssp/Util.h
index 524fe31..8c1af9f 100644
--- a/src/reader/ssp/Util.h
+++ b/src/reader/ssp/Util.h
@@ -69,20 +69,20 @@ McxStatus xml_attr_string(xmlNodePtr node, const char * attribute_name, char **
 McxStatus xml_attr_path(xmlNodePtr node, const char * attribute_name, char ** dest, SSDParamMode mode);
 McxStatus xml_attr_enum(xmlNodePtr node, const char * attribute_name, MapStringInt * mapping, int * dest, SSDParamMode mode);
 McxStatus xml_attr_enum_weak_ptr(xmlNodePtr node, const char * attribute_name, void * map[], size_t entry_size, void ** value, SSDParamMode mode);
-McxStatus xml_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType type, ChannelValueData * dest, SSDParamMode mode);
+McxStatus xml_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType * type, ChannelValueData * dest, SSDParamMode mode);
 
 McxStatus xml_opt_attr_double(xmlNodePtr node, const char * attribute_name, OPTIONAL_VALUE(double) * dest);
 McxStatus xml_opt_attr_int(xmlNodePtr node, const char * attribute_name, OPTIONAL_VALUE(int) * dest);
 McxStatus xml_opt_attr_size_t(xmlNodePtr node, const char * attribute_name, OPTIONAL_VALUE(size_t) * dest);
 McxStatus xml_opt_attr_bool(xmlNodePtr node, const char * attribute_name, OPTIONAL_VALUE(int) * dest);
 McxStatus xml_opt_attr_enum(xmlNodePtr node, const char * attribute_name, MapStringInt * mapping, OPTIONAL_VALUE(int) * dest);
-McxStatus xml_opt_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType type, OPTIONAL_VALUE(ChannelValueData) * dest);
+McxStatus xml_opt_attr_channel_value_data(xmlNodePtr node, const char * attribute_name, ChannelType * type, OPTIONAL_VALUE(ChannelValueData) * dest);
 
 McxStatus xml_attr_double_vec(xmlNodePtr node, const char * attribute_name, size_t * len, double ** dest, SSDParamMode mode);
 McxStatus xml_attr_bool_vec(xmlNodePtr node, const char * attribute_name, size_t * len, int ** dest, SSDParamMode mode);
 McxStatus xml_attr_int_vec(xmlNodePtr node, const char * attribute_name, size_t * len, int ** dest, SSDParamMode mode);
 
-McxStatus xml_attr_vec_len(xmlNodePtr node, const char * attribute_name, ChannelType type, size_t expectedLen, void ** dest, SSDParamMode mode);
+McxStatus xml_attr_vec_len(xmlNodePtr node, const char * attribute_name, ChannelType * type, size_t expectedLen, void ** dest, SSDParamMode mode);
 
 /*****************************************************************************/
 /*                                 Errors                                    */
diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index 4a8a3ff..50c6323 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -83,7 +83,7 @@ static McxStatus ChannelStorageSetup(ChannelStorage * channelStore, int fullStor
         goto cleanup;
     }
 
-    retVal = ChannelInfoSetup(&timeInfo, "Time", "Time", "", GetTimeUnitString(), ChannelTypeDouble, "");
+    retVal = ChannelInfoSetup(&timeInfo, "Time", "Time", "", GetTimeUnitString(), &ChannelTypeDouble, "");
     if (RETURN_ERROR == retVal) {
         mcx_log(LOG_ERROR, "Results: Setup port storage: Could not set up time port data");
         goto cleanup;
diff --git a/src/storage/StorageBackendText.c b/src/storage/StorageBackendText.c
index b7ca92f..2f99855 100644
--- a/src/storage/StorageBackendText.c
+++ b/src/storage/StorageBackendText.c
@@ -215,7 +215,7 @@ static McxStatus WriteRow(FILE * file, ChannelValue * values, size_t numChannels
         if (channel == 0) { // leave out separator at the beginning
             sep = "";
         }
-        switch (ChannelValueType(&val).con) {
+        switch (ChannelValueType(&val)->con) {
         case CHANNEL_DOUBLE:
         case CHANNEL_INTEGER:
         case CHANNEL_BOOL:

From 7517e8b6931073abbaf06e35ccc2e6b9307c201e Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 20 Jul 2021 09:44:11 +0200
Subject: [PATCH 021/166] channel: Use ChannelInfo with Dimension instead of
 VectorChannelInfo

Note: This changes the type in Databus `origInfos` from
`VectorChannelInfo` to `ChannelInfo`, but the uses of
`DatabusGetOutVectorChannelInfo` haven't been updated. That means that
this change breaks all components using `DatabusGetOutVectorChannelInfo`.
---
 src/core/Conversion.c                        |  27 +-
 src/core/Databus.c                           | 387 +++++--------------
 src/core/Databus.h                           |   2 -
 src/core/channels/Channel.c                  |   3 +
 src/core/channels/ChannelDimension.c         |  67 ++++
 src/core/channels/ChannelDimension.h         |  39 ++
 src/core/channels/ChannelInfo.c              |   2 +
 src/core/channels/ChannelInfo.h              |   4 +
 src/core/channels/ChannelValue.c             | 147 ++++++-
 src/core/channels/ChannelValue.h             |   6 +
 src/core/connections/ConnectionInfo.c        |   2 +
 src/core/connections/ConnectionInfo.h        |   2 +
 src/core/connections/ConnectionInfoFactory.c |  83 ++--
 src/core/connections/ConnectionInfoFactory.h |   3 +-
 src/core/connections/ConnectionInfo_impl.h   |  67 ++++
 src/core/connections/FilteredConnection.c    |   2 +
 16 files changed, 497 insertions(+), 346 deletions(-)
 create mode 100644 src/core/channels/ChannelDimension.c
 create mode 100644 src/core/channels/ChannelDimension.h
 create mode 100644 src/core/connections/ConnectionInfo_impl.h

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 7adc2ab..942af6f 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -151,7 +151,8 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
     }
 
     if (!(ChannelTypeEq(conversion->type, &ChannelTypeDouble)
-          || ChannelTypeEq(conversion->type, &ChannelTypeInteger))) {
+          || ChannelTypeEq(conversion->type, &ChannelTypeInteger)
+          || ChannelTypeIsArray(conversion->type))) {
         mcx_log(LOG_ERROR, "Range conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -455,7 +456,8 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
     }
 
     if (!(ChannelTypeEq(conversion->type, &ChannelTypeDouble)
-          || ChannelTypeEq(conversion->type, &ChannelTypeInteger))) {
+          || ChannelTypeEq(conversion->type, &ChannelTypeInteger)
+          || ChannelTypeIsArray(conversion->type))) {
         mcx_log(LOG_WARNING, "Linear conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -615,6 +617,25 @@ static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, Chann
     return RETURN_OK;
 }
 
+static McxStatus TypeConversionConvertSingletonDoubleToDouble(Conversion * conversion, ChannelValue * value) {
+    if (!(ChannelTypeIsArray(ChannelValueType(value)) && value->value.a.type, &ChannelTypeDouble)) {
+        ChannelType * array = ChannelTypeArray(&ChannelTypeDouble, 0, NULL);
+        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), array);
+        ChannelTypeDestructor(array);
+        return RETURN_ERROR;
+    }
+
+    double val = *(double *)value->value.a.data;
+
+    ChannelValueDataDestructor(&value->value, value->type);
+    ChannelTypeDestructor(value->type);
+    value->type = &ChannelTypeDouble;
+
+    value->value.d = val;
+
+    return RETURN_OK;
+}
+
 static McxStatus TypeConversionConvertId(Conversion * conversion, ChannelValue * value) {
     return RETURN_OK;
 }
@@ -638,6 +659,8 @@ static McxStatus TypeConversionSetup(TypeConversion * typeConversion,
         conversion->convert = TypeConversionConvertBoolInteger;
     } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeBool)) {
         conversion->convert = TypeConversionConvertIntegerBool;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
+        conversion->convert = TypeConversionConvertSingletonDoubleToDouble;
     } else {
         mcx_log(LOG_ERROR, "Setup type conversion: Illegal conversion selected");
         return RETURN_ERROR;
diff --git a/src/core/Databus.c b/src/core/Databus.c
index 739ef21..63756d9 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -52,257 +52,124 @@ static DatabusInfoData * DatabusInfoDataCreate(DatabusInfoData * data) {
 OBJECT_CLASS(DatabusInfoData, Object);
 
 
-
-char * CreateIndexedName(const char * name, unsigned i) {
-    size_t len = 0;
-    char * buffer = NULL;
-
-    len = strlen(name) + (mcx_digits10(i) + 1) + 2 + 1;
-
-    buffer = (char *) mcx_calloc(len, sizeof(char));
-    if (!buffer) {
-        return NULL;
-    }
-
-    snprintf(buffer, len, "%s[%d]", name, i);
-
-    return buffer;
-}
-
-
-
-static Vector * DatabusReadPortInput(PortInput * input) {
+static ChannelInfo * DatabusReadPortInput(PortInput * input) {
     McxStatus retVal = RETURN_OK;
-    Vector * list = NULL;
-    VectorChannelInfo * vector = NULL;
-
-    list = (Vector *) object_create(Vector);
-    if (!list) {
-        retVal = RETURN_ERROR;
-        goto cleanup_0;
-    }
-
-    list->Setup(list, sizeof(ChannelInfo), ChannelInfoInit, ChannelInfoSetFrom, ChannelInfoDestroy);
 
-    vector = (VectorChannelInfo *)object_create(VectorChannelInfo);
-    if (!vector) {
-        retVal = RETURN_ERROR;
-        goto cleanup_0;
+    ChannelInfo * info = (ChannelInfo *)mcx_calloc(1, sizeof(ChannelInfo));
+    if (!info) {
+        return NULL;
     }
 
     if (input->type == PORT_VECTOR) {
-        /* vector of channels: Copy info and add "[i]" to name, nameInTool and id */
-        ChannelValue ** mins = NULL;
-        ChannelValue ** maxs = NULL;
-        ChannelValue ** scales = NULL;
-        ChannelValue ** offsets = NULL;
-        ChannelValue ** defaults = NULL;
-        ChannelValue ** initials = NULL;
-
-        int startIndex = 0;
-        int endIndex   = 0;
-
-        int i = 0;
-
         VectorPortInput * vectorPortInput = input->port.vectorPort;
         InputElement * vectorPortElement = (InputElement *) vectorPortInput;
 
-        ChannelType * expectedType = vectorPortInput->type;
-        size_t expectedLen = 0;
+        int startIdx = 0;
+        int endIdx   = 0;
 
-        if (!vector) {
-            retVal = RETURN_ERROR;
-            goto cleanup_1;
-        }
-
-        startIndex = vectorPortInput->startIndex;
-        if (startIndex < 0) {
+        startIdx = vectorPortInput->startIndex;
+        if (startIdx < 0) {
             input_element_error(vectorPortElement, "start index must not be smaller than 0");
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        endIndex = vectorPortInput->endIndex;
-        if (endIndex < startIndex) {
+        endIdx = vectorPortInput->endIndex;
+        if (endIdx < startIdx) {
             input_element_error(vectorPortElement, "end index must not be smaller than start index");
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        expectedLen = endIndex - startIndex + 1;
-
-        retVal = vector->Setup(vector, vectorPortInput->name, vectorPortInput->nameInModel, FALSE, (size_t) startIndex, (size_t) endIndex);
-        if (RETURN_ERROR == retVal) {
-            goto cleanup_1;
+        info->dimension = (ChannelDimension *) object_create(ChannelDimension);
+        if (!info->dimension) {
+            retVal = RETURN_ERROR;
+            goto vector_cleanup_0;
         }
 
-        mins = ArrayToChannelValueArray(vectorPortInput->min, expectedLen, expectedType);
-        if (vectorPortInput->min && !mins) {
+        if (RETURN_OK != ChannelDimensionSetup(info->dimension, 1)) {
+            mcx_log(LOG_ERROR, "Could not setup ChannelDimension");
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        maxs = ArrayToChannelValueArray(vectorPortInput->max, expectedLen, expectedType);
-        if (vectorPortInput->max && !maxs) {
+        if (RETURN_OK != ChannelDimensionSetDimension(info->dimension, 0, (size_t) startIdx, (size_t) endIdx)) {
+            mcx_log(LOG_ERROR, "Could not SetDimension");
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        scales = ArrayToChannelValueArray(vectorPortInput->scale, expectedLen, expectedType);
-        if (vectorPortInput->scale && !scales) {
+        size_t dims[1] = { endIdx - startIdx + 1 };
+
+        if (RETURN_OK != ChannelInfoInit(info,
+                                         vectorPortInput->name,
+                                         vectorPortInput->nameInModel,
+                                         vectorPortInput->description,
+                                         vectorPortInput->unit,
+                                         ChannelTypeArray(vectorPortInput->type, 1, dims),
+                                         vectorPortInput->id)) {
+            mcx_log(LOG_ERROR, "Could not Init ChannelInfo");
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        offsets = ArrayToChannelValueArray(vectorPortInput->offset, expectedLen, expectedType);
-        if (vectorPortInput->offset && !offsets) {
+        info->min = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->min);
+        if (!info->min) {
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        defaults = ArrayToChannelValueArray(vectorPortInput->default_, expectedLen, expectedType);
-        if (vectorPortInput->default_ && !defaults) {
+        info->max = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->max);
+        if (!info->max) {
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        initials = ArrayToChannelValueArray(vectorPortInput->initial, expectedLen, expectedType);
-        if (vectorPortInput->initial && !initials) {
+        info->scale = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->scale);
+        if (!info->scale) {
             retVal = RETURN_ERROR;
-            goto cleanup_1;
+            goto vector_cleanup_0;
         }
 
-        for (i = startIndex; i <= endIndex; i++) {
-            char * name       = NULL;
-            char * nameInTool = NULL;
-            char * id         = NULL;
-
-            ChannelInfo copy = { 0 };
-
-            if (!(name = CreateIndexedName(vectorPortInput->name, i))) {
-                retVal = RETURN_ERROR;
-                goto cleanup_2;
-            }
-            if (vectorPortInput->nameInModel) {  // optional
-                if (!(nameInTool = CreateIndexedName(vectorPortInput->nameInModel, i))) {
-                    retVal = RETURN_ERROR;
-                    goto cleanup_2;
-                }
-            }
-            if (vectorPortInput->id) {  // optional
-                if (!(id = CreateIndexedName(vectorPortInput->id, i))) {
-                    retVal = RETURN_ERROR;
-                    goto cleanup_2;
-                }
-            }
-
-            retVal = ChannelInfoInit(&copy);
-            if (RETURN_ERROR == retVal) {
-                goto cleanup_2;
-            }
-
-            ChannelInfoSetName(&copy, name);
-            ChannelInfoSetNameInTool(&copy, nameInTool);
-            ChannelInfoSetID(&copy, id);
-
-            ChannelInfoSetDescription(&copy, vectorPortInput->description);
-            ChannelInfoSetType(&copy, vectorPortInput->type);
-
-            if (!ChannelInfoIsBinary(&copy)) {
-                ChannelInfoSetUnit(&copy, vectorPortInput->unit);
-            } else {
-                ChannelInfoSetUnit(&copy, "-");
-            }
-
-            ChannelInfoSetVector(&copy, (VectorChannelInfo *) object_strong_reference(vector));
-
-            if (mins) {
-                copy.min = mins[i - startIndex];
-            }
-            if (maxs) {
-                copy.max = maxs[i - startIndex];
-            }
-
-            if (scales)  {
-                copy.scale = scales[i - startIndex];
-            }
-            if (offsets) {
-                copy.offset = offsets[i - startIndex];
-            }
-
-            if (defaults) {
-                copy.defaultValue = defaults[i - startIndex];
-            }
-            if (initials) {
-                copy.initialValue = initials[i - startIndex];
-            }
-
-            if (vectorPortInput->writeResults.defined) {
-                copy.writeResult = vectorPortInput->writeResults.value;
-            }
-
-            list->PushBack(list, &copy);
-
-            retVal = vector->AddElement(vector, list->At(list, list->Size(list) - 1), i);
-            if (RETURN_ERROR == retVal) {
-                goto cleanup_2;
-            }
-
-        cleanup_2:
-            if (name) {
-                mcx_free(name);
-            }
-            if (nameInTool) {
-                mcx_free(nameInTool);
-            }
-            if (id) {
-                mcx_free(id);
-            }
-            if (RETURN_ERROR == retVal) {
-                goto cleanup_1;
-            }
+        info->offset = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->offset);
+        if (!info->offset) {
+            retVal = RETURN_ERROR;
+            goto vector_cleanup_0;
         }
 
-    cleanup_1:
-
-        if (mins) {
-            mcx_free(mins);
-        }
-        if (maxs) {
-            mcx_free(maxs);
+        info->initialValue = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->initial);
+        if (!info->initialValue) {
+            retVal = RETURN_ERROR;
+            goto vector_cleanup_0;
         }
 
-        if (scales)  {
-            mcx_free(scales);
-        }
-        if (offsets) {
-            mcx_free(offsets);
+        info->defaultValue = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->default_);
+        if (!info->defaultValue) {
+            retVal = RETURN_ERROR;
+            goto vector_cleanup_0;
         }
 
-        if (defaults) {
-            mcx_free(defaults);
-        }
-        if (initials) {
-            mcx_free(initials);
+        if (vectorPortInput->writeResults.defined) {
+            info->writeResult = vectorPortInput->writeResults.value;
         }
 
-        if (RETURN_ERROR == retVal) {
+    vector_cleanup_0:
+        if (retVal == RETURN_ERROR) {
             goto cleanup_0;
         }
     } else {
         ScalarPortInput * scalarPortInput = input->port.scalarPort;
 
-        ChannelInfo info = { 0 };
-        retVal = ChannelInfoInit(&info);
+        retVal = ChannelInfoInit(info);
         if (RETURN_ERROR == retVal) {
             goto cleanup_else_1;
         }
 
-        ChannelInfoSetName(&info, scalarPortInput->name);
-        ChannelInfoSetNameInTool(&info, scalarPortInput->nameInModel);
-        ChannelInfoSetDescription(&info, scalarPortInput->description);
-        ChannelInfoSetID(&info, scalarPortInput->id);
-        ChannelInfoSetType(&info, scalarPortInput->type);
+        ChannelInfoSetName(info, scalarPortInput->name);
+        ChannelInfoSetNameInTool(info, scalarPortInput->nameInModel);
+        ChannelInfoSetDescription(info, scalarPortInput->description);
+        ChannelInfoSetID(info, scalarPortInput->id);
+        ChannelInfoSetType(info, scalarPortInput->type);
 
         if (!ChannelInfoIsBinary(&info)) {
             ChannelInfoSetUnit(&info, scalarPortInput->unit);
@@ -310,7 +177,7 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             ChannelInfoSetUnit(&info, "-");
         }
 
-        ChannelType * expectedType = info.type;
+        ChannelType * expectedType = info->type;
 
         ChannelValue value;
         ChannelValueInit(&value, expectedType);
@@ -319,8 +186,8 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->min.value)) {
                 goto cleanup_else_1;
             }
-            info.min = ChannelValueClone(&value);
-            if (!info.min) {
+            info->min = ChannelValueClone(&value);
+            if (!info->min) {
                 goto cleanup_else_1;
             }
         }
@@ -329,8 +196,8 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->max.value)) {
                 goto cleanup_else_1;
             }
-            info.max = ChannelValueClone(&value);
-            if (!info.max) {
+            info->max = ChannelValueClone(&value);
+            if (!info->max) {
                 goto cleanup_else_1;
             }
         }
@@ -339,8 +206,8 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->scale.value)) {
                 goto cleanup_else_1;
             }
-            info.scale = ChannelValueClone(&value);
-            if (!info.scale) {
+            info->scale = ChannelValueClone(&value);
+            if (!info->scale) {
                 goto cleanup_else_1;
             }
         }
@@ -349,8 +216,8 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->offset.value)) {
                 goto cleanup_else_1;
             }
-            info.offset = ChannelValueClone(&value);
-            if (!info.offset) {
+            info->offset = ChannelValueClone(&value);
+            if (!info->offset) {
                 goto cleanup_else_1;
             }
         }
@@ -359,8 +226,8 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->default_.value)) {
                 goto cleanup_else_1;
             }
-            info.defaultValue = ChannelValueClone(&value);
-            if (!info.defaultValue) {
+            info->defaultValue = ChannelValueClone(&value);
+            if (!info->defaultValue) {
                 goto cleanup_else_1;
             }
         }
@@ -369,43 +236,27 @@ static Vector * DatabusReadPortInput(PortInput * input) {
             if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->initial.value)) {
                 goto cleanup_else_1;
             }
-            info.initialValue = ChannelValueClone(&value);
-            if (!info.initialValue) {
+            info->initialValue = ChannelValueClone(&value);
+            if (!info->initialValue) {
                 goto cleanup_else_1;
             }
         }
 
         if (scalarPortInput->writeResults.defined) {
-            info.writeResult = scalarPortInput->writeResults.value;
-        }
-
-        retVal = vector->Setup(vector, ChannelInfoGetName(&info), info.nameInTool, TRUE, -1, -1);
-        if (RETURN_ERROR == retVal) {
-            goto cleanup_else_1;
-        }
-        ChannelInfoSetVector(&info, (VectorChannelInfo *) object_strong_reference(vector));
-
-        list->PushBack(list, &info);
-
-        retVal = vector->AddElement(vector, list->At(list, list->Size(list) - 1), 0);
-        if (RETURN_ERROR == retVal) {
-            goto cleanup_else_1;
+            info->writeResult = scalarPortInput->writeResults.value;
         }
 
     cleanup_else_1:
-        ChannelInfoDestroy(&info);
         ChannelValueDestructor(&value);
         goto cleanup_0;
     }
 
 cleanup_0:
     if (RETURN_ERROR == retVal) {
-        object_destroy(list);
+        object_destroy(info);
     }
 
-    object_destroy(vector);
-
-    return list;
+    return info;
 }
 
 static int ChannelInfoSameNamePred(void * elem, const char * name) {
@@ -439,10 +290,6 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
     Vector * dbInfos = dbInfo->data->infos;
     size_t requiredSize = 0;
     ObjectContainer * allChannels = dbInfo->data->origInfos;
-    if (NULL == allChannels) {
-        mcx_log(LOG_ERROR, "Ports: Read port infos: Container of vector ports missing");
-        return RETURN_ERROR;
-    }
 
     for (i = 0; i < numChildren; i++) {
         PortInput * portInput = (PortInput *) input->ports->At(input->ports, i);
@@ -451,76 +298,32 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
         } else {
             requiredSize += portInput->port.vectorPort->endIndex - portInput->port.vectorPort->startIndex + 1;
         }
-    }
-
-    if (requiredSize > 0) {
-        dbInfos->Reserve(dbInfos, requiredSize);
-    }
-
-    for (i = 0; i < numChildren; i++) {
-        PortInput * portInput = (PortInput *) input->ports->At(input->ports, i);
-        Vector * infos = NULL;
 
-        infos = DatabusReadPortInput(portInput);
-        if (!infos) {
-            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read info of port %zu", i);
+        ChannelInfo * info = DatabusReadPortInput(portInput);
+        if (!info) {
+            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read info of port %d", i);
             return RETURN_ERROR;
         }
 
-        for (j = 0; j < infos->Size(infos); j++) {
-            ChannelInfo * info = (ChannelInfo *) infos->At(infos, j);
-            const char * name = ChannelInfoGetName(info);
-            int n = ChannelInfosGetNameIdx(dbInfos, name);
+        info->mode = mode;
 
-            if (n >= 0) { // key already exists
-                mcx_log(LOG_ERROR, "Ports: Duplicate port %s", name);
-                object_destroy(infos);
-                return RETURN_ERROR;
-            }
+        const char * name = ChannelInfoGetName(info);
+        if (info->dimension) {
+            mcx_log(LOG_DEBUG, "    Port: \"%s[%d:%d]\"", name, info->dimension->startIdxs[0], info->dimension->endIdxs[0]);
+        } else {
             mcx_log(LOG_DEBUG, "    Port: \"%s\"", name);
-
-            info->mode = mode;
         }
 
-        for (j = 0; j < infos->Size(infos); ++j) {
-            ChannelInfo * info = (ChannelInfo *) infos->At(infos, j);
-            VectorChannelInfo * vInfo = info->vector;
-            size_t startIdx = vInfo->GetStartIndex(vInfo);
-            size_t idx = startIdx == -1 ? 0 : (startIdx + j);
-            ChannelInfo * infoCpy = NULL;
-
-            retVal = dbInfos->PushBack(dbInfos, info);
-            if (RETURN_OK != retVal) {
-                mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %zu", i);
-                object_destroy(infos);
-                return RETURN_ERROR;
-            }
-
-            infoCpy = dbInfos->At(dbInfos, dbInfos->Size(dbInfos) - 1);
-            retVal = infoCpy->vector->AddElement(infoCpy->vector, infoCpy, idx);
-            if (RETURN_ERROR == retVal) {
-                mcx_log(LOG_ERROR, "Ports: Read port infos: Could not add vector info of port %zu", i);
-                object_destroy(infos);
-                return RETURN_ERROR;
-            }
-
-            if (infos->Size(infos) == 1 && SpecificRead) {
-                retVal = SpecificRead(comp, infoCpy, portInput, i);
-                if (RETURN_ERROR == retVal) {
-                    mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read element specific data of port %zu", i);
-                    return RETURN_ERROR;
-                }
-            }
+        if (RETURN_OK != allChannels->PushBackNamed(allChannels, (Object *) info, name)) {
+            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %d", i);
+            return RETURN_ERROR;
         }
-
-        {
-            size_t dbInfosSize = dbInfos->Size(dbInfos);
-            ChannelInfo * chInfo = (ChannelInfo *)dbInfos->At(dbInfos, dbInfosSize - 1);
-            allChannels->PushBack(allChannels, (Object *) object_strong_reference(chInfo->vector));
+        if (RETURN_OK != dbInfos->PushBack(dbInfos, (Object *) object_strong_reference(info), name)) {
+            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %d", i);
+            return RETURN_ERROR;
         }
-
-        object_destroy(infos);
     }
+
     return RETURN_OK;
 }
 
diff --git a/src/core/Databus.h b/src/core/Databus.h
index dad4d21..d003e85 100644
--- a/src/core/Databus.h
+++ b/src/core/Databus.h
@@ -341,8 +341,6 @@ typedef struct Databus {
     size_t modeSwitchDataSize;
 } Databus;
 
-char * CreateIndexedName(const char * name, unsigned i);
-
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 58c281b..7019c44 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -565,6 +565,9 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
 static McxStatus ChannelOutRegisterConnection(ChannelOut * out, Connection * connection) {
     ObjectList * conns = out->data->connections;
 
+    // TODO: do we have to check that channelout and connection match
+    // in type/dimension?
+
     return conns->PushBack(conns, (Object *) connection);
 }
 
diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
new file mode 100644
index 0000000..a0886b3
--- /dev/null
+++ b/src/core/channels/ChannelDimension.c
@@ -0,0 +1,67 @@
+/********************************************************************************
+ * Copyright (c) 2021 AVL List GmbH and others
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache Software License 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#include "core/channels/ChannelDimension.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+void ChannelDimensionDestructor(ChannelDimension * dimension) {
+    if (dimension->startIdxs) { mcx_free(dimension->startIdxs); }
+    if (dimension->endIdxs) { mcx_free(dimension->endIdxs); }
+}
+
+ChannelDimension * ChannelDimensionCreate(ChannelDimension * dimension) {
+    dimension->num = 0;
+    dimension->startIdxs = NULL;
+    dimension->endIdxs = NULL;
+
+    return dimension;
+}
+
+OBJECT_CLASS(ChannelDimension, Object);
+
+McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num) {
+    dimension->num = num;
+
+    dimension->startIdxs = (size_t *) mcx_calloc(dimension->num, sizeof(size_t));
+    if (!dimension->startIdxs) {
+        goto error_cleanup;
+    }
+    dimension->endIdxs = (size_t *) mcx_calloc(dimension->num, sizeof(size_t));
+    if (!dimension->endIdxs) {
+        goto error_cleanup;
+    }
+
+    return RETURN_OK;
+
+error_cleanup:
+    if (dimension->startIdxs) { mcx_free(dimension->startIdxs); }
+    if (dimension->endIdxs) { mcx_free(dimension->endIdxs); }
+
+    return RETURN_ERROR;
+}
+
+McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end) {
+    if (num > dimension->num) {
+        return RETURN_ERROR;
+    }
+
+    dimension->startIdxs[num] = start;
+    dimension->endIdxs[num] = end;
+
+    return RETURN_OK;
+}
+
+#ifdef __cplusplus
+} /* closing brace for extern "C" */
+#endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
new file mode 100644
index 0000000..20c11f1
--- /dev/null
+++ b/src/core/channels/ChannelDimension.h
@@ -0,0 +1,39 @@
+/********************************************************************************
+ * Copyright (c) 2021 AVL List GmbH and others
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache Software License 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef MCX_CORE_CHANNELS_CHANNELDIMENSION_H
+#define MCX_CORE_CHANNELS_CHANNELDIMENSION_H
+
+#include "CentralParts.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+extern const struct ObjectClass _ChannelDimension;
+
+typedef struct ChannelDimension {
+    Object * _; // super class first
+
+    size_t num;
+    size_t * startIdxs;
+    size_t * endIdxs;
+} ChannelDimension;
+
+
+McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num);
+McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end);
+
+
+#ifdef __cplusplus
+} /* closing brace for extern "C" */
+#endif /* __cplusplus */
+
+#endif // MCX_CORE_CHANNELS_CHANNELDIMENSION_H
\ No newline at end of file
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index 14e0fbe..d75de81 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -285,6 +285,8 @@ void ChannelInfoDestroy(ChannelInfo * info) {
 McxStatus ChannelInfoInit(ChannelInfo * info) {
     info->vector = NULL;
 
+    info->dimension = NULL;
+
     info->name        = NULL;
     info->nameInTool  = NULL;
     info->description = NULL;
diff --git a/src/core/channels/ChannelInfo.h b/src/core/channels/ChannelInfo.h
index ab26336..59815cb 100644
--- a/src/core/channels/ChannelInfo.h
+++ b/src/core/channels/ChannelInfo.h
@@ -13,6 +13,7 @@
 
 #include "core/channels/ChannelValue.h"
 #include "core/channels/VectorChannelInfo.h"
+#include "core/channels/ChannelDimension.h"
 
 #include "common/status.h"
 
@@ -31,6 +32,9 @@ typedef struct ChannelInfo {
 
     struct Channel * channel;
 
+    // Channel is a scalar iff dimension == NULL
+    ChannelDimension * dimension;
+
     char * name;
     char * nameInTool;
     char * description;
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 5c0e6f2..807e767 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -15,6 +15,16 @@
 extern "C" {
 #endif /* __cplusplus */
 
+void * mcx_copy(void * object, size_t size) {
+    void * copy = mcx_malloc(size);
+    if (!copy) {
+        return NULL;
+    }
+
+    memcpy(copy, object, size);
+
+    return copy;
+}
 
 ChannelType ChannelTypeUnknown = { CHANNEL_UNKNOWN, NULL};
 ChannelType ChannelTypeInteger = { CHANNEL_INTEGER, NULL};
@@ -24,6 +34,57 @@ ChannelType ChannelTypeString = { CHANNEL_STRING, NULL};
 ChannelType ChannelTypeBinary = { CHANNEL_BINARY, NULL};
 ChannelType ChannelTypeBinaryReference = { CHANNEL_BINARY_REFERENCE, NULL};
 
+
+ChannelType * ChannelTypeClone(ChannelType * type) {
+    switch (type->con) {
+    case CHANNEL_UNKNOWN:
+    case CHANNEL_INTEGER:
+    case CHANNEL_DOUBLE:
+    case CHANNEL_BOOL:
+    case CHANNEL_STRING:
+    case CHANNEL_BINARY:
+    case CHANNEL_BINARY_REFERENCE:
+        // Scalar types are used statically (&ChannelTypeDouble, etc)
+        return type;
+    case CHANNEL_ARRAY: {
+        ChannelType * clone = (ChannelType *) mcx_calloc(sizeof(ChannelType), 1);
+        if (!clone) { return NULL; }
+
+        clone->con = type->con;
+
+        clone->ty.a.inner = ChannelTypeClone(type->ty.a.inner);
+        clone->ty.a.numDims = type->ty.a.numDims;
+        clone->ty.a.dims = mcx_copy(type->ty.a.dims, sizeof(size_t) * type->ty.a.numDims);
+        if (!clone->ty.a.dims) {
+            mcx_free(clone);
+            return NULL;
+        }
+
+        return clone;
+    }
+    }
+
+    return NULL;
+}
+
+void ChannelTypeDestructor(ChannelType * type) {
+    if (&ChannelTypeUnknown == type) { }
+    else if (&ChannelTypeInteger == type) { }
+    else if (&ChannelTypeDouble == type) { }
+    else if (&ChannelTypeBool == type) { }
+    else if (&ChannelTypeString == type) { }
+    else if (&ChannelTypeBinary == type) { }
+    else if (&ChannelTypeBinaryReference == type) { }
+    else if (type->con == CHANNEL_ARRAY) {
+        // other ChannelTypes are static
+        ChannelTypeDestructor(type->ty.a.inner);
+        mcx_free(type->ty.a.dims);
+        mcx_free(type);
+    } else {
+        mcx_free(type);
+    }
+}
+
 ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims) {
     ChannelType * array = NULL;
 
@@ -136,7 +197,7 @@ size_t array_num_elements(array * a) {
 }
 
 void ChannelValueInit(ChannelValue * value, ChannelType * type) {
-    value->type = type;
+    value->type = ChannelTypeClone(type);
     ChannelValueDataInit(&value->value, type);
 }
 
@@ -155,6 +216,7 @@ void ChannelValueDataDestructor(ChannelValueData * data, ChannelType * type) {
         // do not free references to binary, they are not owned by the ChannelValueData
     } else if (type->con == CHANNEL_ARRAY) {
         if (data->a.dims) {
+
             mcx_free(data->a.dims);
             data->a.dims = NULL;
         }
@@ -162,13 +224,12 @@ void ChannelValueDataDestructor(ChannelValueData * data, ChannelType * type) {
             mcx_free(data->a.data);
             data->a.data = NULL;
         }
-        // other ChannelTypes are static
-        mcx_free(type);
     }
 }
 
 void ChannelValueDestructor(ChannelValue * value) {
     ChannelValueDataDestructor(&value->value, value->type);
+    ChannelTypeDestructor(value->type);
 }
 
 static int isSpecialChar(unsigned char c) {
@@ -242,6 +303,31 @@ char * ChannelValueToString(ChannelValue * value) {
             }
         }
         break;
+    case CHANNEL_ARRAY:{
+        const char * doubleFmt = "% *.*E";
+
+        // TODO:
+
+        length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
+        length *= array_num_elements(&value->value.a);
+        buffer = (char *) mcx_malloc(sizeof(char) * length);
+        if (!buffer) {
+            return NULL;
+        }
+
+        size_t i = 0;
+        size_t n = 0;
+
+        if (array_num_elements(&value->value.a) > 0) {
+            n += sprintf(buffer + n, doubleFmt, (unsigned)precision, (unsigned)precision, ((double *)value->value.a.data)[0]);
+            for (i = 1; i < array_num_elements(&value->value.a); i++) {
+                n += sprintf(buffer + n, ",");
+                n += sprintf(buffer + n, doubleFmt, (unsigned)precision, (unsigned)precision, ((double *)value->value.a.data)[i]);
+            }
+        }
+
+        break;
+    }
     default:
         return NULL;
     }
@@ -315,6 +401,21 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
             }
         }
         break;
+    case CHANNEL_ARRAY: {
+    const char * doubleFmt = "% *.*E";
+
+        // TODO:
+
+        length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
+        if (len < length) {
+            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
+            return RETURN_ERROR;
+        }
+        sprintf(buffer, doubleFmt, (unsigned)precision, (unsigned)precision, *(double *)value->a.data);
+
+
+        break;
+    }
     default:
         mcx_log(LOG_DEBUG, "Port value to string: Unknown type");
         return RETURN_ERROR;
@@ -358,11 +459,17 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType * type) {
             data->b.len = 0;
             data->b.data = NULL;
             break;
-        case CHANNEL_ARRAY:
-            data->a.numDims = 0;
-            data->a.dims = NULL;
-            data->a.data = NULL;
+        case CHANNEL_ARRAY: {
+            void * tmp = data->a.dims;
+            data->a.type = ChannelTypeClone(type->ty.a.inner);
+            data->a.numDims = type->ty.a.numDims;
+            data->a.dims = (size_t *) mcx_calloc(sizeof(size_t), type->ty.a.numDims);
+            if (data->a.dims) {
+                memcpy(data->a.dims, type->ty.a.dims, type->ty.a.numDims * sizeof(size_t));
+            }
+            data->a.data = mcx_calloc(array_num_elements(&data->a), ChannelValueTypeSize(data->a.type));
             break;
+        }
         case CHANNEL_UNKNOWN:
         default:
             break;
@@ -431,7 +538,7 @@ McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType
                 return RETURN_ERROR;
             }
 
-            memcpy(data->a.data, a->data, ChannelValueTypeSize(a->type) * array_num_elements(a));
+            memcpy(data->a.data, a->data, ChannelValueTypeSize(data->a.type) * array_num_elements(&data->a));
         }
     case CHANNEL_UNKNOWN:
     default:
@@ -601,6 +708,8 @@ const char * ChannelTypeToString(ChannelType * type) {
 }
 
 ChannelValue * ChannelValueClone(ChannelValue * value) {
+    if (!value) { return NULL; }
+
     ChannelValue * clone = (ChannelValue *) mcx_malloc(sizeof(ChannelValue));
 
     if (!clone) { return NULL; }
@@ -704,6 +813,28 @@ McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
     }
 }
 
+// Does not take ownership of dims or data
+ChannelValue * ChannelValueNewArray(size_t numDims, size_t dims[], ChannelType * type, void * data) {
+    ChannelValue * value = mcx_malloc(sizeof(ChannelValue));
+    if (!value) {
+        return NULL;
+    }
+
+    ChannelType * arrayType = ChannelTypeArray(type, numDims, dims);
+    if (!ChannelTypeIsValid(arrayType)) {
+        mcx_free(value);
+        return NULL;
+    }
+    ChannelValueInit(value, arrayType);
+    ChannelTypeDestructor(arrayType);
+
+    if (value->value.a.data && data) {
+        memcpy(value->value.a.data, data, ChannelValueTypeSize(type) * array_num_elements(&value->value.a));
+    }
+
+    return value;
+}
+
 void ChannelValueDestroy(ChannelValue ** value) {
     ChannelValueDestructor(*value);
     mcx_free(*value);
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 1830d0b..278acaf 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -18,6 +18,8 @@
 extern "C" {
 #endif /* __cplusplus */
 
+void * mcx_copy(void * object, size_t size);
+
 // possible types of values that can be put on channels
 typedef enum ChannelTypeConstructor {
     CHANNEL_UNKNOWN = 0,
@@ -53,6 +55,9 @@ extern ChannelType ChannelTypeBinary;
 extern ChannelType ChannelTypeBinaryReference;
 ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims);
 
+ChannelType * ChannelTypeClone(ChannelType * type);
+void ChannelTypeDestructor(ChannelType * type);
+
 int ChannelTypeIsValid(ChannelType * a);
 int ChannelTypeIsScalar(ChannelType * a);
 int ChannelTypeIsArray(ChannelType * a);
@@ -128,6 +133,7 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source);
 size_t ChannelValueTypeSize(ChannelType * type);
 int ChannelTypeMatch(ChannelType * a, ChannelType * b);
 
+ChannelValue * ChannelValueNewArray(size_t numDims, size_t dims[], ChannelType * type, void * data);
 void ChannelValueDestroy(ChannelValue ** value);
 
 ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType * type);
diff --git a/src/core/connections/ConnectionInfo.c b/src/core/connections/ConnectionInfo.c
index 606fdb6..1675ae6 100644
--- a/src/core/connections/ConnectionInfo.c
+++ b/src/core/connections/ConnectionInfo.c
@@ -160,6 +160,8 @@ McxStatus ConnectionInfoInit(ConnectionInfo * info) {
 
     info->connType_ = &ChannelTypeUnknown;
 
+    info->sourceDimension = NULL;
+
     return RETURN_OK;
 }
 
diff --git a/src/core/connections/ConnectionInfo.h b/src/core/connections/ConnectionInfo.h
index 23cbff0..8c18150 100644
--- a/src/core/connections/ConnectionInfo.h
+++ b/src/core/connections/ConnectionInfo.h
@@ -13,6 +13,7 @@
 
 #include "CentralParts.h"
 #include "core/Component_interface.h"
+#include "core/channels/ChannelDimension.h"
 
 #define DECOUPLE_DEFAULT DECOUPLE_IFNEEDED
 
@@ -48,6 +49,7 @@ typedef struct ConnectionInfo {
     DecoupleType decoupleType;
     int decouplePriority;
 
+    ChannelDimension * sourceDimension;
 } ConnectionInfo;
 
 
diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index 6de46c3..f0f774b 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -10,9 +10,11 @@
 
 #include "core/connections/ConnectionInfoFactory.h"
 #include "core/connections/ConnectionInfo.h"
+#include "core/channels/ChannelDimension.h"
 #include "core/Databus.h"
 #include "objects/Vector.h"
 
+#include "util/stdlib.h"
 #include "util/string.h"
 
 #ifdef __cplusplus
@@ -20,13 +22,27 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-static McxStatus ConnectionInfoFactoryInitConnectionInfo(
-    ConnectionInfo * info,
-    ObjectContainer * components,
-    ConnectionInput * connInput,
-    Component * sourceCompOverride,
-    Component * targetCompOverride)
-{
+char * CreateIndexedName(const char * name, unsigned i) {
+    size_t len = 0;
+    char * buffer = NULL;
+
+    len = strlen(name) + (mcx_digits10(i) + 1) + 2 + 1;
+
+    buffer = (char *) mcx_calloc(len, sizeof(char));
+    if (!buffer) {
+        return NULL;
+    }
+
+    snprintf(buffer, len, "%s[%d]", name, i);
+
+    return buffer;
+}
+
+static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
+                                                         ObjectContainer * components,
+                                                         ConnectionInput * connInput,
+                                                         Component * sourceCompOverride,
+                                                         Component * targetCompOverride) {
     McxStatus retVal = RETURN_OK;
 
     int id = 0;
@@ -105,19 +121,34 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(
 
         char * inputFromChannel = connInput->fromType == ENDPOINT_SCALAR ? connInput->from.scalarEndpoint->channel :
                                                                            connInput->from.vectorEndpoint->channel;
+
         strFromChannel = mcx_string_copy(inputFromChannel);
         if (0 == strlen(strFromChannel)) {
             retVal = input_element_error((InputElement*)connInput, "Source port name is empty");
             goto cleanup;
         }
 
+        // TODO: multiplexing here?
         if (connInput->fromType == ENDPOINT_VECTOR) {
-            mcx_free(strFromChannel);
-            strFromChannel = CreateIndexedName(inputFromChannel, connInput->from.vectorEndpoint->startIndex);
-            if (!strFromChannel) {
+            ChannelDimension * sourceDimension = (ChannelDimension *) object_create(ChannelDimension);
+            if (!sourceDimension) {
                 retVal = RETURN_ERROR;
                 goto cleanup;
             }
+
+            if (RETURN_OK != ChannelDimensionSetup(sourceDimension, 1)) {
+                mcx_log(LOG_ERROR, "Could not setup ChannelDimension");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            if (RETURN_OK != ChannelDimensionSetDimension(sourceDimension, 0, (size_t) connInput->from.vectorEndpoint->startIndex, (size_t) connInput->from.vectorEndpoint->endIndex)) {
+                mcx_log(LOG_ERROR, "Could not SetDimension");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            info->sourceDimension = sourceDimension;
         }
 
         info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
@@ -259,36 +290,8 @@ Vector * ConnectionInfoFactoryCreateConnectionInfos(
         goto cleanup;
     }
 
-    if (connInput->fromType == ENDPOINT_VECTOR || connInput->toType == ENDPOINT_VECTOR) {
-        /* vector of connections */
-        int fromStartIndex = connInput->fromType == ENDPOINT_VECTOR ? connInput->from.vectorEndpoint->startIndex : 0;
-        int fromEndIndex = connInput->fromType == ENDPOINT_VECTOR ? connInput->from.vectorEndpoint->endIndex : 0;
-
-        int toStartIndex = connInput->toType == ENDPOINT_VECTOR ? connInput->to.vectorEndpoint->startIndex : 0;
-        int toEndIndex = connInput->toType == ENDPOINT_VECTOR ? connInput->to.vectorEndpoint->endIndex : 0;
-
-        int i = 0;
-        int fromStart = info.sourceChannel;
-        int toStart = info.targetChannel;
-
-        if (fromEndIndex - fromStartIndex != toEndIndex - toStartIndex) {
-            /* the lenghts of both sides do not match */
-            mcx_log(LOG_ERROR, "Connection: Lengths of vectors do not match");
-            goto cleanup;
-        }
-
-        for (i = 0; fromStartIndex + i <= fromEndIndex; i++) {
-            ConnectionInfo * copy = NULL;
-
-            list->PushBack(list, &info);
-            copy = (ConnectionInfo *) list->At(list, list->Size(list) - 1);
-            copy->sourceChannel = fromStart + i;
-            copy->targetChannel = toStart + i;
-        }
-    } else {
-        /* info is the only connection: leave as is */
-        list->PushBack(list, &info);
-    }
+    /* info is the only connection: leave as is */
+    list->PushBack(list, &info);
 
     return list;
 
diff --git a/src/core/connections/ConnectionInfoFactory.h b/src/core/connections/ConnectionInfoFactory.h
index 5881b14..e8494da 100644
--- a/src/core/connections/ConnectionInfoFactory.h
+++ b/src/core/connections/ConnectionInfoFactory.h
@@ -20,13 +20,12 @@
 extern "C" {
 #endif /* __cplusplus */
 
-
+char * CreateIndexedName(const char * name, unsigned i);
 Vector * ConnectionInfoFactoryCreateConnectionInfos(ObjectContainer * components,
                                                     ConnectionInput * connInput,
                                                     Component * sourceCompOverride,
                                                     Component * targetCompOverride);
 
-
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
diff --git a/src/core/connections/ConnectionInfo_impl.h b/src/core/connections/ConnectionInfo_impl.h
new file mode 100644
index 0000000..bd7bc91
--- /dev/null
+++ b/src/core/connections/ConnectionInfo_impl.h
@@ -0,0 +1,67 @@
+/********************************************************************************
+ * Copyright (c) 2020 AVL List GmbH and others
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache Software License 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef MCX_CORE_CONNECTIONS_CONNECTIONINFO_IMPL_H
+#define MCX_CORE_CONNECTIONS_CONNECTIONINFO_IMPL_H
+
+/* for interExtrapolation, DecoupleType */
+#include "CentralParts.h"
+
+/* for ChannelType */
+#include "core/channels/ChannelValue.h"
+
+/* for ChannelDimension */
+#include "core/channels/ChannelDimension.h"
+
+/* for Component */
+#include "core/Component.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+// ----------------------------------------------------------------------
+// ConnectionInfo
+
+extern const struct ObjectClass _ConnectionInfoData;
+
+typedef struct ConnectionInfoData {
+    Object _;
+
+    struct Component * sourceComponent;
+    struct Component * targetComponent;
+
+    int sourceChannel;
+    int targetChannel;
+
+    ChannelDimension * sourceDimension;
+
+    // Decouple Info: If this connection is decoupled because of an algebraic loop
+    // in the model (this means that the value of the source for the target is
+    // behind one timestep)
+    int isDecoupled;
+
+    InterExtrapolatingType isInterExtrapolating;
+
+    InterExtrapolationType interExtrapolationType;
+    InterExtrapolationParams * interExtrapolationParams;
+
+    DecoupleType decoupleType;
+    int          decouplePriority;
+
+    int hasDiscreteTarget;
+
+} ConnectionInfoData;
+
+#ifdef __cplusplus
+} /* closing brace for extern "C" */
+#endif /* __cplusplus */
+
+#endif /* MCX_CORE_CONNECTIONS_CONNECTIONINFO_IMPL_H */
\ No newline at end of file
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index e142869..bb7bf27 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -130,6 +130,8 @@ static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInter
     }
 #endif
 
+    // TODO: copy only sourceDimension slice
+
     if (filter && time->startTime >= 0) {
         ChannelValueData value = * (ChannelValueData *) channel->GetValueReference(channel);
         filter->SetValue(filter, time->startTime, value);

From 458edde172a1206dfc4e7ee58cb53320eb560cb3 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 20 Jul 2021 10:01:24 +0200
Subject: [PATCH 022/166] storage: Expand arrays to scalars in the csv backend

---
 src/storage/StorageBackendCsv.c  | 101 ++++++++++++++++++++++++++-----
 src/storage/StorageBackendText.c |   9 +++
 2 files changed, 95 insertions(+), 15 deletions(-)

diff --git a/src/storage/StorageBackendCsv.c b/src/storage/StorageBackendCsv.c
index f5bdef4..0a13c35 100644
--- a/src/storage/StorageBackendCsv.c
+++ b/src/storage/StorageBackendCsv.c
@@ -16,6 +16,7 @@
 #include "storage/StorageBackendCsv.h"
 #include "storage/StorageBackendText_impl.h"
 #include "storage/PPD.h"
+#include "core/connections/ConnectionInfoFactory.h"
 
 #include "util/string.h"
 #include "util/os.h"
@@ -182,6 +183,29 @@ static char * QuoteString(const char * _str) {
     return newStr;
 }
 
+static char * ExpandedChannelNames(const char * name, size_t start, size_t end) {
+    char ** names = (char **) mcx_malloc(sizeof(char *) * (end - start + 1 + 1));
+    if (!names) { return NULL; }
+
+    size_t i = 0;
+
+    for (i = start; i <= end; i++) {
+        names[i-start] = CreateIndexedName(name, i);
+    }
+    names[i-start] = NULL;
+
+    return names;
+}
+
+static void FreeExpandedChannelNames(char ** names) {
+    size_t i = 0;
+    while (names[i]) {
+        mcx_free(names[i]);
+        ++i;
+    }
+    mcx_free(names);
+}
+
 static McxStatus SetupComponentFilesCsv(StorageBackend * backend) {
     StorageBackendText * textBackend = (StorageBackendText *) backend;
     ResultsStorage * storage = backend->storage;
@@ -255,30 +279,77 @@ static McxStatus SetupComponentFilesCsv(StorageBackend * backend) {
             for (chIdx = 0; chIdx < chNum; chIdx++) {
                 ChannelInfo * info = chStore->GetChannelInfo(chStore, chIdx);
                 const char * channelName = ChannelInfoGetName(info);
-                char * quotedChannelName = QuoteString(channelName);
-                const char * sep = textBackend->separator;
-
-                if (chIdx == 0) {
-                    sep = "";
-                }
-                if(quotedChannelName){
-                    mcx_os_fprintf(textFile->fp, "%s\"%s\"", sep, quotedChannelName);
-                    mcx_free(quotedChannelName);
+                ChannelType * type = info->type;
+
+                if (ChannelTypeIsArray(type)) {
+                    if (type->ty.a.numDims > 1) {
+                        // multi-dim not yet supported
+                        continue;
+                    }
+                    ChannelDimension * dimension = info->dimension;
+                    size_t array_start = dimension->startIdxs[0];
+                    size_t array_end = dimension->endIdxs[0];
+
+                    size_t array_idx = 0;
+
+                    char ** names = ExpandedChannelNames(channelName, array_start, array_end);
+                    const char * sep = textBackend->separator;
+                    while (names[array_idx]) {
+                        char * quotedChannelName = QuoteString(names[array_idx]);
+
+                        if(quotedChannelName){
+                            mcx_os_fprintf(textFile->fp, "%s\"%s\"", sep, quotedChannelName);
+                            mcx_free(quotedChannelName);
+                        } else {
+                            mcx_os_fprintf(textFile->fp, "%s", sep);
+                        }
+                        ++array_idx;
+                    }
+                    FreeExpandedChannelNames(names);
                 } else {
-                    mcx_os_fprintf(textFile->fp, "%s", sep);
+                    char * quotedChannelName = QuoteString(channelName);
+                    const char * sep = textBackend->separator;
+
+                    if (chIdx == 0) {
+                        sep = "";
+                    }
+                    if(quotedChannelName){
+                        mcx_os_fprintf(textFile->fp, "%s\"%s\"", sep, quotedChannelName);
+                        mcx_free(quotedChannelName);
+                    } else {
+                        mcx_os_fprintf(textFile->fp, "%s", sep);
+                    }
                 }
-
             }
             mcx_os_fprintf(textFile->fp, "\n");
 
             for (chIdx = 0; chIdx < chNum; chIdx++) {
                 ChannelInfo * info = chStore->GetChannelInfo(chStore, chIdx);
+                ChannelType * type = info->type;
                 const char * channelUnit = info->unitString;
-                const char * sep = textBackend->separator;
-                if (chIdx == 0) {
-                    sep = "";
+
+                if (ChannelTypeIsArray(type)) {
+                    if (type->ty.a.numDims > 1) {
+                        // multi-dim not yet supported
+                        continue;
+                    }
+                    ChannelDimension * dimension = info->dimension;
+                    size_t array_start = dimension->startIdxs[0];
+                    size_t array_end = dimension->endIdxs[0];
+
+                    size_t array_idx = 0;
+
+                    const char * sep = textBackend->separator;
+                    for (array_idx = array_start; array_idx <= array_end; array_idx++) {
+                        mcx_os_fprintf(textFile->fp, "%s%s", sep, channelUnit);
+                    }
+                } else {
+                    const char * sep = textBackend->separator;
+                    if (chIdx == 0) {
+                        sep = "";
+                    }
+                    mcx_os_fprintf(textFile->fp, "%s%s", sep, channelUnit);
                 }
-                mcx_os_fprintf(textFile->fp, "%s%s", sep, channelUnit);
             }
             mcx_os_fprintf(textFile->fp, "\n");
         }
diff --git a/src/storage/StorageBackendText.c b/src/storage/StorageBackendText.c
index 2f99855..b14f4c6 100644
--- a/src/storage/StorageBackendText.c
+++ b/src/storage/StorageBackendText.c
@@ -215,6 +215,9 @@ static McxStatus WriteRow(FILE * file, ChannelValue * values, size_t numChannels
         if (channel == 0) { // leave out separator at the beginning
             sep = "";
         }
+
+        // TODO: This should not mention CHANNEL_* anymore
+
         switch (ChannelValueType(&val)->con) {
         case CHANNEL_DOUBLE:
         case CHANNEL_INTEGER:
@@ -245,6 +248,12 @@ static McxStatus WriteRow(FILE * file, ChannelValue * values, size_t numChannels
             }
             break;
         }
+        case CHANNEL_ARRAY: {
+            char * str = ChannelValueToString(&val);
+            mcx_os_fprintf(file, "%s%s", sep, str);
+            mcx_free(str);
+            break;
+        }
         default:
             mcx_os_fprintf(file, "%s\"\"", sep);
             break;

From 24cbf758778cbc9b8e3c1bcbc61d6587c6485e5e Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 6 Sep 2021 14:58:26 +0200
Subject: [PATCH 023/166] channel: Add ChannelTypeBaseType

---
 src/core/channels/ChannelValue.c | 8 ++++++++
 src/core/channels/ChannelValue.h | 2 ++
 2 files changed, 10 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 807e767..25207df 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -126,6 +126,14 @@ int ChannelTypeIsBinary(ChannelType * a) {
     return a->con == CHANNEL_BINARY || a->con == CHANNEL_BINARY_REFERENCE;
 }
 
+ChannelType * ChannelTypeBaseType(ChannelType * a) {
+    if (ChannelTypeIsArray(a)) {
+        return ChannelTypeBaseType(a->ty.a.inner);
+    } else {
+        return a;
+    }
+}
+
 int ChannelTypeEq(ChannelType * a, ChannelType * b) {
     if (a->con == CHANNEL_ARRAY && b->con == CHANNEL_ARRAY) {
         size_t i = 0;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 278acaf..5ee85ca 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -63,6 +63,8 @@ int ChannelTypeIsScalar(ChannelType * a);
 int ChannelTypeIsArray(ChannelType * a);
 int ChannelTypeIsBinary(ChannelType * a);
 
+ChannelType * ChannelTypeBaseType(ChannelType * a);
+
 int ChannelTypeEq(ChannelType * a, ChannelType * b);
 
 typedef struct MapStringChannelType {

From 0de5c26e495153b545dbd7511802c505e794ee00 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Thu, 22 Jul 2021 09:24:04 +0200
Subject: [PATCH 024/166] channel: Add ChannelValueNewScalar

---
 src/core/channels/ChannelValue.c | 13 +++++++++++++
 src/core/channels/ChannelValue.h |  1 +
 2 files changed, 14 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 25207df..9a77972 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -821,6 +821,19 @@ McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
     }
 }
 
+// Does not take ownership of dims or data
+ChannelValue * ChannelValueNewScalar(ChannelType * type, void * data) {
+    ChannelValue * value = mcx_malloc(sizeof(ChannelValue));
+    if (!value) {
+        return NULL;
+    }
+
+    ChannelValueInit(value, type);
+    ChannelValueSetFromReference(value, data);
+
+    return value;
+}
+
 // Does not take ownership of dims or data
 ChannelValue * ChannelValueNewArray(size_t numDims, size_t dims[], ChannelType * type, void * data) {
     ChannelValue * value = mcx_malloc(sizeof(ChannelValue));
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 5ee85ca..be15765 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -135,6 +135,7 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source);
 size_t ChannelValueTypeSize(ChannelType * type);
 int ChannelTypeMatch(ChannelType * a, ChannelType * b);
 
+ChannelValue * ChannelValueNewScalar(ChannelType * type, void * data);
 ChannelValue * ChannelValueNewArray(size_t numDims, size_t dims[], ChannelType * type, void * data);
 void ChannelValueDestroy(ChannelValue ** value);
 

From 888534e8cec4faf16d5cef70e835c4ca6dc425d7 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Thu, 22 Jul 2021 09:23:27 +0200
Subject: [PATCH 025/166] constant: Remove use of VectorChannelInfo

---
 src/components/comp_constant.c | 55 +++++++++++-----------------------
 1 file changed, 18 insertions(+), 37 deletions(-)

diff --git a/src/components/comp_constant.c b/src/components/comp_constant.c
index 1825b67..c1b1140 100644
--- a/src/components/comp_constant.c
+++ b/src/components/comp_constant.c
@@ -10,6 +10,7 @@
 
 #include "components/comp_constant.h"
 
+#include "core/channels/ChannelValue.h"
 #include "core/Databus.h"
 #include "reader/model/components/specific_data/ConstantInput.h"
 
@@ -23,37 +24,27 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
     ConstantInput * constantInput = (ConstantInput *)input;
 
     Databus * db = comp->GetDatabus(comp);
-    size_t numVecOut = DatabusGetOutVectorChannelsNum(db);
+    size_t numOut = DatabusGetOutChannelsNum(db);
 
-    // We read each vector channel (scalars are vectors of length 1)
-    // and the corresponding values from the input file.
-    compConstant->values = (ChannelValue **)mcx_calloc(numVecOut, sizeof(ChannelValue *));
+    compConstant->values = (ChannelValue **)mcx_calloc(numOut, sizeof(ChannelValue *));
 
     if (constantInput->values) {
         ConstantValuesInput * values = constantInput->values;
         size_t i = 0;
 
-        for (i = 0; i < numVecOut; i++) {
+        for (i = 0; i < numOut; i++) {
             ConstantValueInput * value = (ConstantValueInput *)values->values->At(values->values, i);
             if (value->type == CONSTANT_VALUE_SCALAR) {
-                compConstant->values[i] = (ChannelValue *)mcx_calloc(1, sizeof(ChannelValue));
-                ChannelValueInit(compConstant->values[i], value->value.scalar->type);
-                if (RETURN_OK != ChannelValueSetFromReference(compConstant->values[i], &value->value.scalar->value)) {
+                compConstant->values[i] = ChannelValueNewScalar(value->value.scalar->type, &value->value.scalar->value);
+                if (!compConstant->values[i]) {
                     ComponentLog(comp, LOG_ERROR, "Could not set channel value");
                     return RETURN_ERROR;
                 }
             } else {
-                size_t j = 0;
-                size_t size = ChannelValueTypeSize(value->value.array->type);
-                compConstant->values[i] = (ChannelValue *)mcx_calloc(value->value.array->numValues,
-                                                                     sizeof(ChannelValue));
-                for (j = 0; j < value->value.array->numValues; j++) {
-                    ChannelValueInit(compConstant->values[i] + j, value->value.array->type);
-                    if (RETURN_OK != ChannelValueSetFromReference(compConstant->values[i] + j,
-                                                                  (char *)value->value.array->values + j * size)) {
-                        ComponentLog(comp, LOG_ERROR, "Could not set channel value");
-                        return RETURN_ERROR;
-                    }
+                compConstant->values[i] = ChannelValueNewArray(1, &value->value.array->numValues, value->value.array->type, value->value.array->values);
+                if (!compConstant->values[i]) {
+                    ComponentLog(comp, LOG_ERROR, "Could not set channel value");
+                    return RETURN_ERROR;
                 }
             }
         }
@@ -103,16 +94,12 @@ static McxStatus Setup(Component * comp) {
     CompConstant * constComp = (CompConstant *)comp;
     McxStatus retVal = RETURN_OK;
     Databus * db = comp->GetDatabus(comp);
-    size_t numVecOut = DatabusGetOutVectorChannelsNum(db);
+    size_t numOut = DatabusGetOutChannelsNum(db);
 
     size_t i = 0;
 
-    for (i = 0; i < numVecOut; i++) {
-        VectorChannelInfo * vInfo = DatabusGetOutVectorChannelInfo(db, i);
-        size_t startIdx = vInfo->GetStartIndex(vInfo);
-        size_t endIdx = vInfo->GetEndIndex(vInfo);
-        size_t numCh = endIdx - startIdx;
-        retVal = DatabusSetOutRefVectorChannel(db, i, startIdx, endIdx, constComp->values[i]);
+    for (i = 0; i < numOut; i++) {
+        retVal = DatabusSetOutReference(db, i, (void *) &constComp->values[i]->value, constComp->values[i]->type);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
             return RETURN_ERROR;
@@ -134,18 +121,12 @@ static void CompConstantDestructor(CompConstant * compConst) {
     Component * comp = (Component *)compConst;
     McxStatus retVal = RETURN_OK;
     Databus * db = comp->GetDatabus(comp);
-    size_t numVecOut = DatabusGetOutVectorChannelsNum(db);
+    size_t numOut = DatabusGetOutChannelsNum(db);
 
-    if (numVecOut > 0 && compConst->values != NULL) {
-        size_t i, j;
-        for (i = 0; i < numVecOut; i++) {
-            VectorChannelInfo * vInfo = DatabusGetOutVectorChannelInfo(db, i);
-            size_t startIdx = vInfo->GetStartIndex(vInfo);
-            size_t endIdx = vInfo->GetEndIndex(vInfo);
-            size_t numCh = endIdx - startIdx + 1;
-            for (j = 0; j < numCh; j++) {
-                ChannelValueDestructor(&compConst->values[i][j]);
-            }
+    if (numOut > 0 && compConst->values != NULL) {
+        size_t i;
+        for (i = 0; i < numOut; i++) {
+            ChannelValueDestructor(compConst->values[i]);
             mcx_free(compConst->values[i]);
         }
         mcx_free(compConst->values);

From e8e149519713111d8e2bf60723bef3f87070c7bc Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Fri, 10 Sep 2021 12:08:49 +0200
Subject: [PATCH 026/166] value: Add array_destroy

---
 src/core/channels/ChannelValue.c | 6 ++++++
 src/core/channels/ChannelValue.h | 1 +
 2 files changed, 7 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 9a77972..543b52c 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -170,6 +170,12 @@ McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * inn
     return RETURN_OK;
 }
 
+void array_destroy(array * a) {
+    if (a->dims) { mcx_free(a->dims); }
+    if (a->data) { mcx_free(a->data); }
+    if (a->type) { ChannelTypeDestructor(a->type); }
+}
+
 int array_dims_match(array * a, array * b) {
     size_t i = 0;
 
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index be15765..8d79666 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -96,6 +96,7 @@ typedef struct {
 } array;
 
 McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * type);
+void array_destroy(array * a);
 int array_dims_match(array * a, array * b);
 size_t array_num_elements(array * a);
 

From 67c0d1bb3b1466c3fd50086509d3b1678346de41 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Fri, 20 Aug 2021 06:40:25 +0200
Subject: [PATCH 027/166] vector_integrator: Remove use of VectorChannelInfo

---
 src/components/comp_vector_integrator.c | 123 +++++++++++++++---------
 1 file changed, 77 insertions(+), 46 deletions(-)

diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 6eaeda6..295ac6b 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -11,6 +11,7 @@
 #include "components/comp_vector_integrator.h"
 
 #include "core/Databus.h"
+#include "core/channels/ChannelValue.h"
 #include "reader/model/components/specific_data/VectorIntegratorInput.h"
 
 #ifdef __cplusplus
@@ -20,9 +21,10 @@ extern "C" {
 typedef struct CompVectorIntegrator {
     Component _;
 
-    size_t numStates;
-    double * state;
-    double * deriv;
+    size_t num;
+
+    ChannelValue * state;
+    ChannelValue * deriv;
 
     double initialState;
 
@@ -33,32 +35,52 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
     CompVectorIntegrator * integrator = (CompVectorIntegrator *) comp;
     VectorIntegratorInput * integratorInput = (VectorIntegratorInput *) input;
 
-    size_t numAllIn = 0, numAllOut = 0;
     size_t i = 0;
 
     Databus * db = comp->GetDatabus(comp);
-    size_t numVecIn = DatabusGetInVectorChannelsNum(db);
-    size_t numVecOut = DatabusGetOutVectorChannelsNum(db);
+    size_t numIn = DatabusGetInChannelsNum(db);
+    size_t numOut = DatabusGetOutChannelsNum(db);
 
-    for (i = 0; i < numVecIn; i++) {
-        VectorChannelInfo *vInfo = DatabusGetInVectorChannelInfo(db, i);
-        size_t numCh = vInfo->GetEndIndex(vInfo) - vInfo->GetStartIndex(vInfo) + 1;
-        numAllIn += numCh;
+    if (numIn != numOut) {
+        ComponentLog(comp, LOG_ERROR, "#inports (%d) does not match the #outports (%d)", numIn, numOut);
+        return RETURN_ERROR;
     }
-    for (i = 0; i < numVecOut; i++) {
-        VectorChannelInfo *vInfo = DatabusGetOutVectorChannelInfo(db, i);
-        size_t numCh = vInfo->GetEndIndex(vInfo) - vInfo->GetStartIndex(vInfo) + 1;
-        numAllOut += numCh;
+
+    integrator->num = numOut;
+
+    integrator->deriv = mcx_calloc(sizeof(ChannelValue), integrator->num);
+    if (!integrator->deriv) {
+        return RETURN_ERROR;
     }
 
-    if (numAllIn != numAllOut) {
-        ComponentLog(comp, LOG_ERROR, "#inports (%d) does not match the #outports (%d)", numAllIn, numAllOut);
+    integrator->state = mcx_calloc(sizeof(ChannelValue), integrator->num);
+    if (!integrator->state) {
         return RETURN_ERROR;
     }
 
-    integrator->numStates = numAllOut;
     integrator->initialState = integratorInput->initialState.defined ? integratorInput->initialState.value : 0.0;
 
+    for (i = 0; i < integrator->num; i++) {
+        ChannelInfo * inInfo = DatabusGetInChannelInfo(db, i);
+        ChannelInfo * outInfo = DatabusGetOutChannelInfo(db, i);
+
+        if (!ChannelTypeEq(inInfo->GetType(inInfo), outInfo->GetType(outInfo))) {
+            ComponentLog(comp, LOG_ERROR, "Types of inport %s and outport %s do not match", inInfo->GetName(inInfo), outInfo->GetName(outInfo));
+            return RETURN_ERROR;
+        }
+
+        ChannelInfo * info = outInfo;
+        ChannelType * type = info->GetType(info);
+
+        if (!ChannelTypeEq(type, &ChannelTypeDouble) || ChannelTypeIsArray(type)) {
+            ComponentLog(comp, LOG_ERROR, "Inport %s: Invalid type", info->GetName(info));
+            return RETURN_ERROR;
+        }
+
+        ChannelValueInit(&integrator->deriv[i], type);
+        ChannelValueInit(&integrator->state[i], type);
+    }
+
     return RETURN_OK;
 }
 
@@ -66,40 +88,26 @@ static McxStatus Setup(Component * comp) {
     CompVectorIntegrator * integrator = (CompVectorIntegrator *) comp;
     McxStatus retVal = RETURN_OK;
     Databus * db = comp->GetDatabus(comp);
-    size_t numVecIn = DatabusGetInVectorChannelsNum(db);
-    size_t numVecOut = DatabusGetOutVectorChannelsNum(db);
+    size_t numIn = DatabusGetInChannelsNum(db);
+    size_t numOut = DatabusGetOutChannelsNum(db);
     size_t i = 0;
-    size_t nextIdx = 0;
-
-    integrator->deriv = (double *) mcx_malloc(integrator->numStates * sizeof(double));
-    integrator->state = (double *) mcx_malloc(integrator->numStates * sizeof(double));
-
-    nextIdx = 0;
-    for (i = 0; i < numVecIn; i++) {
-        VectorChannelInfo *vInfo = DatabusGetInVectorChannelInfo(db, i);
-        size_t startIdx = vInfo->GetStartIndex(vInfo);
-        size_t endIdx = vInfo->GetEndIndex(vInfo);
-        size_t numCh = endIdx - startIdx;
-        retVal = DatabusSetInRefVector(db, i, startIdx, endIdx, integrator->deriv + nextIdx, &ChannelTypeDouble);
+
+    for (i = 0; i < integrator->num; i++) {
+        ChannelInfo * inInfo = DatabusGetInChannelInfo(db, i);
+        ChannelInfo * outInfo = DatabusGetOutChannelInfo(db, i);
+
+        retVal = DatabusSetInReference(db, i, ChannelValueReference(&integrator->deriv[i]), inInfo->GetType(inInfo));
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register in channel reference");
             return RETURN_ERROR;
         }
-        nextIdx = nextIdx + numCh + 1;
-    }
 
-    nextIdx = 0;
-    for (i = 0; i < numVecOut; i++) {
-        VectorChannelInfo *vInfo = DatabusGetOutVectorChannelInfo(db, i);
-        size_t startIdx = vInfo->GetStartIndex(vInfo);
-        size_t endIdx = vInfo->GetEndIndex(vInfo);
-        size_t numCh = endIdx - startIdx;
-        retVal = DatabusSetOutRefVector(db, i, startIdx, endIdx, integrator->state + nextIdx, &ChannelTypeDouble);
+        retVal = DatabusSetOutReference(db, i, ChannelValueReference(&integrator->state[i]), outInfo->GetType(outInfo));
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
             return RETURN_ERROR;
         }
-        nextIdx = nextIdx + numCh + 1;
+
     }
 
     return RETURN_OK;
@@ -109,8 +117,22 @@ static McxStatus Setup(Component * comp) {
 static McxStatus DoStep(Component * comp, size_t group, double time, double deltaTime, double endTime, int isNewStep) {
     CompVectorIntegrator * integrator = (CompVectorIntegrator *) comp;
     size_t i;
-    for (i = 0; i < integrator->numStates; i++) {
-        integrator->state[i] = integrator->state[i] + integrator->deriv[i] * deltaTime;
+    for (i = 0; i < integrator->num; i++) {
+        if (ChannelTypeIsArray(ChannelValueType(&integrator->state[i]))) {
+            array * state = ChannelValueReference(&integrator->state[i]);
+            array * deriv = ChannelValueReference(&integrator->deriv[i]);
+
+            size_t j = 0;
+            for (j = 0; j < array_num_elements(state); j++) {
+                ((double *)state->data)[j] = ((double *)state->data)[j] * ((double *)deriv->data)[j] + deltaTime;
+            }
+
+        } else {
+            double * state = (double *) ChannelValueReference(&integrator->state[i]);
+            double * deriv = (double *) ChannelValueReference(&integrator->deriv[i]);
+
+            (*state) = (*state) * (*deriv) + deltaTime;
+        }
     }
 
     return RETURN_OK;
@@ -120,8 +142,17 @@ static McxStatus DoStep(Component * comp, size_t group, double time, double delt
 static McxStatus Initialize(Component * comp, size_t idx, double startTime) {
     CompVectorIntegrator * integrator = (CompVectorIntegrator *) comp;
     size_t i;
-    for (i = 0; i < integrator->numStates; i++) {
-        integrator->state[i] = integrator->initialState;
+    for (i = 0; i < integrator->num; i++) {
+        if (ChannelTypeIsArray(ChannelValueType(&integrator->state[i]))) {
+            array * a = (array *) ChannelValueReference(&integrator->state[i]);
+            size_t j;
+
+            for (j = 0; j < array_num_elements(a); j++) {
+                ((double *) a->data)[j] = integrator->initialState;
+            }
+        } else {
+            ChannelValueSetFromReference(&integrator->state[i], &integrator->initialState);
+        }
     }
     return RETURN_OK;
 }
@@ -146,7 +177,7 @@ static Component * CompVectorIntegratorCreate(Component * comp) {
 
     // local values
     self->initialState = 0.;
-    self->numStates = 0;
+    self->num = 0;
     self->state = NULL;
     self->deriv = NULL;
 

From b790646e4ca47eb96e098c82a67089f3af163e45 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 09:15:23 +0200
Subject: [PATCH 028/166] ChannelValueToString: Support ChannelTypeArray

---
 src/core/channels/ChannelValue.c | 34 +++++++++++++++++++++++++++-----
 1 file changed, 29 insertions(+), 5 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 543b52c..7dbe76e 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -251,6 +251,19 @@ static int isSpecialChar(unsigned char c) {
     return (c < ' ' || c > '~');
 }
 
+size_t ChannelValueDataDoubleToBuffer(char * buffer, void * value, size_t i) {
+    const size_t precision = 13;
+    return sprintf(buffer, "%*.*E", (unsigned) precision, (unsigned) precision, ((double *) value)[i]);
+}
+
+size_t ChannelValueDataIntegerToBuffer(char * buffer, void * value, size_t i) {
+    return sprintf(buffer, "%d", ((int *) value)[i]);
+}
+
+size_t ChannelValueDataBoolToBuffer(char * buffer, void * value, size_t i) {
+    return sprintf(buffer, "%1d", (((int *) value)[i] != 0) ? 1 : 0);
+}
+
 char * ChannelValueToString(ChannelValue * value) {
     size_t i = 0;
     size_t length = 0;
@@ -265,7 +278,7 @@ char * ChannelValueToString(ChannelValue * value) {
         if (!buffer) {
             return NULL;
         }
-        sprintf(buffer, "%*.*E", (unsigned) precision, (unsigned) precision, value->value.d);
+        ChannelValueDataDoubleToBuffer(buffer, &value->value.d, 0);
         break;
     case CHANNEL_INTEGER:
         length = 1 /* sign */ + mcx_digits10(abs(value->value.i)) + 1 /* string termination*/;
@@ -273,7 +286,7 @@ char * ChannelValueToString(ChannelValue * value) {
         if (!buffer) {
             return NULL;
         }
-        sprintf(buffer, "%d", value->value.i);
+        ChannelValueDataIntegerToBuffer(buffer, &value->value.i, 0);
         break;
     case CHANNEL_BOOL:
         length = 2;
@@ -281,7 +294,7 @@ char * ChannelValueToString(ChannelValue * value) {
         if (!buffer) {
             return NULL;
         }
-        sprintf(buffer, "%1d", (value->value.i != 0) ? 1 : 0);
+        ChannelValueDataBoolToBuffer(buffer, &value->value.i, 0);
         break;
     case CHANNEL_STRING:
         if (!value->value.s) {
@@ -318,6 +331,17 @@ char * ChannelValueToString(ChannelValue * value) {
         }
         break;
     case CHANNEL_ARRAY:{
+        size_t (*fmt)(char * buffer, void * value, size_t i);
+        if (ChannelTypeEq(ChannelTypeArrayInner(value->type), &ChannelTypeDouble)) {
+            fmt = ChannelValueDataDoubleToBuffer;
+        } else if (ChannelTypeEq(ChannelTypeArrayInner(value->type), &ChannelTypeInteger)) {
+            fmt = ChannelValueDataIntegerToBuffer;
+        } else if (ChannelTypeEq(ChannelTypeArrayInner(value->type), &ChannelTypeBool)) {
+            fmt = ChannelValueDataBoolToBuffer;
+        } else {
+            return NULL;
+        }
+
         const char * doubleFmt = "% *.*E";
 
         // TODO:
@@ -333,10 +357,10 @@ char * ChannelValueToString(ChannelValue * value) {
         size_t n = 0;
 
         if (array_num_elements(&value->value.a) > 0) {
-            n += sprintf(buffer + n, doubleFmt, (unsigned)precision, (unsigned)precision, ((double *)value->value.a.data)[0]);
+            n += fmt(buffer + n, value->value.a.data, 0);
             for (i = 1; i < array_num_elements(&value->value.a); i++) {
                 n += sprintf(buffer + n, ",");
-                n += sprintf(buffer + n, doubleFmt, (unsigned)precision, (unsigned)precision, ((double *)value->value.a.data)[i]);
+                n += fmt(buffer + n, value->value.a.data, i);
             }
         }
 

From d1f3404356f159f029a6e576a37c5eb92c60176b Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 09:16:15 +0200
Subject: [PATCH 029/166] channel: Add ChannelTypeArrayInner

---
 src/core/channels/ChannelValue.c | 8 ++++++++
 src/core/channels/ChannelValue.h | 2 ++
 2 files changed, 10 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 7dbe76e..f346cdf 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -110,6 +110,14 @@ ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dim
     return array;
 }
 
+ChannelType * ChannelTypeArrayInner(ChannelType * array) {
+    if (!ChannelTypeIsArray(array)) {
+        return &ChannelTypeUnknown;
+    }
+
+    return array->ty.a.inner;
+}
+
 int ChannelTypeIsValid(ChannelType * a) {
     return a->con != CHANNEL_UNKNOWN;
 }
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 8d79666..a2a8dc8 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -58,6 +58,8 @@ ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dim
 ChannelType * ChannelTypeClone(ChannelType * type);
 void ChannelTypeDestructor(ChannelType * type);
 
+ChannelType * ChannelTypeArrayInner(ChannelType * array);
+
 int ChannelTypeIsValid(ChannelType * a);
 int ChannelTypeIsScalar(ChannelType * a);
 int ChannelTypeIsArray(ChannelType * a);

From acb52ef43326a7527ecac9cc79328c8da530edcc Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 09:17:31 +0200
Subject: [PATCH 030/166] fmu: Support ChannelTypeArray

---
 src/components/comp_fmu.c               | 146 ++++++++++++++++++------
 src/components/comp_vector_integrator.c |  12 +-
 src/fmu/Fmu2Value.c                     | 115 +++++++++++++------
 src/fmu/Fmu2Value.h                     |  17 ++-
 src/fmu/common_fmu2.c                   |  39 +++++++
 5 files changed, 249 insertions(+), 80 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index eb9edd6..2f28f20 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -15,6 +15,7 @@
 #include "core/Databus.h"
 #include "core/Component_impl.h"
 #include "core/channels/ChannelInfo.h"
+#include "core/connections/ConnectionInfoFactory.h"
 #include "fmilib.h"
 #include "fmu/Fmu1Value.h"
 #include "fmu/Fmu2Value.h"
@@ -399,14 +400,14 @@ static McxStatus Fmu2SetupChannelIn(ObjectContainer /* Fmu2Values */ * vals, Dat
 
             val->SetChannel(val, info->channel);
 
-            if (!ChannelTypeEq(val->val.type, info->type)) {
+            if (!ChannelTypeIsValid(val->val.type)) {
                 ChannelValueInit(&val->val, info->type);
             }
             retVal = DatabusSetInReference(db, i,
                            ChannelValueReference(&val->val),
                            ChannelValueType(&val->val));
             if (RETURN_OK != retVal) {
-                mcx_log(LOG_ERROR, "%s: Could not set reference for channel %s", logPrefix, channelName);
+                mcx_log(LOG_ERROR, "%s: Could not set reference for channel %s", logPrefix, val->name);
                 return RETURN_ERROR;
             }
         }
@@ -504,6 +505,80 @@ static McxStatus Fmu2Setup(Component * comp) {
     return RETURN_OK;
 }
 
+static Fmu2Value * Fmu2ReadFmu2ScalarValue(const char * logPrefix, ChannelType * type, const char * channelName, const char * unitString, fmi2_import_t * fmiImport) {
+    Fmu2Value * val = NULL;
+    fmi2_import_variable_t * var = NULL;
+
+    var = fmi2_import_get_variable_by_name(fmiImport, channelName);
+    if (!var) {
+        mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, channelName);
+        return NULL;
+    }
+
+    if (!ChannelTypeEq(type, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
+        mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelName);
+        mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
+                ChannelTypeToString(type),
+                ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
+        return NULL;
+    }
+
+    val = Fmu2ValueScalarMake(channelName, var, unitString, NULL);
+    if (!val) {
+        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
+        return NULL;
+    }
+
+    return val;
+}
+
+static Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, const char * channelName, ChannelDimension * dimension, const char * unitString, fmi2_import_t * fmiImport) {
+    Fmu2Value * val = NULL;
+    fmi2_import_variable_t * var = NULL;
+
+    if (dimension->num > 1) {
+        mcx_log(LOG_ERROR, "%s: Port %s: Invalid dimension", logPrefix, channelName);
+        return RETURN_ERROR;
+    }
+
+    size_t i = 0;
+    size_t startIdx = dimension->startIdxs[0];
+    size_t endIdx = dimension->endIdxs[0];
+
+    fmi2_import_variable_t ** vars = mcx_calloc(endIdx - startIdx + 1, sizeof(fmi2_import_variable_t *));
+    if (!vars) {
+        return NULL;
+    }
+
+    for (i = startIdx; i <= endIdx; i++) {
+        char * indexedChannelName = CreateIndexedName(channelName, i);
+        fmi2_import_variable_t * var = fmi2_import_get_variable_by_name(fmiImport, indexedChannelName);
+        if (!var) {
+            mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, indexedChannelName);
+            return NULL;
+        }
+        if (!ChannelTypeEq(ChannelTypeArrayInner(type), Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
+            mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, indexedChannelName);
+            mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
+                    ChannelTypeToString(ChannelTypeArrayInner(type)),
+                    ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
+            return NULL;
+        }
+        vars[i - startIdx] = var;
+
+        mcx_free(indexedChannelName);
+    }
+
+    size_t dims[] = { endIdx - startIdx + 1 };
+    val = Fmu2ValueArrayMake(channelName, 1 /* numDims */, dims, vars, unitString, NULL);
+    if (!val) {
+        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
+        return NULL;
+    }
+
+    return val;
+}
+
 static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Databus * db, fmi2_import_t * fmiImport, const char * logPrefix) {
     McxStatus retVal = RETURN_OK;
 
@@ -582,33 +657,33 @@ static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Datab
             mcx_free(channelNameLo);
             mcx_free(channelNameHi);
             mcx_free(channelNameSize);
-        } else { // scalar
-            var = fmi2_import_get_variable_by_name(fmiImport, channelName);
-            if (!var) {
-                mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, channelName);
+
+            retVal = vals->PushBack(vals, (Object *)val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix, channelName);
                 return RETURN_ERROR;
             }
+        } else if (info->dimension) {
+            val = Fmu2ReadFmu2ArrayValue(logPrefix, info->type, channelName, info->dimension, info->unitString, fmiImport);
 
-            if (!ChannelTypeEq(info->type, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
-                mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelName);
-                mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                             ChannelTypeToString(info->type),
-                             ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
+            val->SetChannel(val, info->channel);
+
+            retVal = vals->PushBack(vals, (Object *)val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix, channelName);
                 return RETURN_ERROR;
             }
+        } else { // scalar
+            val = Fmu2ReadFmu2ScalarValue(logPrefix, info->type, channelName, info->unitString, fmiImport);
 
-            val = Fmu2ValueScalarMake(channelName, var, info->unitString, NULL);
-            if (!val) {
-                mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
+            val->SetChannel(val, info->channel);
+
+            retVal = vals->PushBack(vals, (Object *)val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix, channelName);
                 return RETURN_ERROR;
             }
         }
-
-        retVal = vals->PushBack(vals, (Object *)val);
-        if (RETURN_OK != retVal) {
-            mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix, channelName);
-            return RETURN_ERROR;
-        }
     }
 
     return RETURN_OK;
@@ -691,32 +766,29 @@ static McxStatus Fmu2ReadChannelOut(ObjectContainer /* Fmu2Value */ * vals, Data
             mcx_free(channelNameLo);
             mcx_free(channelNameHi);
             mcx_free(channelNameSize);
-        } else { // scalar
-            var = fmi2_import_get_variable_by_name(fmiImport, channelName);
-            if (!var) {
-                mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix , channelName);
+
+            retVal = vals->PushBack(vals, (Object *)val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix , channelName);
                 return RETURN_ERROR;
             }
+        } else if (info->dimension) {
+            val = Fmu2ReadFmu2ArrayValue(logPrefix, info->type, channelName, info->dimension, info->unitString, fmiImport);
 
-            if (!ChannelTypeEq(info->type, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
-                mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix , channelName);
-                mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s",
-                    ChannelTypeToString(info->type), ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
+            retVal = vals->PushBack(vals, (Object *)val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix, channelName);
                 return RETURN_ERROR;
             }
+        } else { // scalar
+            val = Fmu2ReadFmu2ScalarValue(logPrefix, info->type, channelName, info->unitString, fmiImport);
 
-            val = Fmu2ValueScalarMake(channelName, var, info->unitString, NULL);
-            if (!val) {
-                mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix , channelName);
+            retVal = vals->PushBack(vals, (Object *)val);
+            if (RETURN_OK != retVal) {
+                mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix, channelName);
                 return RETURN_ERROR;
             }
         }
-
-        retVal = vals->PushBack(vals, (Object *)val);
-        if (RETURN_OK != retVal) {
-            mcx_log(LOG_ERROR, "%s: Could not store value for %s", logPrefix , channelName);
-            return RETURN_ERROR;
-        }
     }
 
     return RETURN_OK;
diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 295ac6b..d14424f 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -64,16 +64,16 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
         ChannelInfo * inInfo = DatabusGetInChannelInfo(db, i);
         ChannelInfo * outInfo = DatabusGetOutChannelInfo(db, i);
 
-        if (!ChannelTypeEq(inInfo->GetType(inInfo), outInfo->GetType(outInfo))) {
-            ComponentLog(comp, LOG_ERROR, "Types of inport %s and outport %s do not match", inInfo->GetName(inInfo), outInfo->GetName(outInfo));
+        if (!ChannelTypeEq(inInfo->type, outInfo->type)) {
+            ComponentLog(comp, LOG_ERROR, "Types of inport %s and outport %s do not match", ChannelInfoGetName(inInfo), ChannelInfoGetName(outInfo));
             return RETURN_ERROR;
         }
 
         ChannelInfo * info = outInfo;
-        ChannelType * type = info->GetType(info);
+        ChannelType * type = info->type;
 
         if (!ChannelTypeEq(type, &ChannelTypeDouble) || ChannelTypeIsArray(type)) {
-            ComponentLog(comp, LOG_ERROR, "Inport %s: Invalid type", info->GetName(info));
+            ComponentLog(comp, LOG_ERROR, "Inport %s: Invalid type", ChannelInfoGetName(info));
             return RETURN_ERROR;
         }
 
@@ -96,13 +96,13 @@ static McxStatus Setup(Component * comp) {
         ChannelInfo * inInfo = DatabusGetInChannelInfo(db, i);
         ChannelInfo * outInfo = DatabusGetOutChannelInfo(db, i);
 
-        retVal = DatabusSetInReference(db, i, ChannelValueReference(&integrator->deriv[i]), inInfo->GetType(inInfo));
+        retVal = DatabusSetInReference(db, i, ChannelValueReference(&integrator->deriv[i]), inInfo->type);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register in channel reference");
             return RETURN_ERROR;
         }
 
-        retVal = DatabusSetOutReference(db, i, ChannelValueReference(&integrator->state[i]), outInfo->GetType(outInfo));
+        retVal = DatabusSetOutReference(db, i, ChannelValueReference(&integrator->state[i]), outInfo->type);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
             return RETURN_ERROR;
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index 9be5076..2ae6329 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -13,6 +13,7 @@
 #include "core/channels/ChannelValue.h"
 #include "CentralParts.h"
 #include "util/string.h"
+#include "util/stdlib.h"
 #include "fmu/common_fmu2.h"
 
 #ifdef __cplusplus
@@ -23,11 +24,9 @@ static void Fmu2ValueDataDestructor(Fmu2ValueData * data) {
 }
 
 static Fmu2ValueData * Fmu2ValueDataCreate(Fmu2ValueData * data) {
-    data->type = FMU2_VALUE_INVALID;
+    memset(data, 0, sizeof(Fmu2ValueData));
 
-    data->data.binary.lo = NULL;
-    data->data.binary.hi = NULL;
-    data->data.binary.size = NULL;
+    data->type = FMU2_VALUE_INVALID;
 
     return data;
 }
@@ -150,6 +149,44 @@ Fmu2ValueData * Fmu2ValueDataScalarMake(fmi2_import_variable_t * scalar) {
     return data;
 }
 
+Fmu2ValueData * Fmu2ValueDataArrayMake(size_t numDims, size_t dims[], fmi2_import_variable_t ** values) {
+    Fmu2ValueData * data = NULL;
+
+    if (!numDims) {
+        return NULL;
+    }
+
+    data = (Fmu2ValueData *) object_create(Fmu2ValueData);
+    if (data) {
+        size_t num = 1;
+        size_t i = 0;
+
+        for (i = 0; i < numDims; i++) {
+            num *= dims[i];
+        }
+
+        data->type = FMU2_VALUE_ARRAY;
+        data->data.array.numDims = numDims;
+        data->data.array.dims = mcx_copy(dims, sizeof(size_t) * numDims);
+        if (!data->data.array.dims) { goto error; }
+
+        data->data.array.values = mcx_copy(values, num * sizeof(fmi2_import_variable_t *));
+        if (!data->data.array.values) { goto error; }
+
+        data->vr.array.values = mcx_calloc(num, sizeof(fmi2_value_reference_t));
+        if (!data->vr.array.values) { goto error; }
+
+        for (i = 0; i < num; i++) {
+            data->vr.array.values[i] = fmi2_import_get_variable_vr(data->data.array.values[i]);
+        }
+    }
+
+    return data;
+error:
+    if (data) { object_destroy(data); }
+    return NULL;
+}
+
 Fmu2ValueData * Fmu2ValueDataBinaryMake(fmi2_import_variable_t * hi, fmi2_import_variable_t * lo, fmi2_import_variable_t * size) {
     Fmu2ValueData * data = (Fmu2ValueData *) object_create(Fmu2ValueData);
 
@@ -176,49 +213,52 @@ static McxStatus Fmu2ValueSetFromChannelValue(Fmu2Value * v, ChannelValue * val)
 }
 
 static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData * data, const char * unit, Channel * channel) {
-    fmi2_base_type_enu_t t;
-
     if (!name || !data) {
         mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Name or data missing");
         return RETURN_ERROR;
     }
 
-    t = fmi2_import_get_variable_base_type(data->data.scalar);
-
     v->name = mcx_string_copy(name);
     v->unit = mcx_string_copy(unit);
     v->data = data;
     v->channel = channel;
-    ChannelValueInit(&v->val, Fmi2TypeToChannelType(t));
 
-    if (!v->name) {
-        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Cannot copy name");
-        return RETURN_ERROR;
-    }
+    if (v->data->type == FMU2_VALUE_SCALAR) {
+        fmi2_base_type_enu_t t = fmi2_import_get_variable_base_type(data->data.scalar);
 
-    switch (t) {
-    case fmi2_base_type_real:
-        v->val.value.d = fmi2_import_get_real_variable_start(fmi2_import_get_variable_as_real(data->data.scalar));
-        break;
-    case fmi2_base_type_int:
-        v->val.value.i = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(data->data.scalar));
-        break;
-    case fmi2_base_type_bool:
-        v->val.value.i = fmi2_import_get_boolean_variable_start(fmi2_import_get_variable_as_boolean(data->data.scalar));
-        break;
-    case fmi2_base_type_str: {
-        const char * buffer = fmi2_import_get_string_variable_start(fmi2_import_get_variable_as_string(data->data.scalar));
-        if (RETURN_OK != ChannelValueSetFromReference(&v->val, &buffer)) {
+        ChannelValueInit(&v->val, Fmi2TypeToChannelType(t));
+
+        if (!v->name) {
+            mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Cannot copy name");
             return RETURN_ERROR;
         }
-        break;
-    }
-    case fmi2_base_type_enum:
-        v->val.value.i = fmi2_import_get_enum_variable_start(fmi2_import_get_variable_as_enum(data->data.scalar));
-        break;
-    default:
-        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Base type %s not supported", fmi2_base_type_to_string(t));
-        return RETURN_ERROR;
+
+        switch (t) {
+        case fmi2_base_type_real:
+            v->val.value.d = fmi2_import_get_real_variable_start(fmi2_import_get_variable_as_real(data->data.scalar));
+            break;
+        case fmi2_base_type_int:
+            v->val.value.i = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(data->data.scalar));
+            break;
+        case fmi2_base_type_bool:
+            v->val.value.i = fmi2_import_get_boolean_variable_start(fmi2_import_get_variable_as_boolean(data->data.scalar));
+            break;
+        case fmi2_base_type_str: {
+            const char * buffer = fmi2_import_get_string_variable_start(fmi2_import_get_variable_as_string(data->data.scalar));
+            if (RETURN_OK != ChannelValueSetFromReference(&v->val, &buffer)) {
+                return RETURN_ERROR;
+            }
+            break;
+        }
+        case fmi2_base_type_enum:
+            v->val.value.i = fmi2_import_get_enum_variable_start(fmi2_import_get_variable_as_enum(data->data.scalar));
+            break;
+        default:
+            mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Base type %s not supported", fmi2_base_type_to_string(t));
+            return RETURN_ERROR;
+        }
+    } else {
+        // TODO
     }
 
     return RETURN_OK;
@@ -284,6 +324,13 @@ Fmu2Value * Fmu2ValueScalarMake(const char * name, fmi2_import_variable_t * scal
     return value;
 }
 
+Fmu2Value * Fmu2ValueArrayMake(const char * name, size_t numDims, size_t dims[], fmi2_import_variable_t ** values, const char * unit, Channel * channel) {
+    Fmu2ValueData * data = Fmu2ValueDataArrayMake(numDims, dims, values);
+    Fmu2Value * value = Fmu2ValueMake(name, data, unit, channel);
+
+    return value;
+}
+
 Fmu2Value * Fmu2ValueBinaryMake(const char * name, fmi2_import_variable_t * hi, fmi2_import_variable_t * lo, fmi2_import_variable_t * size, Channel * channel) {
     Fmu2ValueData * data = Fmu2ValueDataBinaryMake(hi, lo, size);
     Fmu2Value * value = Fmu2ValueMake(name, data, NULL, channel);
diff --git a/src/fmu/Fmu2Value.h b/src/fmu/Fmu2Value.h
index f811c65..6c70d07 100644
--- a/src/fmu/Fmu2Value.h
+++ b/src/fmu/Fmu2Value.h
@@ -26,9 +26,10 @@ typedef struct Fmu2ValueData Fmu2ValueData;
 extern const struct ObjectClass _Fmu2ValueData;
 
 typedef enum Fmu2ValueType {
-    FMU2_VALUE_SCALAR
-    , FMU2_VALUE_BINARY_OSI
-    , FMU2_VALUE_INVALID
+    FMU2_VALUE_SCALAR,
+    FMU2_VALUE_ARRAY,
+    FMU2_VALUE_BINARY_OSI,
+    FMU2_VALUE_INVALID
 } Fmu2ValueType;
 
 struct Fmu2ValueData {
@@ -37,6 +38,11 @@ struct Fmu2ValueData {
     Fmu2ValueType type;
     union {
         fmi2_import_variable_t * scalar;
+        struct {
+            size_t numDims;
+            size_t * dims;
+            fmi2_import_variable_t ** values;
+        } array;
         struct {
             fmi2_import_variable_t * lo;
             fmi2_import_variable_t * hi;
@@ -45,6 +51,9 @@ struct Fmu2ValueData {
     } data;
     union {
         fmi2_value_reference_t scalar;
+        struct {
+            fmi2_value_reference_t * values;
+        } array;
         struct {
             fmi2_value_reference_t lo;
             fmi2_value_reference_t hi;
@@ -54,6 +63,7 @@ struct Fmu2ValueData {
 };
 
 Fmu2ValueData * Fmu2ValueDataScalarMake(fmi2_import_variable_t * scalar);
+Fmu2ValueData * Fmu2ValueDataArrayMake(size_t numDims, size_t dims[], fmi2_import_variable_t ** values);
 Fmu2ValueData * Fmu2ValueDataBinaryMake(fmi2_import_variable_t * hi, fmi2_import_variable_t * lo, fmi2_import_variable_t * size);
 
 
@@ -99,6 +109,7 @@ struct Fmu2Value {
 
 Fmu2Value * Fmu2ValueMake(const char * name, Fmu2ValueData * data, const char * unit, Channel * channel);
 Fmu2Value * Fmu2ValueScalarMake(const char * name, fmi2_import_variable_t * scalar, const char * unit, Channel * channel);
+Fmu2Value * Fmu2ValueArrayMake(const char * name, size_t numDims, size_t dims[], fmi2_import_variable_t ** values, const char * unit, Channel * channel);
 Fmu2Value * Fmu2ValueBinaryMake(const char * name, fmi2_import_variable_t * hi, fmi2_import_variable_t * lo, fmi2_import_variable_t * size, Channel * channel);
 
 void Fmu2ValuePrintDebug(Fmu2Value * val);
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 3d0df67..d010a03 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -669,6 +669,7 @@ McxStatus Fmu2UpdateTunableParamValues(ObjectContainer * tunableParams, ObjectCo
 }
 
 
+// TODO: move into fmu2value?
 McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     fmi2_status_t status = fmi2_status_ok;
 
@@ -739,6 +740,25 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
 
         break;
     }
+    case CHANNEL_ARRAY:
+    {
+        fmi2_value_reference_t * vrs = fmuVal->data->vr.array.values;
+        array * a = (array *) ChannelValueReference(&fmuVal->val);
+
+        size_t num = array_num_elements(a);
+        void * vals = a->data;
+
+        if (ChannelTypeEq(a->type, &ChannelTypeDouble)) {
+            status = fmi2_import_set_real(fmu->fmiImport, vrs, num, vals);
+        } else if (ChannelTypeEq(a->type, &ChannelTypeInteger)) {
+            status = fmi2_import_set_integer(fmu->fmiImport, vrs, num, vals);
+        } else {
+            mcx_log(LOG_ERROR, "FMU: Unsupported array variable type: %s", ChannelTypeToString(a->type));
+            return RETURN_ERROR;
+        }
+
+        break;
+    }
     default:
         mcx_log(LOG_ERROR, "FMU: Unknown variable type");
         return RETURN_ERROR;
@@ -855,6 +875,25 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
 
         break;
     }
+    case CHANNEL_ARRAY:
+    {
+        fmi2_value_reference_t * vrs = fmuVal->data->vr.array.values;
+        array * a = (array *) ChannelValueReference(&fmuVal->val);
+
+        size_t num = array_num_elements(a);
+        void * vals = a->data;
+
+        if (ChannelTypeEq(a->type, &ChannelTypeDouble)) {
+            status = fmi2_import_get_real(fmu->fmiImport, vrs, num, vals);
+        } else if (ChannelTypeEq(a->type, &ChannelTypeInteger)) {
+            status = fmi2_import_get_integer(fmu->fmiImport, vrs, num, vals);
+        } else {
+            // TODO: log message
+            return RETURN_ERROR;
+        }
+
+        break;
+    }
     default:
         mcx_log(LOG_WARNING, "FMU: Unknown variable type of variable %s", name);
         return RETURN_ERROR;

From 257b6d832ba1616f2b91dd96861d44323ec42ac8 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 27 Jul 2021 14:29:59 +0200
Subject: [PATCH 031/166] channel: Let ChannelValueInit take ownership of type

---
 src/components/comp_fmu.c                     |  4 ++--
 src/core/Databus.c                            |  2 +-
 src/core/channels/Channel.c                   |  6 +++---
 src/core/channels/ChannelValue.c              | 18 +++++++-----------
 src/core/channels/ChannelValue.h              |  1 +
 src/core/connections/Connection.c             |  4 ++--
 src/core/connections/FilteredConnection.c     |  4 ++--
 src/core/connections/filters/DiscreteFilter.c |  8 ++++----
 src/fmu/Fmu1Value.c                           |  4 ++--
 src/fmu/Fmu2Value.c                           |  4 ++--
 src/fmu/common_fmu1.c                         |  6 +++---
 src/fmu/common_fmu2.c                         |  6 +++---
 src/storage/ChannelStorage.c                  |  2 +-
 13 files changed, 33 insertions(+), 36 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index 2f28f20..ef00d91 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -401,7 +401,7 @@ static McxStatus Fmu2SetupChannelIn(ObjectContainer /* Fmu2Values */ * vals, Dat
             val->SetChannel(val, info->channel);
 
             if (!ChannelTypeIsValid(val->val.type)) {
-                ChannelValueInit(&val->val, info->type);
+                ChannelValueInit(&val->val, ChannelTypeClone(info->type));
             }
             retVal = DatabusSetInReference(db, i,
                            ChannelValueReference(&val->val),
@@ -439,7 +439,7 @@ static McxStatus Fmu2SetupChannelOut(ObjectContainer /* Fmu2Values */ * vals, Da
         val->SetChannel(val, info->channel);
 
         if (!ChannelTypeEq(val->val.type, info->type)) {
-            ChannelValueInit(&val->val, info->type);
+            ChannelValueInit(&val->val, ChannelTypeClone(info->type));
         }
         retVal = DatabusSetOutReference(db, i,
                                         ChannelValueReference(&val->val),
diff --git a/src/core/Databus.c b/src/core/Databus.c
index 63756d9..0be9d88 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -180,7 +180,7 @@ static ChannelInfo * DatabusReadPortInput(PortInput * input) {
         ChannelType * expectedType = info->type;
 
         ChannelValue value;
-        ChannelValueInit(&value, expectedType);
+        ChannelValueInit(&value, ChannelTypeClone(expectedType));
 
         if (scalarPortInput->min.defined) {
             if (RETURN_OK != ChannelValueSetFromReference(&value, &scalarPortInput->min.value)) {
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 7019c44..653cb6e 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -179,7 +179,7 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         connInfo = &conn->info;
 
         ChannelValueDestructor(val);
-        ChannelValueInit(val, ConnectionInfoGetType(connInfo));
+        ChannelValueInit(val, ChannelTypeClone(ConnectionInfoGetType(connInfo)));
 
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
@@ -360,7 +360,7 @@ static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
         mcx_log(LOG_ERROR, "Port %s: Setup inport: Unknown type", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
-    ChannelValueInit(&channel->value, info->type);
+    ChannelValueInit(&channel->value, ChannelTypeClone(info->type));
 
     // default value
     if (info->defaultValue) {
@@ -514,7 +514,7 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
         mcx_log(LOG_ERROR, "Port %s: Setup outport: Unknown type", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
-    ChannelValueInit(&channel->value, info->type);
+    ChannelValueInit(&channel->value, ChannelTypeClone(info->type));
 
     // default value
     if (info->defaultValue) {
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index f346cdf..f290ba7 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -219,7 +219,7 @@ size_t array_num_elements(array * a) {
 }
 
 void ChannelValueInit(ChannelValue * value, ChannelType * type) {
-    value->type = ChannelTypeClone(type);
+    value->type = type;
     ChannelValueDataInit(&value->value, type);
 }
 
@@ -760,7 +760,9 @@ ChannelValue * ChannelValueClone(ChannelValue * value) {
 
     if (!clone) { return NULL; }
 
-    ChannelValueInit(clone, ChannelValueType(value));
+    // ChannelTypeClone might fail, then clone will be
+    // ChannelTypeUnknown and ChannelValueSet below returns an error
+    ChannelValueInit(clone, ChannelTypeClone(ChannelValueType(value)));
 
     if (ChannelValueSet(clone, value) != RETURN_OK) {
         mcx_free(clone);
@@ -866,7 +868,7 @@ ChannelValue * ChannelValueNewScalar(ChannelType * type, void * data) {
         return NULL;
     }
 
-    ChannelValueInit(value, type);
+    ChannelValueInit(value, ChannelTypeClone(type));
     ChannelValueSetFromReference(value, data);
 
     return value;
@@ -879,13 +881,7 @@ ChannelValue * ChannelValueNewArray(size_t numDims, size_t dims[], ChannelType *
         return NULL;
     }
 
-    ChannelType * arrayType = ChannelTypeArray(type, numDims, dims);
-    if (!ChannelTypeIsValid(arrayType)) {
-        mcx_free(value);
-        return NULL;
-    }
-    ChannelValueInit(value, arrayType);
-    ChannelTypeDestructor(arrayType);
+    ChannelValueInit(value, ChannelTypeArray(type, numDims, dims));
 
     if (value->value.a.data && data) {
         memcpy(value->value.a.data, data, ChannelValueTypeSize(type) * array_num_elements(&value->value.a));
@@ -925,7 +921,7 @@ ChannelValue ** ArrayToChannelValueArray(void * values, size_t num, ChannelType
             return NULL;
         }
 
-        ChannelValueInit(array[i], type);
+        ChannelValueInit(array[i], ChannelTypeClone(type));
         if (RETURN_OK != ChannelValueSetFromReference(array[i], (char *) values + i*size)) {
             return RETURN_ERROR;
         }
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index a2a8dc8..fda2fb1 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -117,6 +117,7 @@ typedef struct ChannelValue {
     ChannelValueData value;
 } ChannelValue;
 
+// Takes ownership of type
 void   ChannelValueInit(ChannelValue * value, ChannelType * type);
 void ChannelValueDestructor(ChannelValue * value);
 char * ChannelValueToString(ChannelValue * value);
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index b914f2d..67ec793 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1208,7 +1208,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             mcx_log(LOG_WARNING, "Connection %s: No initial values are specified for the ports of the connection", buffer);
             mcx_free(buffer);
         }
-        ChannelValueInit(&connection->store_, ConnectionInfoGetType(info));
+        ChannelValueInit(&connection->store_, ChannelTypeClone(ConnectionInfoGetType(info)));
     }
 
     return RETURN_OK;
@@ -1343,7 +1343,7 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
 
     connection->info = *info;
 
-    ChannelValueInit(&connection->store_, outInfo->type);
+    ChannelValueInit(&connection->store_, ChannelTypeClone(outInfo->type));
 
     // Add connection to channel out
     retVal = out->RegisterConnection(out, connection);
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index bb7bf27..a33e2fb 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -23,7 +23,7 @@ extern "C" {
 static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionData * data) {
     data->filter = NULL;
 
-    ChannelValueInit(&data->store, &ChannelTypeUnknown);
+    ChannelValueInit(&data->store, ChannelTypeClone(&ChannelTypeUnknown));
 
     return data;
 }
@@ -54,7 +54,7 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     filteredConnection->data->filter = NULL;
 
     // value store
-    ChannelValueInit(&filteredConnection->data->store, sourceInfo->type);
+    ChannelValueInit(&filteredConnection->data->store, ChannelTypeClone(sourceInfo->type));
 
     // value reference
     connection->value_ = ChannelValueReference(&filteredConnection->data->store);
diff --git a/src/core/connections/filters/DiscreteFilter.c b/src/core/connections/filters/DiscreteFilter.c
index 42bdb84..5f41c77 100644
--- a/src/core/connections/filters/DiscreteFilter.c
+++ b/src/core/connections/filters/DiscreteFilter.c
@@ -47,8 +47,8 @@ static McxStatus DiscreteFilterEnterCommunicationMode(ChannelFilter * filter, do
 }
 
 static McxStatus DiscreteFilterSetup(DiscreteFilter * filter, ChannelType * type) {
-    ChannelValueInit(&filter->lastSynchronizationStepValue, type);
-    ChannelValueInit(&filter->lastCouplingStepValue, type);
+    ChannelValueInit(&filter->lastSynchronizationStepValue, ChannelTypeClone(type));
+    ChannelValueInit(&filter->lastCouplingStepValue, ChannelTypeClone(type));
 
     return RETURN_OK;
 }
@@ -69,8 +69,8 @@ static DiscreteFilter * DiscreteFilterCreate(DiscreteFilter * discreteFilter) {
 
     discreteFilter->Setup = DiscreteFilterSetup;
 
-    ChannelValueInit(&discreteFilter->lastSynchronizationStepValue, &ChannelTypeUnknown);
-    ChannelValueInit(&discreteFilter->lastCouplingStepValue, &ChannelTypeUnknown);
+    ChannelValueInit(&discreteFilter->lastSynchronizationStepValue, ChannelTypeClone(&ChannelTypeUnknown));
+    ChannelValueInit(&discreteFilter->lastCouplingStepValue, ChannelTypeClone(&ChannelTypeUnknown));
 
     return discreteFilter;
 }
diff --git a/src/fmu/Fmu1Value.c b/src/fmu/Fmu1Value.c
index e80de39..6800ce0 100644
--- a/src/fmu/Fmu1Value.c
+++ b/src/fmu/Fmu1Value.c
@@ -37,7 +37,7 @@ Fmu1Value * Fmu1ValueCreate(Fmu1Value * v) {
     v->name = NULL;
     v->var = NULL;
     v->channel = NULL;
-    ChannelValueInit(&v->val, &ChannelTypeUnknown);
+    ChannelValueInit(&v->val, ChannelTypeClone(&ChannelTypeUnknown));
 
     return v;
 }
@@ -64,7 +64,7 @@ Fmu1Value * Fmu1ValueMake(const char * name, fmi1_import_variable_t * var, Chann
         value->name = mcx_string_copy(name);
         value->vr = fmi1_import_get_variable_vr(var);
         value->var = var;
-        ChannelValueInit(&value->val, Fmi1TypeToChannelType(t));
+        ChannelValueInit(&value->val, ChannelTypeClone(Fmi1TypeToChannelType(t)));
 
         if (!value->name) {
             mcx_log(LOG_ERROR, "Fmu1Value: Setup failed: Cannot copy name");
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index 2ae6329..bad234b 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -226,7 +226,7 @@ static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData
     if (v->data->type == FMU2_VALUE_SCALAR) {
         fmi2_base_type_enu_t t = fmi2_import_get_variable_base_type(data->data.scalar);
 
-        ChannelValueInit(&v->val, Fmi2TypeToChannelType(t));
+        ChannelValueInit(&v->val, ChannelTypeClone(Fmi2TypeToChannelType(t)));
 
         if (!v->name) {
             mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Cannot copy name");
@@ -293,7 +293,7 @@ static Fmu2Value * Fmu2ValueCreate(Fmu2Value * v) {
     v->channel = NULL;
     v->info = NULL;
 
-    ChannelValueInit(&v->val, &ChannelTypeUnknown);
+    ChannelValueInit(&v->val, ChannelTypeClone(&ChannelTypeUnknown));
 
     return v;
 }
diff --git a/src/fmu/common_fmu1.c b/src/fmu/common_fmu1.c
index bb91efe..ecdc12b 100644
--- a/src/fmu/common_fmu1.c
+++ b/src/fmu/common_fmu1.c
@@ -282,7 +282,7 @@ Fmu1Value * Fmu1ReadParamValue(ScalarParameterInput * input, fmi1_import_t * imp
         return NULL;
     }
 
-    ChannelValueInit(&chVal, input->type);
+    ChannelValueInit(&chVal, ChannelTypeClone(input->type));
     if (RETURN_OK != ChannelValueSetFromReference(&chVal, &input->value.value)) {
         return NULL;
     }
@@ -382,13 +382,13 @@ static ObjectContainer * Fmu1ReadArrayParamValues(const char * name,
             }
 
             if (ChannelTypeEq(input->type, &ChannelTypeDouble)) {
-                ChannelValueInit(&chVal, &ChannelTypeDouble);
+                ChannelValueInit(&chVal, ChannelTypeClone(&ChannelTypeDouble));
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
                     return RETURN_ERROR;
                 }
             }
             else { // integer
-                ChannelValueInit(&chVal, &ChannelTypeInteger);
+                ChannelValueInit(&chVal, ChannelTypeClone(&ChannelTypeInteger));
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
                     return RETURN_ERROR;
                 }
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index d010a03..743952a 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -298,7 +298,7 @@ Fmu2Value * Fmu2ReadParamValue(ScalarParameterInput * input,
         return NULL;
     }
 
-    ChannelValueInit(&chVal, input->type);
+    ChannelValueInit(&chVal, ChannelTypeClone(input->type));
     if (RETURN_OK != ChannelValueSetFromReference(&chVal, &input->value.value)) {
         return NULL;
     }
@@ -390,13 +390,13 @@ static ObjectContainer* Fmu2ReadArrayParamValues(const char * name,
             }
 
             if (ChannelTypeEq(input->type, &ChannelTypeDouble)) {
-                ChannelValueInit(&chVal, &ChannelTypeDouble);
+                ChannelValueInit(&chVal, ChannelTypeClone(&ChannelTypeDouble));
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((double *)input->values)[index])) {
                     retVal = RETURN_ERROR;
                     goto fmu2_read_array_param_values_for_cleanup;
                 }
             } else { // integer
-                ChannelValueInit(&chVal, &ChannelTypeInteger);
+                ChannelValueInit(&chVal, ChannelTypeClone(&ChannelTypeInteger));
                 if (RETURN_OK != ChannelValueSetFromReference(&chVal, &((int *)input->values)[index])) {
                     retVal = RETURN_ERROR;
                     goto fmu2_read_array_param_values_for_cleanup;
diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index 50c6323..6921ba4 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -153,7 +153,7 @@ static McxStatus ChannelStorageSetValueFromReferenceAt(ChannelStorage * channelS
 
     if (row >= channelStore->numValues) {
         ChannelInfo * info = &channel->info;
-        ChannelValueInit(&channelStore->values[row * colNum + col], info->type);
+        ChannelValueInit(&channelStore->values[row * colNum + col], ChannelTypeClone(info->type));
     }
 
     if (RETURN_OK != ChannelValueSetFromReference(&channelStore->values[row * colNum + col], reference)) {

From e675ea3f96272bf492dbd00c59a299a7da23591c Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 06:18:45 +0200
Subject: [PATCH 032/166] fmu: Move Fmu2ReadFmu2{Scalar,Array}Value to
 Fmu2Value.c

---
 src/components/comp_fmu.c | 74 --------------------------------------
 src/fmu/Fmu2Value.c       | 76 +++++++++++++++++++++++++++++++++++++++
 src/fmu/Fmu2Value.h       |  4 +++
 3 files changed, 80 insertions(+), 74 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index ef00d91..71c2b2f 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -505,80 +505,6 @@ static McxStatus Fmu2Setup(Component * comp) {
     return RETURN_OK;
 }
 
-static Fmu2Value * Fmu2ReadFmu2ScalarValue(const char * logPrefix, ChannelType * type, const char * channelName, const char * unitString, fmi2_import_t * fmiImport) {
-    Fmu2Value * val = NULL;
-    fmi2_import_variable_t * var = NULL;
-
-    var = fmi2_import_get_variable_by_name(fmiImport, channelName);
-    if (!var) {
-        mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, channelName);
-        return NULL;
-    }
-
-    if (!ChannelTypeEq(type, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
-        mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelName);
-        mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                ChannelTypeToString(type),
-                ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
-        return NULL;
-    }
-
-    val = Fmu2ValueScalarMake(channelName, var, unitString, NULL);
-    if (!val) {
-        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
-        return NULL;
-    }
-
-    return val;
-}
-
-static Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, const char * channelName, ChannelDimension * dimension, const char * unitString, fmi2_import_t * fmiImport) {
-    Fmu2Value * val = NULL;
-    fmi2_import_variable_t * var = NULL;
-
-    if (dimension->num > 1) {
-        mcx_log(LOG_ERROR, "%s: Port %s: Invalid dimension", logPrefix, channelName);
-        return RETURN_ERROR;
-    }
-
-    size_t i = 0;
-    size_t startIdx = dimension->startIdxs[0];
-    size_t endIdx = dimension->endIdxs[0];
-
-    fmi2_import_variable_t ** vars = mcx_calloc(endIdx - startIdx + 1, sizeof(fmi2_import_variable_t *));
-    if (!vars) {
-        return NULL;
-    }
-
-    for (i = startIdx; i <= endIdx; i++) {
-        char * indexedChannelName = CreateIndexedName(channelName, i);
-        fmi2_import_variable_t * var = fmi2_import_get_variable_by_name(fmiImport, indexedChannelName);
-        if (!var) {
-            mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, indexedChannelName);
-            return NULL;
-        }
-        if (!ChannelTypeEq(ChannelTypeArrayInner(type), Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
-            mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, indexedChannelName);
-            mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
-                    ChannelTypeToString(ChannelTypeArrayInner(type)),
-                    ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
-            return NULL;
-        }
-        vars[i - startIdx] = var;
-
-        mcx_free(indexedChannelName);
-    }
-
-    size_t dims[] = { endIdx - startIdx + 1 };
-    val = Fmu2ValueArrayMake(channelName, 1 /* numDims */, dims, vars, unitString, NULL);
-    if (!val) {
-        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
-        return NULL;
-    }
-
-    return val;
-}
-
 static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Databus * db, fmi2_import_t * fmiImport, const char * logPrefix) {
     McxStatus retVal = RETURN_OK;
 
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index bad234b..b3c1929 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -11,6 +11,7 @@
 #include "fmu/Fmu2Value.h"
 
 #include "core/channels/ChannelValue.h"
+#include "core/connections/ConnectionInfoFactory.h"
 #include "CentralParts.h"
 #include "util/string.h"
 #include "util/stdlib.h"
@@ -342,6 +343,81 @@ void Fmu2ValuePrintDebug(Fmu2Value * val) {
     mcx_log(LOG_DEBUG, "Fmu2Value { name: \"%s\" }", val->name);
 }
 
+Fmu2Value * Fmu2ReadFmu2ScalarValue(const char * logPrefix, ChannelType * type, const char * channelName, const char * unitString, fmi2_import_t * fmiImport) {
+    Fmu2Value * val = NULL;
+    fmi2_import_variable_t * var = NULL;
+
+    var = fmi2_import_get_variable_by_name(fmiImport, channelName);
+    if (!var) {
+        mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, channelName);
+        return NULL;
+    }
+
+    if (!ChannelTypeEq(type, Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
+        mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelName);
+        mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
+                ChannelTypeToString(type),
+                ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
+        return NULL;
+    }
+
+    val = Fmu2ValueScalarMake(channelName, var, unitString, NULL);
+    if (!val) {
+        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
+        return NULL;
+    }
+
+    return val;
+}
+
+Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, const char * channelName, ChannelDimension * dimension, const char * unitString, fmi2_import_t * fmiImport) {
+    Fmu2Value * val = NULL;
+    fmi2_import_variable_t * var = NULL;
+
+    if (dimension->num > 1) {
+        mcx_log(LOG_ERROR, "%s: Port %s: Invalid dimension", logPrefix, channelName);
+        return RETURN_ERROR;
+    }
+
+    size_t i = 0;
+    size_t startIdx = dimension->startIdxs[0];
+    size_t endIdx = dimension->endIdxs[0];
+
+    fmi2_import_variable_t ** vars = mcx_calloc(endIdx - startIdx + 1, sizeof(fmi2_import_variable_t *));
+    if (!vars) {
+        return NULL;
+    }
+
+    for (i = startIdx; i <= endIdx; i++) {
+        char * indexedChannelName = CreateIndexedName(channelName, i);
+        fmi2_import_variable_t * var = fmi2_import_get_variable_by_name(fmiImport, indexedChannelName);
+        if (!var) {
+            mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, indexedChannelName);
+            return NULL;
+        }
+        if (!ChannelTypeEq(ChannelTypeArrayInner(type), Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
+            mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, indexedChannelName);
+            mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
+                    ChannelTypeToString(ChannelTypeArrayInner(type)),
+                    ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
+            return NULL;
+        }
+        vars[i - startIdx] = var;
+
+        mcx_free(indexedChannelName);
+    }
+
+    size_t dims[] = { endIdx - startIdx + 1 };
+    val = Fmu2ValueArrayMake(channelName, 1 /* numDims */, dims, vars, unitString, NULL);
+    if (!val) {
+        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
+        return NULL;
+    }
+
+    return val;
+}
+
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/fmu/Fmu2Value.h b/src/fmu/Fmu2Value.h
index 6c70d07..fb85f7e 100644
--- a/src/fmu/Fmu2Value.h
+++ b/src/fmu/Fmu2Value.h
@@ -13,6 +13,7 @@
 
 #include "CentralParts.h"
 #include "core/channels/Channel.h"
+#include "core/channels/ChannelDimension.h"
 #include "fmilib.h"
 
 #ifdef __cplusplus
@@ -114,6 +115,9 @@ Fmu2Value * Fmu2ValueBinaryMake(const char * name, fmi2_import_variable_t * hi,
 
 void Fmu2ValuePrintDebug(Fmu2Value * val);
 
+Fmu2Value * Fmu2ReadFmu2ScalarValue(const char * logPrefix, ChannelType * type, const char * channelName, const char * unitString, fmi2_import_t * fmiImport);
+Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, const char * channelName, ChannelDimension * dimension, const char * unitString, fmi2_import_t * fmiImport);
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */

From 97935ae374e95513f63913c44e443a4c8259a503 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 06:24:39 +0200
Subject: [PATCH 033/166] fmu: Check status of Fmu2ReadFmu2{Scalar,Array}Value

---
 src/components/comp_fmu.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index 71c2b2f..6ffe7c7 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -591,6 +591,10 @@ static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Datab
             }
         } else if (info->dimension) {
             val = Fmu2ReadFmu2ArrayValue(logPrefix, info->type, channelName, info->dimension, info->unitString, fmiImport);
+            if (!val) {
+                mcx_log(LOG_ERROR, "%s: Could not create value for %s", logPrefix, channelName);
+                return RETURN_ERROR;
+            }
 
             val->SetChannel(val, info->channel);
 
@@ -601,6 +605,10 @@ static McxStatus Fmu2ReadChannelIn(ObjectContainer /* Fmu2Value */ * vals, Datab
             }
         } else { // scalar
             val = Fmu2ReadFmu2ScalarValue(logPrefix, info->type, channelName, info->unitString, fmiImport);
+            if (!val) {
+                mcx_log(LOG_ERROR, "%s: Could not create value for %s", logPrefix, channelName);
+                return RETURN_ERROR;
+            }
 
             val->SetChannel(val, info->channel);
 

From bf5d66df8f5ebba0d2add3ee06af0573acbeeea3 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 24 Aug 2021 12:38:15 +0200
Subject: [PATCH 034/166] fmu: Improve error message for "unknown type"

---
 src/fmu/common_fmu2.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 743952a..925560b 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -760,7 +760,7 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
         break;
     }
     default:
-        mcx_log(LOG_ERROR, "FMU: Unknown variable type");
+        mcx_log(LOG_ERROR, "FMU: Unknown variable type: %s", ChannelTypeToString(type));
         return RETURN_ERROR;
     }
 

From 6be26231fb6a028498491e8fb5f798e640aab2d3 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 06:25:24 +0200
Subject: [PATCH 035/166] fmu: Extend Fmu2ValueSetup to handle arrays

This includes a workaround for a crash in binary channel values.
---
 src/fmu/Fmu2Value.c | 157 +++++++++++++++++++++++++++++++++++++-------
 1 file changed, 133 insertions(+), 24 deletions(-)

diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index b3c1929..70cc1a4 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -213,6 +213,96 @@ static McxStatus Fmu2ValueSetFromChannelValue(Fmu2Value * v, ChannelValue * val)
     return ChannelValueSet(&v->val, val);
 }
 
+static McxStatus Fmu2ValueGetVariableStart(fmi2_base_type_enu_t t, fmi2_import_variable_t * var, ChannelValue * value) {
+
+    switch (t) {
+    case fmi2_base_type_real:
+        value->value.d = fmi2_import_get_real_variable_start(fmi2_import_get_variable_as_real(var));
+        break;
+    case fmi2_base_type_int:
+        value->value.i = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(var));
+        break;
+    case fmi2_base_type_bool:
+        value->value.i = fmi2_import_get_boolean_variable_start(fmi2_import_get_variable_as_boolean(var));
+        break;
+    case fmi2_base_type_str: {
+        const char * buffer = fmi2_import_get_string_variable_start(fmi2_import_get_variable_as_string(var));
+        if (RETURN_OK != ChannelValueSetFromReference(value, &buffer)) {
+            return RETURN_ERROR;
+        }
+        break;
+    }
+    case fmi2_base_type_enum:
+        value->value.i = fmi2_import_get_enum_variable_start(fmi2_import_get_variable_as_enum(var));
+        break;
+    default:
+        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Base type %s not supported", fmi2_base_type_to_string(t));
+        return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus Fmu2ValueGetArrayVariableStart(fmi2_base_type_enu_t t, fmi2_import_variable_t * var, array * a, size_t i) {
+
+    switch (t) {
+    case fmi2_base_type_real:
+        ((double *)a->data)[i] = fmi2_import_get_real_variable_start(fmi2_import_get_variable_as_real(var));
+        break;
+    case fmi2_base_type_int:
+        ((int *)a->data)[i] = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(var));
+        break;
+    case fmi2_base_type_enum:
+       ((int *)a->data)[i] = fmi2_import_get_enum_variable_start(fmi2_import_get_variable_as_enum(var));
+        break;
+    case fmi2_base_type_bool:
+        ((int *)a->data)[i] = fmi2_import_get_boolean_variable_start(fmi2_import_get_variable_as_boolean(var));
+        break;
+    default:
+        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Array base type %s not supported", fmi2_base_type_to_string(t));
+        return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus Fmu2ValueGetBinaryVariableStart(fmi2_import_variable_t * varHi, fmi2_import_variable_t * varLo, fmi2_import_variable_t * varSize, ChannelValue * value) {
+    fmi2_base_type_enu_t t;
+
+    t = fmi2_import_get_variable_base_type(varHi);
+    if (t != fmi2_base_type_int) {
+        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Binary base type (hi) %s not supported", fmi2_base_type_to_string(t));
+        return RETURN_ERROR;
+    }
+    t = fmi2_import_get_variable_base_type(varLo);
+    if (t != fmi2_base_type_int) {
+        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Binary base type (lo) %s not supported", fmi2_base_type_to_string(t));
+        return RETURN_ERROR;
+    }
+    t = fmi2_import_get_variable_base_type(varSize);
+    if (t != fmi2_base_type_int) {
+        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Binary base type (size) %s not supported", fmi2_base_type_to_string(t));
+        return RETURN_ERROR;
+    }
+
+    fmi2_integer_t hi = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(varHi));
+    fmi2_integer_t lo = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(varLo));
+    fmi2_integer_t size = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(varSize));
+
+    binary_string b;
+
+    b.len = size;
+    b.data = (char *) ((((long long)hi & 0xffffffff) << 32) | (lo & 0xffffffff));
+
+    if (RETURN_OK != ChannelValueSetFromReference(value, &b)) {
+        mcx_log(LOG_ERROR, "Fmu2Value: Could not set value");
+        return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
+
 static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData * data, const char * unit, Channel * channel) {
     if (!name || !data) {
         mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Name or data missing");
@@ -224,42 +314,61 @@ static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData
     v->data = data;
     v->channel = channel;
 
+    if (!v->name) {
+        mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Cannot copy name");
+        return RETURN_ERROR;
+    }
+
     if (v->data->type == FMU2_VALUE_SCALAR) {
         fmi2_base_type_enu_t t = fmi2_import_get_variable_base_type(data->data.scalar);
 
         ChannelValueInit(&v->val, ChannelTypeClone(Fmi2TypeToChannelType(t)));
 
-        if (!v->name) {
-            mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Cannot copy name");
+
+        if (RETURN_OK != Fmu2ValueGetVariableStart(t, data->data.scalar, &v->val)) {
+            return RETURN_ERROR;
+        }
+    } else if (v->data->type == FMU2_VALUE_ARRAY) {
+        fmi2_base_type_enu_t t = fmi2_import_get_variable_base_type(data->data.array.values[0]);
+
+        ChannelValueInit(&v->val, ChannelTypeArray(Fmi2TypeToChannelType(t), data->data.array.numDims, data->data.array.dims));
+
+        if (data->data.array.numDims == 0) {
+            mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Array of dimension 0 is not supported");
             return RETURN_ERROR;
         }
 
-        switch (t) {
-        case fmi2_base_type_real:
-            v->val.value.d = fmi2_import_get_real_variable_start(fmi2_import_get_variable_as_real(data->data.scalar));
-            break;
-        case fmi2_base_type_int:
-            v->val.value.i = fmi2_import_get_integer_variable_start(fmi2_import_get_variable_as_integer(data->data.scalar));
-            break;
-        case fmi2_base_type_bool:
-            v->val.value.i = fmi2_import_get_boolean_variable_start(fmi2_import_get_variable_as_boolean(data->data.scalar));
-            break;
-        case fmi2_base_type_str: {
-            const char * buffer = fmi2_import_get_string_variable_start(fmi2_import_get_variable_as_string(data->data.scalar));
-            if (RETURN_OK != ChannelValueSetFromReference(&v->val, &buffer)) {
+        size_t i = 0, n = 1;
+
+        for (i = 0; i < data->data.array.numDims; i++) {
+            n *= data->data.array.dims[i];
+        }
+
+        array * a = (array *) ChannelValueReference(&v->val);
+
+        for (i = 0; i < n; i++) {
+            if (RETURN_OK != Fmu2ValueGetArrayVariableStart(t, data->data.array.values[i], a, i)) {
                 return RETURN_ERROR;
             }
-            break;
-        }
-        case fmi2_base_type_enum:
-            v->val.value.i = fmi2_import_get_enum_variable_start(fmi2_import_get_variable_as_enum(data->data.scalar));
-            break;
-        default:
-            mcx_log(LOG_ERROR, "Fmu2Value: Setup failed: Base type %s not supported", fmi2_base_type_to_string(t));
-            return RETURN_ERROR;
         }
+    } else if (v->data->type == FMU2_VALUE_BINARY_OSI) {
+        return RETURN_OK;
+
+        // TODO: Setting the initial value causes some memory errors.
+
+        // ChannelValueInit(&v->val, &ChannelTypeBinary);
+
+        // if (RETURN_OK != Fmu2ValueGetBinaryVariableStart(
+        //         data->data.binary.hi,
+        //         data->data.binary.lo,
+        //         data->data.binary.size,
+        //         &v->val)) {
+        //     return RETURN_ERROR;
+        // }
+
+
     } else {
-        // TODO
+        return RETURN_ERROR;
     }
 
     return RETURN_OK;

From d18c5ec6756350dd6a27860022af129679815c94 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Fri, 20 Aug 2021 13:50:37 +0200
Subject: [PATCH 036/166] icos: Refactor ports and remove VectorChannelInfo

---
 src/core/channels/ChannelDimension.c | 14 ++++++++++++++
 src/core/channels/ChannelDimension.h |  2 +-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index a0886b3..7a01564 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -62,6 +62,20 @@ McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num,
     return RETURN_OK;
 }
 
+size_t ChannelDimensionNumElements(ChannelDimension * dimension) {
+    size_t i = 0, n = 1;
+
+    if (dimension->num == 0) {
+        return 0;
+    }
+
+    for (i = 0; i < dimension->num; i++) {
+        n *= (dimension->endIdxs[i] - dimension->startIdxs[i] + 1);
+    }
+
+    return n;
+}
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 20c11f1..d8763c7 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -30,7 +30,7 @@ typedef struct ChannelDimension {
 
 McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num);
 McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end);
-
+size_t ChannelDimensionNumElements(ChannelDimension * dimension);
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */

From a3839e32f2706349249bc7d1cd84118067b3dd7a Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 31 Aug 2021 14:10:08 +0200
Subject: [PATCH 037/166] channel: Replace double with ChannelValueData for
 proc functions

---
 src/core/channels/Channel.c               |  7 +++++--
 src/core/channels/ChannelValue.h          | 13 ++++++++-----
 src/core/connections/FilteredConnection.c |  9 ++++++---
 3 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 653cb6e..b1323f8 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -707,10 +707,13 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
         if (out->GetFunction(out)) {
             // function value
             proc * p = (proc *) out->GetFunction(out);
-            double val = p->fn(time, p->env);
+            ChannelValueData val = { 0 };
+            if (p->fn(time, p->env, &val) != 0) {
+                return RETURN_ERROR;
+            }
 #ifdef MCX_DEBUG
             if (time->startTime < MCX_DEBUG_LOG_TIME) {
-                MCX_DEBUG_LOG("[%f] CH OUT (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, val);
+                MCX_DEBUG_LOG("[%f] CH OUT (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, val.d);
             }
 #endif // MCX_DEBUG
             if (RETURN_OK != ChannelValueSetFromReference(&channel->value, &val)) {
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index fda2fb1..eefeb57 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -80,8 +80,11 @@ typedef struct {
     double endTime;
 } TimeInterval;
 
+typedef union ChannelValueData ChannelValueData;
+typedef struct ChannelValue ChannelValue;
+
 typedef struct {
-    double (* fn)(TimeInterval * arg, void * env);
+    int (* fn)(TimeInterval * arg, void * env, ChannelValueData * res);
     void * env;
 } proc;
 
@@ -103,19 +106,19 @@ int array_dims_match(array * a, array * b);
 size_t array_num_elements(array * a);
 
 // TODO: change concrete types to McxDouble, McxInteger, etc
-typedef union ChannelValueData {
+union ChannelValueData {
     /* the order is significant. double needs to be the first entry for union initialization to work */
     double d;
     int i;
     char * s;
     binary_string b;
     array a;
-} ChannelValueData;
+};
 
-typedef struct ChannelValue {
+struct ChannelValue {
     ChannelType * type;
     ChannelValueData value;
-} ChannelValue;
+};
 
 // Takes ownership of type
 void   ChannelValueInit(ChannelValue * value, ChannelType * type);
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index a33e2fb..c8fd206 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -155,9 +155,12 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
 
     if (out->GetFunction(out)) {
         proc * p = (proc *) out->GetFunction(out);
-        double value = 0.0;
+        ChannelValueData value = { 0 };
 
-        value = p->fn(time, p->env);
+        if (p->fn(time, p->env, &value) != 0) {
+            mcx_log(LOG_ERROR, "FilteredConnection: Function failed");
+            return RETURN_ERROR;
+        }
         if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
             mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
             return RETURN_ERROR;
@@ -165,7 +168,7 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
     } else {
         // only filter if time is not negative (negative time means filter disabled)
         if (filteredConnection->GetReadFilter(filteredConnection) && time->startTime >= 0) {
-            ChannelValueData value;
+            ChannelValueData value = { 0 };
 
             filter = filteredConnection->GetReadFilter(filteredConnection);
             value = filter->GetValue(filter, time->startTime);

From c3d9c55761eb43e2bc3bd587c5f694ff4354a146 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 23 Aug 2021 18:43:48 +0200
Subject: [PATCH 038/166] Move CreateIndexedName to ChannelValue

---
 src/core/channels/ChannelValue.c             | 17 +++++++++++++++++
 src/core/channels/ChannelValue.h             |  2 ++
 src/core/connections/ConnectionInfoFactory.c | 18 ++----------------
 src/core/connections/ConnectionInfoFactory.h |  1 -
 4 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index f290ba7..0dbb319 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -35,6 +35,23 @@ ChannelType ChannelTypeBinary = { CHANNEL_BINARY, NULL};
 ChannelType ChannelTypeBinaryReference = { CHANNEL_BINARY_REFERENCE, NULL};
 
 
+char * CreateIndexedName(const char * name, unsigned i) {
+    size_t len = 0;
+    char * buffer = NULL;
+
+    len = strlen(name) + (mcx_digits10(i) + 1) + 2 + 1;
+
+    buffer = (char *) mcx_calloc(len, sizeof(char));
+    if (!buffer) {
+        return NULL;
+    }
+
+    snprintf(buffer, len, "%s[%d]", name, i);
+
+    return buffer;
+}
+
+
 ChannelType * ChannelTypeClone(ChannelType * type) {
     switch (type->con) {
     case CHANNEL_UNKNOWN:
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index eefeb57..a919268 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -20,6 +20,8 @@ extern "C" {
 
 void * mcx_copy(void * object, size_t size);
 
+char * CreateIndexedName(const char * name, unsigned i);
+
 // possible types of values that can be put on channels
 typedef enum ChannelTypeConstructor {
     CHANNEL_UNKNOWN = 0,
diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index f0f774b..0db5751 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -17,27 +17,13 @@
 #include "util/stdlib.h"
 #include "util/string.h"
 
+#include "core/channels/ChannelValue.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
 
-char * CreateIndexedName(const char * name, unsigned i) {
-    size_t len = 0;
-    char * buffer = NULL;
-
-    len = strlen(name) + (mcx_digits10(i) + 1) + 2 + 1;
-
-    buffer = (char *) mcx_calloc(len, sizeof(char));
-    if (!buffer) {
-        return NULL;
-    }
-
-    snprintf(buffer, len, "%s[%d]", name, i);
-
-    return buffer;
-}
-
 static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
                                                          ObjectContainer * components,
                                                          ConnectionInput * connInput,
diff --git a/src/core/connections/ConnectionInfoFactory.h b/src/core/connections/ConnectionInfoFactory.h
index e8494da..b7e0b63 100644
--- a/src/core/connections/ConnectionInfoFactory.h
+++ b/src/core/connections/ConnectionInfoFactory.h
@@ -20,7 +20,6 @@
 extern "C" {
 #endif /* __cplusplus */
 
-char * CreateIndexedName(const char * name, unsigned i);
 Vector * ConnectionInfoFactoryCreateConnectionInfos(ObjectContainer * components,
                                                     ConnectionInput * connInput,
                                                     Component * sourceCompOverride,

From 1c29e105c1da74cd66d74fea9db7598457e243e3 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Wed, 1 Sep 2021 14:15:25 +0200
Subject: [PATCH 039/166] db: Remove DatabusGet{In,Out}VectorChannel{Info,Num}

---
 src/components/comp_constant.c |  8 ++--
 src/core/Databus.c             | 79 ++++++----------------------------
 src/core/Databus.h             |  7 ---
 3 files changed, 16 insertions(+), 78 deletions(-)

diff --git a/src/components/comp_constant.c b/src/components/comp_constant.c
index c1b1140..b911ad8 100644
--- a/src/components/comp_constant.c
+++ b/src/components/comp_constant.c
@@ -56,7 +56,7 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
 static ChannelValue * GetValue(CompConstant * compConstant, size_t idx) {
     Component * comp = (Component *) (compConstant);
     Databus * db = comp->GetDatabus(comp);
-    size_t numVecOut = DatabusGetOutVectorChannelsNum(db);
+    size_t numOut = DatabusGetOutChannelsNum(db);
     size_t i = 0;
     size_t sum = 0;
     ChannelValue * value = NULL;
@@ -65,8 +65,8 @@ static ChannelValue * GetValue(CompConstant * compConstant, size_t idx) {
     size_t startIdx = 0;
     size_t endIdx = 0;
 
-    for (i = 0; i < numVecOut; i++) {
-        vInfo = DatabusGetOutVectorChannelInfo(db, i);
+    for (i = 0; i < numOut; i++) {
+        vInfo = DatabusGetOutChannelInfo(db, i);
         startIdx = vInfo->GetStartIndex(vInfo);
         endIdx = vInfo->GetEndIndex(vInfo);
         numCh = endIdx - startIdx + 1;
@@ -77,7 +77,7 @@ static ChannelValue * GetValue(CompConstant * compConstant, size_t idx) {
         }
     }
 
-    if (i >= numVecOut) {
+    if (i >= numOut) {
         ComponentLog(comp, LOG_ERROR, "GetValue: Invalid index (%zu) provided", idx);
         return NULL;
     }
diff --git a/src/core/Databus.c b/src/core/Databus.c
index 0be9d88..a55ee9a 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -894,26 +894,6 @@ size_t DatabusGetInChannelsNum(Databus * db) {
     return DatabusInfoGetChannelNum(DatabusGetInInfo(db));
 }
 
-// Only returns SIZE_T_ERROR if db was NULL
-size_t DatabusGetOutVectorChannelsNum(Databus * db) {
-    if (!db) {
-        mcx_log(LOG_ERROR, "Ports: Get outport number: Invalid structure");
-        return SIZE_T_ERROR;
-    }
-
-    return DatabusInfoGetVectorChannelNum(DatabusGetOutInfo(db));
-}
-
-// Only returns SIZE_T_ERROR if db was NULL
-size_t DatabusGetInVectorChannelsNum(Databus * db) {
-    if (!db) {
-        mcx_log(LOG_ERROR, "Ports: Get inport number: Invalid structure");
-        return SIZE_T_ERROR;
-    }
-
-    return DatabusInfoGetVectorChannelNum(DatabusGetInInfo(db));
-}
-
 // Only returns SIZE_T_ERROR if db was NULL
 size_t DatabusGetLocalChannelsNum(Databus * db) {
     if (!db) {
@@ -1019,12 +999,12 @@ McxStatus DatabusSetOutRefVectorChannel(Databus * db, size_t channel,
         return RETURN_ERROR;
     }
 
-    if (channel > DatabusGetOutVectorChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutVectorChannelsNum(db));
+    if (channel > DatabusGetOutChannelsNum(db)) {
+        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutChannelsNum(db));
         return RETURN_ERROR;
     }
 
-    vInfo = DatabusGetOutVectorChannelInfo(db, channel);
+    vInfo = DatabusGetOutChannelInfo(db, channel);
     for (i = startIdx; i <= endIdx; i++) {
         McxStatus retVal = RETURN_OK;
         const void * ref = NULL;
@@ -1068,12 +1048,12 @@ McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
         return RETURN_ERROR;
     }
 
-    if (channel > DatabusGetOutVectorChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutVectorChannelsNum(db));
+    if (channel > DatabusGetOutChannelsNum(db)) {
+        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutChannelsNum(db));
         return RETURN_ERROR;
     }
 
-    vInfo = DatabusGetOutVectorChannelInfo(db, channel);
+    vInfo = DatabusGetOutChannelInfo(db, channel);
     for (i = startIdx; i <= endIdx; i++) {
         McxStatus retVal = RETURN_OK;
         const void * ref = NULL;
@@ -1167,12 +1147,12 @@ McxStatus DatabusSetInRefVector(Databus * db, size_t channel, size_t startIdx, s
         mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector needs to be specified");
         return RETURN_ERROR;
     }
-    if (channel > DatabusGetInVectorChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutVectorChannelsNum(db));
+    if (channel > DatabusGetInChannelsNum(db)) {
+        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutChannelsNum(db));
         return RETURN_ERROR;
     }
 
-    vInfo = DatabusGetInVectorChannelInfo(db, channel);
+    vInfo = DatabusGetInChannelInfo(db, channel);
     for (i = startIdx; i <= endIdx; i++) {
         McxStatus retVal = RETURN_OK;
         void * ref = NULL;
@@ -1224,12 +1204,12 @@ McxStatus DatabusSetInRefVectorChannel(Databus * db, size_t channel,
         mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector needs to be specified");
         return RETURN_ERROR;
     }
-    if (channel > DatabusGetInVectorChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetInVectorChannelsNum(db));
+    if (channel > DatabusGetInChannelsNum(db)) {
+        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetInChannelsNum(db));
         return RETURN_ERROR;
     }
 
-    vInfo = DatabusGetInVectorChannelInfo(db, channel);
+    vInfo = DatabusGetInChannelInfo(db, channel);
     for (i = startIdx; i <= endIdx; i++) {
         McxStatus retVal = RETURN_OK;
         void * ref = NULL;
@@ -1486,41 +1466,6 @@ ChannelInfo * DatabusGetLocalChannelInfo(Databus * db, size_t channel) {
     return (ChannelInfo *) data->infos->At(data->infos, channel);
 }
 
-ChannelInfo * DatabusGetRTFactorChannelInfo(Databus * db, size_t channel) {
-    DatabusInfoData * data = db->data->rtfactorInfo->data;
-
-    if (channel >= data->infos->Size(data->infos)) {
-        mcx_log(LOG_ERROR, "Ports: Get rtfactor-info: Unknown port %d", channel);
-        return NULL;
-    }
-
-    return (ChannelInfo *) data->infos->At(data->infos, channel);
-}
-
-VectorChannelInfo * DatabusGetInVectorChannelInfo(Databus * db, size_t channel) {
-    DatabusInfo * inInfo = NULL;
-    if (!db) {
-        mcx_log(LOG_ERROR, "Ports: Get in-info: Invalid structure");
-        return NULL;
-    }
-
-    inInfo = DatabusGetInInfo(db);
-
-    return DatabusInfoGetVectorChannelInfo(inInfo, channel);
-}
-
-VectorChannelInfo * DatabusGetOutVectorChannelInfo(Databus * db, size_t channel) {
-    DatabusInfo * outInfo = NULL;
-    if (!db) {
-        mcx_log(LOG_ERROR, "Ports: Get out-info: Invalid structure");
-        return NULL;
-    }
-
-    outInfo = DatabusGetOutInfo(db);
-
-    return DatabusInfoGetVectorChannelInfo(outInfo, channel);
-}
-
 int DatabusChannelInIsValid(Databus * db, size_t channel) {
     Channel * in = NULL;
 
diff --git a/src/core/Databus.h b/src/core/Databus.h
index d003e85..572285e 100644
--- a/src/core/Databus.h
+++ b/src/core/Databus.h
@@ -125,13 +125,6 @@ McxStatus DatabusAddRTFactorChannel(Databus * db,
 
 /* vector channel functions */
 
-VectorChannelInfo * DatabusGetInVectorChannelInfo(Databus * db, size_t channel);
-VectorChannelInfo * DatabusGetOutVectorChannelInfo(Databus * db, size_t channel);
-
-size_t DatabusGetInVectorChannelsNum(Databus * db);
-
-size_t DatabusGetOutVectorChannelsNum(Databus * db);
-
 McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
     size_t startIdx, size_t endIdx, const void * reference, ChannelType * type);
 

From 7f54ae7b7340fbb16c80cf441b23dd1af76e4c3f Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Thu, 2 Sep 2021 09:21:00 +0200
Subject: [PATCH 040/166] db: Remove DatabusSet{In,Out}RefVector{Channel}

---
 src/core/Databus.c | 219 ---------------------------------------------
 src/core/Databus.h |  13 ---
 2 files changed, 232 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index a55ee9a..b044bcb 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -982,122 +982,6 @@ McxStatus DatabusSetOutReferenceFunction(Databus * db, size_t channel, const voi
     return out->SetReferenceFunction(out, (const proc *) reference, type);
 }
 
-McxStatus DatabusSetOutRefVectorChannel(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, ChannelValue * value)
-{
-    VectorChannelInfo * vInfo = NULL;
-    size_t i = 0;
-    size_t ii = 0;
-    ChannelType * type = ChannelValueType(value);
-
-    if (startIdx > endIdx) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
-        return RETURN_ERROR;
-    }
-    if (!ChannelTypeIsValid(type)) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Type of vector needs to be specified");
-        return RETURN_ERROR;
-    }
-
-    if (channel > DatabusGetOutChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutChannelsNum(db));
-        return RETURN_ERROR;
-    }
-
-    vInfo = DatabusGetOutChannelInfo(db, channel);
-    for (i = startIdx; i <= endIdx; i++) {
-        McxStatus retVal = RETURN_OK;
-        const void * ref = NULL;
-        ChannelOut * chOut = NULL;
-        ChannelInfo * chInfo = vInfo->GetElement(vInfo, i);
-        if (!chInfo) {
-            mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector Port does not exist");
-            return RETURN_ERROR;
-        }
-        chOut = (ChannelOut *) chInfo->channel;
-        if (!chOut) {
-            mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector Port not initialized");
-            return RETURN_ERROR;
-        }
-        ii = i - startIdx;
-        ref = (const void *) ( &((ChannelValue*)value + ii)->value );
-
-        retVal = chOut->SetReference(chOut, ref, type);
-        if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Ports: Set out reference vector: Reference could not be set");
-            return RETURN_ERROR;
-        }
-    }
-
-    return RETURN_OK;
-}
-
-McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, const void * reference, ChannelType * type)
-{
-    VectorChannelInfo * vInfo = NULL;
-    size_t i = 0;
-    size_t ii = 0;
-
-    if (startIdx > endIdx) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
-        return RETURN_ERROR;
-    }
-    if (!ChannelTypeIsValid(type)) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Type of vector needs to be specified");
-        return RETURN_ERROR;
-    }
-
-    if (channel > DatabusGetOutChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutChannelsNum(db));
-        return RETURN_ERROR;
-    }
-
-    vInfo = DatabusGetOutChannelInfo(db, channel);
-    for (i = startIdx; i <= endIdx; i++) {
-        McxStatus retVal = RETURN_OK;
-        const void * ref = NULL;
-        ChannelOut * chOut = NULL;
-        ChannelInfo * chInfo = vInfo->GetElement(vInfo, i);
-        if (!chInfo) {
-            mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector Port does not exist");
-            return RETURN_ERROR;
-        }
-        chOut = (ChannelOut *) chInfo->channel;
-        if (!chOut) {
-            mcx_log(LOG_ERROR, "Ports: Set out reference vector: Vector Port not initialized");
-            return RETURN_ERROR;
-        }
-        ii = i - startIdx;
-        switch (type->con) {
-        case CHANNEL_DOUBLE:
-            ref = (const void *) (((double *) reference) + ii);
-            break;
-        case CHANNEL_INTEGER:
-            ref = (const void *) (((int *) reference) + ii);
-            break;
-        case CHANNEL_BOOL:
-            ref = (const void *) (((int *) reference) + ii);
-            break;
-        case CHANNEL_BINARY:
-        case CHANNEL_BINARY_REFERENCE:
-            ref = (const void *) (((binary_string *) reference) + ii);
-            break;
-        default:
-            mcx_log(LOG_ERROR, "Ports: Set out reference vector: Type of vector not allowed");
-            return RETURN_ERROR;
-        }
-
-        retVal = chOut->SetReference(chOut, ref, type);
-        if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Ports: Set out reference vector: Reference could not be set");
-            return RETURN_ERROR;
-        }
-    }
-
-    return RETURN_OK;
-}
-
 McxStatus DatabusSetInReference(Databus * db, size_t channel, void * reference, ChannelType *  type) {
     ChannelIn * in = NULL;
     ChannelInfo * info = NULL;
@@ -1134,109 +1018,6 @@ McxStatus DatabusSetInReference(Databus * db, size_t channel, void * reference,
     return in->SetReference(in, reference, type);
 }
 
-McxStatus DatabusSetInRefVector(Databus * db, size_t channel, size_t startIdx, size_t endIdx, void * reference, ChannelType * type)
-{
-    VectorChannelInfo * vInfo = NULL;
-    size_t i = 0;
-    size_t ii = 0;
-    if (startIdx > endIdx) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
-        return RETURN_ERROR;
-    }
-    if (!ChannelTypeIsValid(type)) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector needs to be specified");
-        return RETURN_ERROR;
-    }
-    if (channel > DatabusGetInChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetOutChannelsNum(db));
-        return RETURN_ERROR;
-    }
-
-    vInfo = DatabusGetInChannelInfo(db, channel);
-    for (i = startIdx; i <= endIdx; i++) {
-        McxStatus retVal = RETURN_OK;
-        void * ref = NULL;
-        ChannelIn * chIn = NULL;
-        ChannelInfo * chInfo = vInfo->GetElement(vInfo, i);
-        if (!chInfo) {
-            mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector Port does not exist");
-            return RETURN_ERROR;
-        }
-        chIn = (ChannelIn *) chInfo->channel;
-        if (!chIn) {
-            mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector Port not initialized");
-            return RETURN_ERROR;
-        }
-        ii = i - startIdx;
-        if (ChannelTypeEq(&ChannelTypeDouble, type)) {
-            ref = (void *) (((double *) reference) + ii);
-        } else if (ChannelTypeEq(&ChannelTypeInteger, type)) {
-            ref = (void *) (((int *) reference) + ii);
-        } else if (ChannelTypeEq(&ChannelTypeBool, type)) {
-            ref = (void *) (((int *) reference) + ii);
-        } else {
-            mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector not allowed");
-            return RETURN_ERROR;
-        }
-        retVal = chIn->SetReference(chIn, ref, type);
-        if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Ports: Set in reference vector: Reference could not be set");
-            return RETURN_ERROR;
-        }
-    }
-
-    return RETURN_OK;
-}
-
-McxStatus DatabusSetInRefVectorChannel(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, ChannelValue * value)
-{
-    VectorChannelInfo * vInfo = NULL;
-    size_t i = 0;
-    size_t ii = 0;
-    ChannelType * type = ChannelValueType(value);
-
-    if (startIdx > endIdx) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Start index %d bigger than end index %d", startIdx, endIdx);
-        return RETURN_ERROR;
-    }
-    if (!ChannelTypeIsValid(type)) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Type of vector needs to be specified");
-        return RETURN_ERROR;
-    }
-    if (channel > DatabusGetInChannelsNum(db)) {
-        mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector port %d does not exist (numer of vector ports=%d)", channel, DatabusGetInChannelsNum(db));
-        return RETURN_ERROR;
-    }
-
-    vInfo = DatabusGetInChannelInfo(db, channel);
-    for (i = startIdx; i <= endIdx; i++) {
-        McxStatus retVal = RETURN_OK;
-        void * ref = NULL;
-        ChannelIn * chIn = NULL;
-        ChannelInfo * chInfo = vInfo->GetElement(vInfo, i);
-        if (!chInfo) {
-            mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector Port does not exist");
-            return RETURN_ERROR;
-        }
-        chIn = (ChannelIn *) chInfo->channel;
-        if (!chIn) {
-            mcx_log(LOG_ERROR, "Ports: Set in reference vector: Vector Port not initialized");
-            return RETURN_ERROR;
-        }
-        ii = i - startIdx;
-        ref = (void *) ( &((ChannelValue*)value + ii)->value );
-
-        retVal = chIn->SetReference(chIn, ref, type);
-        if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Ports: Set in reference vector: Reference could not be set");
-            return RETURN_ERROR;
-        }
-    }
-
-    return RETURN_OK;
-}
-
 
 static char * DatabusGetUniqueChannelName(Databus * db, const char * name) {
 #define SUFFIX_LEN 5
diff --git a/src/core/Databus.h b/src/core/Databus.h
index 572285e..9772d25 100644
--- a/src/core/Databus.h
+++ b/src/core/Databus.h
@@ -123,19 +123,6 @@ McxStatus DatabusAddRTFactorChannel(Databus * db,
                                    const void * reference,
                                    ChannelType * type);
 
-/* vector channel functions */
-
-McxStatus DatabusSetOutRefVector(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, const void * reference, ChannelType * type);
-
-McxStatus DatabusSetOutRefVectorChannel(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, ChannelValue * value);
-
-McxStatus DatabusSetInRefVector(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, void * reference, ChannelType * type);
-McxStatus DatabusSetInRefVectorChannel(Databus * db, size_t channel,
-    size_t startIdx, size_t endIdx, ChannelValue * value);
-
 
 /**
  * \return The address of the value of the in channel \a channel in \a db or \c NULL

From ae6ba5d8bf5c95d15b242c934f6800ea203a1661 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 08:53:21 +0200
Subject: [PATCH 041/166] channel: Remove VectorChannelInfo

---
 src/components/comp_constant.c  | 16 ----------------
 src/core/Databus.c              | 24 +-----------------------
 src/core/Databus.h              |  1 -
 src/core/Databus_impl.h         |  1 -
 src/core/channels/ChannelInfo.c | 24 ------------------------
 src/core/channels/ChannelInfo.h |  8 +-------
 6 files changed, 2 insertions(+), 72 deletions(-)

diff --git a/src/components/comp_constant.c b/src/components/comp_constant.c
index b911ad8..b670cd8 100644
--- a/src/components/comp_constant.c
+++ b/src/components/comp_constant.c
@@ -60,32 +60,16 @@ static ChannelValue * GetValue(CompConstant * compConstant, size_t idx) {
     size_t i = 0;
     size_t sum = 0;
     ChannelValue * value = NULL;
-    VectorChannelInfo * vInfo = NULL;
     size_t numCh = 0;
     size_t startIdx = 0;
     size_t endIdx = 0;
 
-    for (i = 0; i < numOut; i++) {
-        vInfo = DatabusGetOutChannelInfo(db, i);
-        startIdx = vInfo->GetStartIndex(vInfo);
-        endIdx = vInfo->GetEndIndex(vInfo);
-        numCh = endIdx - startIdx + 1;
-
-        sum += numCh;
-        if (sum > idx) {
-            break;
-        }
-    }
-
     if (i >= numOut) {
         ComponentLog(comp, LOG_ERROR, "GetValue: Invalid index (%zu) provided", idx);
         return NULL;
     }
 
     value = compConstant->values[i];
-    if (!vInfo->IsScalar(vInfo)) {
-        value += idx - (sum - numCh);
-    }
 
     return value;
 }
diff --git a/src/core/Databus.c b/src/core/Databus.c
index b044bcb..67dca95 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -38,14 +38,11 @@ extern "C" {
 
 static void DatabusInfoDataDestructor(DatabusInfoData * data) {
     object_destroy(data->infos);
-    data->origInfos->DestroyObjects(data->origInfos);
-    object_destroy(data->origInfos);
 }
 
 static DatabusInfoData * DatabusInfoDataCreate(DatabusInfoData * data) {
     data->infos = (Vector *) object_create(Vector);
     data->infos->Setup(data->infos, sizeof(ChannelInfo), ChannelInfoInit, ChannelInfoSetFrom, ChannelInfoDestroy);
-    data->origInfos = (ObjectContainer *) object_create(ObjectContainer);
     return data;
 }
 
@@ -289,7 +286,6 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
 
     Vector * dbInfos = dbInfo->data->infos;
     size_t requiredSize = 0;
-    ObjectContainer * allChannels = dbInfo->data->origInfos;
 
     for (i = 0; i < numChildren; i++) {
         PortInput * portInput = (PortInput *) input->ports->At(input->ports, i);
@@ -314,10 +310,6 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
             mcx_log(LOG_DEBUG, "    Port: \"%s\"", name);
         }
 
-        if (RETURN_OK != allChannels->PushBackNamed(allChannels, (Object *) info, name)) {
-            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %d", i);
-            return RETURN_ERROR;
-        }
         if (RETURN_OK != dbInfos->PushBack(dbInfos, (Object *) object_strong_reference(info), name)) {
             mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %d", i);
             return RETURN_ERROR;
@@ -751,7 +743,7 @@ size_t DatabusInfoGetVectorChannelNum(DatabusInfo * info) {
         return SIZE_T_ERROR;
     }
 
-    return info->data->origInfos->Size(info->data->origInfos);
+    return info->data->infos->Size(info->data->infos);
 }
 
 ChannelInfo * DatabusInfoGetChannel(DatabusInfo * info, size_t i) {
@@ -768,20 +760,6 @@ ChannelInfo * DatabusInfoGetChannel(DatabusInfo * info, size_t i) {
     return (ChannelInfo *) info->data->infos->At(info->data->infos, i);
 }
 
-static VectorChannelInfo * DatabusInfoGetVectorChannelInfo(DatabusInfo * info, size_t i) {
-    if (!info) {
-        mcx_log(LOG_ERROR, "Ports: Get vector port info: Invalid structure");
-        return NULL;
-    }
-
-    if (i >= info->data->origInfos->Size(info->data->origInfos)) {
-        mcx_log(LOG_ERROR, "Ports: Get vector port info: Unknown port %d", i);
-        return NULL;
-    }
-
-    return (VectorChannelInfo *) info->data->origInfos->At(info->data->origInfos, i);
-}
-
 int DatabusInChannelsDefined(Databus * db) {
     return db->data->in != NULL;
 }
diff --git a/src/core/Databus.h b/src/core/Databus.h
index 9772d25..d69a9ca 100644
--- a/src/core/Databus.h
+++ b/src/core/Databus.h
@@ -18,7 +18,6 @@
 #include "core/channels/Channel.h"
 #include "core/connections/Connection.h"
 #include "core/Component.h"
-#include "core/channels/VectorChannelInfo.h"
 #include "reader/model/ports/PortsInput.h"
 
 #ifdef __cplusplus
diff --git a/src/core/Databus_impl.h b/src/core/Databus_impl.h
index 8527c27..8799e8c 100644
--- a/src/core/Databus_impl.h
+++ b/src/core/Databus_impl.h
@@ -30,7 +30,6 @@ typedef struct DatabusInfoData {
     Object _; // base class
 
     Vector * infos;
-    ObjectContainer * origInfos;
 } DatabusInfoData;
 
 
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index d75de81..fa1d1cf 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -90,16 +90,6 @@ McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType * type) {
     return RETURN_OK;
 }
 
-McxStatus ChannelInfoSetVector(ChannelInfo * info, VectorChannelInfo * vector) {
-    if (info->vector) {
-        object_destroy(info->vector);
-    }
-
-    info->vector = vector;
-
-    return RETURN_OK;
-}
-
 McxStatus ChannelInfoSetup(ChannelInfo * info,
                            const char * name,
                            const char * nameInModel,
@@ -239,14 +229,6 @@ McxStatus ChannelInfoSetFrom(ChannelInfo * info, const ChannelInfo * other) {
         }
     }
 
-    if (info->vector) {
-        object_destroy(info->vector);
-    }
-
-    if (other->vector) {
-        info->vector = (VectorChannelInfo *) object_strong_reference(other->vector);
-    }
-
     return RETURN_OK;
 }
 
@@ -271,10 +253,6 @@ void ChannelInfoDestroy(ChannelInfo * info) {
     FreeChannelValue(&info->defaultValue);
     FreeChannelValue(&info->initialValue);
 
-    if (info->vector) {
-        object_destroy(info->vector);
-    }
-
     info->channel = NULL;
     info->initialValueIsExact = FALSE;
     info->type = &ChannelTypeUnknown;
@@ -283,8 +261,6 @@ void ChannelInfoDestroy(ChannelInfo * info) {
 }
 
 McxStatus ChannelInfoInit(ChannelInfo * info) {
-    info->vector = NULL;
-
     info->dimension = NULL;
 
     info->name        = NULL;
diff --git a/src/core/channels/ChannelInfo.h b/src/core/channels/ChannelInfo.h
index 59815cb..adad36d 100644
--- a/src/core/channels/ChannelInfo.h
+++ b/src/core/channels/ChannelInfo.h
@@ -12,7 +12,7 @@
 #define MCX_CORE_CHANNELS_CHANNELINFO_H
 
 #include "core/channels/ChannelValue.h"
-#include "core/channels/VectorChannelInfo.h"
+#include "CentralParts.h"
 #include "core/channels/ChannelDimension.h"
 
 #include "common/status.h"
@@ -25,11 +25,6 @@ extern "C" {
 
 
 typedef struct ChannelInfo {
-    /* vector must be NULL if this is a scalar. It is the *only* way
-     * to distinguish between vectors of size 1 and scalar values.
-     */
-    VectorChannelInfo * vector;
-
     struct Channel * channel;
 
     // Channel is a scalar iff dimension == NULL
@@ -72,7 +67,6 @@ McxStatus ChannelInfoSetID(ChannelInfo * info, const char * name);
 McxStatus ChannelInfoSetDescription(ChannelInfo * info, const char * name);
 McxStatus ChannelInfoSetUnit(ChannelInfo * info, const char * name);
 McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType * type);
-McxStatus ChannelInfoSetVector(ChannelInfo * info, VectorChannelInfo * vector);
 
 int ChannelInfoIsBinary(const ChannelInfo * info);
 

From cfea69bf4a1563fb6d9be50e7cc130127d6e1696 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 13:08:45 +0200
Subject: [PATCH 042/166] fmu: Fix memory cleanup of Fmu2Value

---
 src/fmu/Fmu2Value.c | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index 70cc1a4..af8a5bc 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -22,6 +22,12 @@ extern "C" {
 #endif /* __cplusplus */
 
 static void Fmu2ValueDataDestructor(Fmu2ValueData * data) {
+    if (data->type == FMU2_VALUE_ARRAY) {
+        mcx_free(data->data.array.dims);
+        mcx_free(data->data.array.values);
+
+        mcx_free(data->vr.array.values);
+    }
 }
 
 static Fmu2ValueData * Fmu2ValueDataCreate(Fmu2ValueData * data) {
@@ -387,6 +393,7 @@ static void Fmu2ValueDestructor(Fmu2Value * v) {
         mcx_free(v->unit);
         v->unit = NULL;
     }
+    Fmu2ValueDataDestructor(v->data);
     object_destroy(v->data);
     object_destroy(v->info);
     ChannelValueDestructor(&v->val);
@@ -485,7 +492,7 @@ Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, c
 
     if (dimension->num > 1) {
         mcx_log(LOG_ERROR, "%s: Port %s: Invalid dimension", logPrefix, channelName);
-        return RETURN_ERROR;
+        goto cleanup;
     }
 
     size_t i = 0;
@@ -494,7 +501,7 @@ Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, c
 
     fmi2_import_variable_t ** vars = mcx_calloc(endIdx - startIdx + 1, sizeof(fmi2_import_variable_t *));
     if (!vars) {
-        return NULL;
+        goto cleanup;
     }
 
     for (i = startIdx; i <= endIdx; i++) {
@@ -502,14 +509,14 @@ Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, c
         fmi2_import_variable_t * var = fmi2_import_get_variable_by_name(fmiImport, indexedChannelName);
         if (!var) {
             mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, indexedChannelName);
-            return NULL;
+            goto cleanup;
         }
         if (!ChannelTypeEq(ChannelTypeArrayInner(type), Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var)))) {
             mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, indexedChannelName);
             mcx_log(LOG_ERROR, "%s: Expected: %s, Imported from FMU: %s", logPrefix,
                     ChannelTypeToString(ChannelTypeArrayInner(type)),
                     ChannelTypeToString(Fmi2TypeToChannelType(fmi2_import_get_variable_base_type(var))));
-            return NULL;
+            goto cleanup;
         }
         vars[i - startIdx] = var;
 
@@ -520,7 +527,12 @@ Fmu2Value * Fmu2ReadFmu2ArrayValue(const char * logPrefix, ChannelType * type, c
     val = Fmu2ValueArrayMake(channelName, 1 /* numDims */, dims, vars, unitString, NULL);
     if (!val) {
         mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
-        return NULL;
+        goto cleanup;
+    }
+
+cleanup:
+    if (vars) {
+        mcx_free(vars);
     }
 
     return val;

From 13b38d03462355fda61bbae94e92cd5bb22b33d4 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 13:10:02 +0200
Subject: [PATCH 043/166] channel: Fix memory cleanup of ChannelInfo

---
 src/core/channels/ChannelInfo.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index fa1d1cf..b54717f 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -12,6 +12,8 @@
 
 #include "core/channels/ChannelInfo.h"
 
+#include "core/channels/ChannelValue.h"
+#include "objects/Object.h"
 #include "util/string.h"
 
 #ifdef __cplusplus
@@ -253,6 +255,14 @@ void ChannelInfoDestroy(ChannelInfo * info) {
     FreeChannelValue(&info->defaultValue);
     FreeChannelValue(&info->initialValue);
 
+    if (info->type) {
+        ChannelTypeDestructor(info->type);
+    }
+
+    if (info->dimension) {
+        object_destroy(info->dimension);
+    }
+
     info->channel = NULL;
     info->initialValueIsExact = FALSE;
     info->type = &ChannelTypeUnknown;

From 373b5b4499f5ffcf5bf82b41cb45688bad97f68f Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 13:10:52 +0200
Subject: [PATCH 044/166] reader: Fix memory cleanup

---
 mcx/mcx.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mcx/mcx.c b/mcx/mcx.c
index c180997..d3afd34 100644
--- a/mcx/mcx.c
+++ b/mcx/mcx.c
@@ -573,6 +573,10 @@ McxStatus RunMCX(int argc, char *argv[]) {
 
 
 cleanup:
+    if (reader) {
+        reader->Cleanup(reader);
+        object_destroy(reader);
+    }
     if (mcxInput) { object_destroy(mcxInput); }
 
     if (model) { object_destroy(model); }

From 3772aed45b92f0e6a900b9e69c1b0cc6b7621650 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 7 Sep 2021 13:32:44 +0200
Subject: [PATCH 045/166] channel: ChannelOutUpdate: Add error messages to all
 error returns

---
 src/core/channels/Channel.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index b1323f8..cbb4ceb 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -709,6 +709,7 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
             proc * p = (proc *) out->GetFunction(out);
             ChannelValueData val = { 0 };
             if (p->fn(time, p->env, &val) != 0) {
+                mcx_log(LOG_ERROR, "Port %s: Update outport: Function failed", ChannelInfoGetLogName(info));
                 return RETURN_ERROR;
             }
 #ifdef MCX_DEBUG
@@ -734,6 +735,7 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
             }
 #endif // MCX_DEBUG
             if (RETURN_OK != ChannelValueSetFromReference(&channel->value, channel->internalValue)) {
+                mcx_log(LOG_ERROR, "Port %s: Update outport: Setting value failed", ChannelInfoGetLogName(info));
                 return RETURN_ERROR;
             }
         }

From 358768d8b071a7dd1f2fed68f3eba4a9d3eff140 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Thu, 9 Sep 2021 14:05:27 +0200
Subject: [PATCH 046/166] Rename array -> mcx_array

---
 src/components/comp_vector_integrator.c | 10 +++----
 src/core/channels/ChannelValue.c        | 36 ++++++++++++-------------
 src/core/channels/ChannelValue.h        | 12 ++++-----
 src/fmu/Fmu2Value.c                     |  4 +--
 src/fmu/common_fmu2.c                   |  8 +++---
 5 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index d14424f..92e28fe 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -119,11 +119,11 @@ static McxStatus DoStep(Component * comp, size_t group, double time, double delt
     size_t i;
     for (i = 0; i < integrator->num; i++) {
         if (ChannelTypeIsArray(ChannelValueType(&integrator->state[i]))) {
-            array * state = ChannelValueReference(&integrator->state[i]);
-            array * deriv = ChannelValueReference(&integrator->deriv[i]);
+            mcx_array * state = ChannelValueReference(&integrator->state[i]);
+            mcx_array * deriv = ChannelValueReference(&integrator->deriv[i]);
 
             size_t j = 0;
-            for (j = 0; j < array_num_elements(state); j++) {
+            for (j = 0; j < mcx_array_num_elements(state); j++) {
                 ((double *)state->data)[j] = ((double *)state->data)[j] * ((double *)deriv->data)[j] + deltaTime;
             }
 
@@ -144,10 +144,10 @@ static McxStatus Initialize(Component * comp, size_t idx, double startTime) {
     size_t i;
     for (i = 0; i < integrator->num; i++) {
         if (ChannelTypeIsArray(ChannelValueType(&integrator->state[i]))) {
-            array * a = (array *) ChannelValueReference(&integrator->state[i]);
+            mcx_array * a = (mcx_array *) ChannelValueReference(&integrator->state[i]);
             size_t j;
 
-            for (j = 0; j < array_num_elements(a); j++) {
+            for (j = 0; j < mcx_array_num_elements(a); j++) {
                 ((double *) a->data)[j] = integrator->initialState;
             }
         } else {
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 0dbb319..26e5927 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -178,7 +178,7 @@ int ChannelTypeEq(ChannelType * a, ChannelType * b) {
     }
 }
 
-McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * inner) {
+McxStatus mcx_array_init(mcx_array * a, size_t numDims, size_t * dims, ChannelType * inner) {
     a->numDims = numDims;
     a->dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
     if (!a->dims) {
@@ -187,7 +187,7 @@ McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * inn
     memcpy(a->dims, dims, sizeof(size_t) * numDims);
 
     a->type = inner;
-    a->data = (void *) mcx_calloc(ChannelValueTypeSize(inner), array_num_elements(a));
+    a->data = (void *) mcx_calloc(ChannelValueTypeSize(inner), mcx_array_num_elements(a));
     if (!a->data) {
         return RETURN_ERROR;
     }
@@ -195,13 +195,13 @@ McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * inn
     return RETURN_OK;
 }
 
-void array_destroy(array * a) {
+void mcx_array_destroy(mcx_array * a) {
     if (a->dims) { mcx_free(a->dims); }
     if (a->data) { mcx_free(a->data); }
     if (a->type) { ChannelTypeDestructor(a->type); }
 }
 
-int array_dims_match(array * a, array * b) {
+int mcx_array_dims_match(mcx_array * a, mcx_array * b) {
     size_t i = 0;
 
     if (a->numDims != b->numDims) {
@@ -220,7 +220,7 @@ int array_dims_match(array * a, array * b) {
     return 1;
 }
 
-size_t array_num_elements(array * a) {
+size_t mcx_array_num_elements(mcx_array * a) {
     size_t i = 0;
     size_t n = 1;
 
@@ -372,7 +372,7 @@ char * ChannelValueToString(ChannelValue * value) {
         // TODO:
 
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
-        length *= array_num_elements(&value->value.a);
+        length *= mcx_array_num_elements(&value->value.a);
         buffer = (char *) mcx_malloc(sizeof(char) * length);
         if (!buffer) {
             return NULL;
@@ -381,9 +381,9 @@ char * ChannelValueToString(ChannelValue * value) {
         size_t i = 0;
         size_t n = 0;
 
-        if (array_num_elements(&value->value.a) > 0) {
+        if (mcx_array_num_elements(&value->value.a) > 0) {
             n += fmt(buffer + n, value->value.a.data, 0);
-            for (i = 1; i < array_num_elements(&value->value.a); i++) {
+            for (i = 1; i < mcx_array_num_elements(&value->value.a); i++) {
                 n += sprintf(buffer + n, ",");
                 n += fmt(buffer + n, value->value.a.data, i);
             }
@@ -530,7 +530,7 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType * type) {
             if (data->a.dims) {
                 memcpy(data->a.dims, type->ty.a.dims, type->ty.a.numDims * sizeof(size_t));
             }
-            data->a.data = mcx_calloc(array_num_elements(&data->a), ChannelValueTypeSize(data->a.type));
+            data->a.data = mcx_calloc(mcx_array_num_elements(&data->a), ChannelValueTypeSize(data->a.type));
             break;
         }
         case CHANNEL_UNKNOWN:
@@ -583,17 +583,17 @@ McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType
         break;
     case CHANNEL_ARRAY:
         if (NULL != reference) {
-            array * a = (array *) reference;
+            mcx_array * a = (mcx_array *) reference;
 
             // The first call to SetFromReference fixes the dimensions
             if (!data->a.numDims && a->numDims) {
-                if (RETURN_OK != array_init(&data->a, a->numDims, a->dims, a->type)) {
+                if (RETURN_OK != mcx_array_init(&data->a, a->numDims, a->dims, a->type)) {
                     return RETURN_ERROR;
                 }
             }
 
             // Arrays do not support multiplexing (yet)
-            if (!array_dims_match(&data->a, a)) {
+            if (!mcx_array_dims_match(&data->a, a)) {
                 return RETURN_ERROR;
             }
 
@@ -601,7 +601,7 @@ McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType
                 return RETURN_ERROR;
             }
 
-            memcpy(data->a.data, a->data, ChannelValueTypeSize(data->a.type) * array_num_elements(&data->a));
+            memcpy(data->a.data, a->data, ChannelValueTypeSize(data->a.type) * mcx_array_num_elements(&data->a));
         }
     case CHANNEL_UNKNOWN:
     default:
@@ -673,17 +673,17 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
         break;
     case CHANNEL_ARRAY:
         if (NULL != reference) {
-            array * a = (array *) reference;
+            mcx_array * a = (mcx_array *) reference;
 
             // First Set fixes the dimensions
             if (value->value.a.numDims && !a->numDims) {
-                if (RETURN_OK != array_init(a, value->value.a.numDims, value->value.a.dims, value->value.a.type)) {
+                if (RETURN_OK != mcx_array_init(a, value->value.a.numDims, value->value.a.dims, value->value.a.type)) {
                     return RETURN_ERROR;
                 }
             }
 
             // Arrays do not support multiplexing (yet)
-            if (!array_dims_match(a, &value->value.a)) {
+            if (!mcx_array_dims_match(a, &value->value.a)) {
                 return RETURN_ERROR;
             }
 
@@ -691,7 +691,7 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
                 return RETURN_ERROR;
             }
 
-            memcpy(a->data, value->value.a.data, ChannelValueTypeSize(a->type) * array_num_elements(a));
+            memcpy(a->data, value->value.a.data, ChannelValueTypeSize(a->type) * mcx_array_num_elements(a));
         }
         break;
     case CHANNEL_UNKNOWN:
@@ -901,7 +901,7 @@ ChannelValue * ChannelValueNewArray(size_t numDims, size_t dims[], ChannelType *
     ChannelValueInit(value, ChannelTypeArray(type, numDims, dims));
 
     if (value->value.a.data && data) {
-        memcpy(value->value.a.data, data, ChannelValueTypeSize(type) * array_num_elements(&value->value.a));
+        memcpy(value->value.a.data, data, ChannelValueTypeSize(type) * mcx_array_num_elements(&value->value.a));
     }
 
     return value;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index a919268..c91a04b 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -100,12 +100,12 @@ typedef struct {
     size_t * dims;
     ChannelType * type;
     void * data;
-} array;
+} mcx_array;
 
-McxStatus array_init(array * a, size_t numDims, size_t * dims, ChannelType * type);
-void array_destroy(array * a);
-int array_dims_match(array * a, array * b);
-size_t array_num_elements(array * a);
+McxStatus mcx_array_init(mcx_array * a, size_t numDims, size_t * dims, ChannelType * type);
+void mcx_array_destroy(mcx_array * a);
+int mcx_array_dims_match(mcx_array * a, mcx_array * b);
+size_t mcx_array_num_elements(mcx_array * a);
 
 // TODO: change concrete types to McxDouble, McxInteger, etc
 union ChannelValueData {
@@ -114,7 +114,7 @@ union ChannelValueData {
     int i;
     char * s;
     binary_string b;
-    array a;
+    mcx_array a;
 };
 
 struct ChannelValue {
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index af8a5bc..7701a95 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -249,7 +249,7 @@ static McxStatus Fmu2ValueGetVariableStart(fmi2_base_type_enu_t t, fmi2_import_v
     return RETURN_OK;
 }
 
-static McxStatus Fmu2ValueGetArrayVariableStart(fmi2_base_type_enu_t t, fmi2_import_variable_t * var, array * a, size_t i) {
+static McxStatus Fmu2ValueGetArrayVariableStart(fmi2_base_type_enu_t t, fmi2_import_variable_t * var, mcx_array * a, size_t i) {
 
     switch (t) {
     case fmi2_base_type_real:
@@ -350,7 +350,7 @@ static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData
             n *= data->data.array.dims[i];
         }
 
-        array * a = (array *) ChannelValueReference(&v->val);
+        mcx_array * a = (mcx_array *) ChannelValueReference(&v->val);
 
         for (i = 0; i < n; i++) {
             if (RETURN_OK != Fmu2ValueGetArrayVariableStart(t, data->data.array.values[i], a, i)) {
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 925560b..e114158 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -743,9 +743,9 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     case CHANNEL_ARRAY:
     {
         fmi2_value_reference_t * vrs = fmuVal->data->vr.array.values;
-        array * a = (array *) ChannelValueReference(&fmuVal->val);
+        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
 
-        size_t num = array_num_elements(a);
+        size_t num = mcx_array_num_elements(a);
         void * vals = a->data;
 
         if (ChannelTypeEq(a->type, &ChannelTypeDouble)) {
@@ -878,9 +878,9 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     case CHANNEL_ARRAY:
     {
         fmi2_value_reference_t * vrs = fmuVal->data->vr.array.values;
-        array * a = (array *) ChannelValueReference(&fmuVal->val);
+        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
 
-        size_t num = array_num_elements(a);
+        size_t num = mcx_array_num_elements(a);
         void * vals = a->data;
 
         if (ChannelTypeEq(a->type, &ChannelTypeDouble)) {

From 378e3b6343d35aaf36d365270a1b2c08cb108c8a Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Fri, 10 Sep 2021 07:33:19 +0200
Subject: [PATCH 047/166] Move mcx_copy to util/stdlib

---
 src/core/channels/ChannelValue.c | 11 -----------
 src/core/channels/ChannelValue.h |  2 --
 src/util/common/stdlib.c         | 11 +++++++++++
 src/util/stdlib.h                |  2 ++
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 26e5927..794e606 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -15,17 +15,6 @@
 extern "C" {
 #endif /* __cplusplus */
 
-void * mcx_copy(void * object, size_t size) {
-    void * copy = mcx_malloc(size);
-    if (!copy) {
-        return NULL;
-    }
-
-    memcpy(copy, object, size);
-
-    return copy;
-}
-
 ChannelType ChannelTypeUnknown = { CHANNEL_UNKNOWN, NULL};
 ChannelType ChannelTypeInteger = { CHANNEL_INTEGER, NULL};
 ChannelType ChannelTypeDouble = { CHANNEL_DOUBLE, NULL};
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index c91a04b..72501b0 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -18,8 +18,6 @@
 extern "C" {
 #endif /* __cplusplus */
 
-void * mcx_copy(void * object, size_t size);
-
 char * CreateIndexedName(const char * name, unsigned i);
 
 // possible types of values that can be put on channels
diff --git a/src/util/common/stdlib.c b/src/util/common/stdlib.c
index cfa25b8..3109219 100644
--- a/src/util/common/stdlib.c
+++ b/src/util/common/stdlib.c
@@ -20,6 +20,17 @@ extern "C" {
 #endif /* __cplusplus */
 
 
+void * mcx_copy(void * object, size_t size) {
+    void * copy = mcx_malloc(size);
+    if (!copy) {
+        return NULL;
+    }
+
+    memcpy(copy, object, size);
+
+    return copy;
+}
+
 size_t mcx_filter(void * dst, void * base, size_t nmemb, size_t size, int (*pred)(const void *, void *), void * arg) {
     size_t i;
     size_t j = 0;
diff --git a/src/util/stdlib.h b/src/util/stdlib.h
index 52332c2..2dd3470 100644
--- a/src/util/stdlib.h
+++ b/src/util/stdlib.h
@@ -18,6 +18,8 @@ extern "C" {
 #endif /* __cplusplus */
 
 
+void * mcx_copy(void * object, size_t size);
+
 /**
  * Sorts the given array in-place using quicksort.
  *

From a9cccb77237bbc108dc585550e09d312c573a6a2 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Fri, 10 Sep 2021 07:45:46 +0200
Subject: [PATCH 048/166] value: Cleanup ChannelValueToString

---
 src/core/channels/ChannelValue.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 794e606..0d1e4fb 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -345,7 +345,11 @@ char * ChannelValueToString(ChannelValue * value) {
         }
         break;
     case CHANNEL_ARRAY:{
+        size_t i = 0;
+        size_t n = 0;
+
         size_t (*fmt)(char * buffer, void * value, size_t i);
+
         if (ChannelTypeEq(ChannelTypeArrayInner(value->type), &ChannelTypeDouble)) {
             fmt = ChannelValueDataDoubleToBuffer;
         } else if (ChannelTypeEq(ChannelTypeArrayInner(value->type), &ChannelTypeInteger)) {
@@ -356,10 +360,6 @@ char * ChannelValueToString(ChannelValue * value) {
             return NULL;
         }
 
-        const char * doubleFmt = "% *.*E";
-
-        // TODO:
-
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         length *= mcx_array_num_elements(&value->value.a);
         buffer = (char *) mcx_malloc(sizeof(char) * length);
@@ -367,9 +367,6 @@ char * ChannelValueToString(ChannelValue * value) {
             return NULL;
         }
 
-        size_t i = 0;
-        size_t n = 0;
-
         if (mcx_array_num_elements(&value->value.a) > 0) {
             n += fmt(buffer + n, value->value.a.data, 0);
             for (i = 1; i < mcx_array_num_elements(&value->value.a); i++) {

From d7f36b3281db96328f2a7947607dd883d42cde45 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 13 Sep 2021 09:43:39 +0200
Subject: [PATCH 049/166] value: Remove obsolete TODOs

---
 src/core/channels/ChannelValue.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 0d1e4fb..d9ac3cf 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -453,8 +453,6 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
     case CHANNEL_ARRAY: {
     const char * doubleFmt = "% *.*E";
 
-        // TODO:
-
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         if (len < length) {
             mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
@@ -526,7 +524,7 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType * type) {
 }
 
 McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType * type, const void * reference) {
-    if (!reference) { return RETURN_OK; } // TODO: change to ERROR
+    if (!reference) { return RETURN_OK; }
 
     switch (type->con) {
     case CHANNEL_DOUBLE:
@@ -688,7 +686,6 @@ McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
     return RETURN_OK;
 }
 
-// TODO: invalid size should be (-1)
 #ifdef __cplusplus
 size_t ChannelValueTypeSize(ChannelType * type) {
     switch (type->con) {

From 9bc123773df95a44285414c969f17b21e11b62a4 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 14 Sep 2021 07:55:47 +0200
Subject: [PATCH 050/166] fmu: Add defaults in actuation switch statement

---
 src/fmu/common_fmu2.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index e114158..0602ecd 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -9,6 +9,7 @@
  ********************************************************************************/
 
 #include "fmu/common_fmu2.h"
+#include "core/channels/ChannelValue.h"
 #include "fmu/common_fmu.h" /* for jm callbacks */
 
 #include "fmu/Fmu2Value.h"

From e4227e475b18924154f12a4072fb7cbe6e8d80c7 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 20 Sep 2021 06:54:05 +0200
Subject: [PATCH 051/166] Fix binary channel initialization

---
 src/core/channels/Channel.c      | 10 +++++++---
 src/core/channels/ChannelValue.c |  5 ++---
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index cbb4ceb..135daad 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -134,9 +134,13 @@ static McxStatus ChannelInSetReference(ChannelIn * in, void * reference, Channel
             mcx_log(LOG_ERROR, "Port %s: Set inport reference: Port not set up", ChannelInfoGetLogName(info));
             return RETURN_ERROR;
         }
-        if (!ChannelTypeMatch(info->type, type)) {
-            mcx_log(LOG_ERROR, "Port %s: Set inport reference: Mismatching types", ChannelInfoGetLogName(info));
-            return RETURN_ERROR;
+        if (!ChannelTypeEq(info->type, type)) {
+            if (ChannelInfoIsBinary(info) && ChannelTypeIsBinary(type)) {
+                // ok
+            } else {
+                mcx_log(LOG_ERROR, "Port %s: Set inport reference: Mismatching types", ChannelInfoGetLogName(info));
+                return RETURN_ERROR;
+            }
         }
     }
 
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index d9ac3cf..50996c2 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -160,8 +160,6 @@ int ChannelTypeEq(ChannelType * a, ChannelType * b) {
             }
         }
         return 1;
-    } else if ((a->con == CHANNEL_BINARY || a->con == CHANNEL_BINARY_REFERENCE) &&
-        (b->con == CHANNEL_BINARY || b->con == CHANNEL_BINARY_REFERENCE)) {
     } else {
         return a->con == b->con;
     }
@@ -744,8 +742,9 @@ const char * ChannelTypeToString(ChannelType * type) {
     case CHANNEL_STRING:
         return "String";
     case CHANNEL_BINARY:
-    case CHANNEL_BINARY_REFERENCE:
         return "Binary";
+    case CHANNEL_BINARY_REFERENCE:
+        return "BinaryReference";
     case CHANNEL_ARRAY:
         return "Array";
     default:

From 2677d063cf1c24ce2828ba41f3d6a44fc74a8352 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 20 Sep 2021 13:39:31 +0200
Subject: [PATCH 052/166] values: Fix printing of binary values

---
 src/core/channels/ChannelValue.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 50996c2..7df70b3 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -338,7 +338,13 @@ char * ChannelValueToString(ChannelValue * value) {
             size_t i = 0;
 
             for (i = 0; i < value->value.b.len; i++) {
-                sprintf(buffer + (4 * i), "\\x%02x", value->value.b.data[i]);
+                // specifier: x (hex integer) -----+
+                // length: 2 (unsigned char) -----+|
+                // width: 2 --------------------+ ||
+                // flag: 0-padded -------------+| ||
+                //                             || ||
+                // string literal "\x" ------+ || ||
+                sprintf(buffer + (4 * i), "\\x%02hhx", value->value.b.data[i]);
             }
         }
         break;

From d39476c944572145818cb777ecab4f6ffa2acca5 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Mon, 20 Sep 2021 13:40:14 +0200
Subject: [PATCH 053/166] channel: Store type of registered inport reference

This avoids mismatches between `ChannelTypeBinary` and
`ChannelTypeBinaryReference`.
---
 src/core/channels/Channel.c      | 7 ++++++-
 src/core/channels/Channel_impl.h | 1 +
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 135daad..4d7688f 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -10,6 +10,7 @@
 
 #include "CentralParts.h"
 #include "core/Config.h"
+#include "core/channels/ChannelValue.h"
 #include "core/connections/Connection.h"
 #include "core/Conversion.h"
 
@@ -110,6 +111,9 @@ static void ChannelInDataDestructor(ChannelInData * data) {
     if (data->rangeConversion) {
         object_destroy(data->rangeConversion);
     }
+    if (data->type) {
+        ChannelTypeDestructor(data->type);
+    }
 }
 
 OBJECT_CLASS(ChannelInData, Object);
@@ -145,6 +149,7 @@ static McxStatus ChannelInSetReference(ChannelIn * in, void * reference, Channel
     }
 
     in->data->reference = reference;
+    in->data->type = ChannelTypeClone(type);
 
     return RETURN_OK;
 }
@@ -253,7 +258,7 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         MCX_DEBUG_LOG("[%f] CH IN  (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, * (double *) channel->GetValueReference(channel));
     }
 
-    if (RETURN_OK != ChannelValueDataSetFromReference(in->data->reference, info->type, channel->GetValueReference(channel))) {
+    if (RETURN_OK != ChannelValueDataSetFromReference(in->data->reference, in->data->type, channel->GetValueReference(channel))) {
         return RETURN_ERROR;
     }
 
diff --git a/src/core/channels/Channel_impl.h b/src/core/channels/Channel_impl.h
index af2a837..83c0133 100644
--- a/src/core/channels/Channel_impl.h
+++ b/src/core/channels/Channel_impl.h
@@ -44,6 +44,7 @@ typedef struct ChannelInData {
     int isDiscrete;
 
     void * reference;
+    ChannelType * type;
 } ChannelInData;
 
 // ----------------------------------------------------------------------

From 94c171d20017f64a7b4d7136400e6970037e61c9 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Tue, 14 Sep 2021 07:37:52 +0200
Subject: [PATCH 054/166] fmu: Get start value for binary channels

---
 src/fmu/Fmu2Value.c | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index 7701a95..3cff407 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -358,19 +358,15 @@ static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData
             }
         }
     } else if (v->data->type == FMU2_VALUE_BINARY_OSI) {
-        return RETURN_OK;
+        ChannelValueInit(&v->val, &ChannelTypeBinary);
 
-        // TODO: Setting the initial value causes some memory errors.
-
-        // ChannelValueInit(&v->val, &ChannelTypeBinary);
-
-        // if (RETURN_OK != Fmu2ValueGetBinaryVariableStart(
-        //         data->data.binary.hi,
-        //         data->data.binary.lo,
-        //         data->data.binary.size,
-        //         &v->val)) {
-        //     return RETURN_ERROR;
-        // }
+        if (RETURN_OK != Fmu2ValueGetBinaryVariableStart(
+                data->data.binary.hi,
+                data->data.binary.lo,
+                data->data.binary.size,
+                &v->val)) {
+            return RETURN_ERROR;
+        }
 
 
     } else {

From dd3324fdeccb55cc547b52fbb8fe6516181502c2 Mon Sep 17 00:00:00 2001
From: Herwig Stuetz <herwig.stuetz@avl.com>
Date: Thu, 23 Sep 2021 08:43:04 +0200
Subject: [PATCH 055/166] monitoring: Add array support to Online Monitor

---
 src/core/Model.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/core/Model.c b/src/core/Model.c
index 8c9a786..35c8f6e 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -677,7 +677,6 @@ static void ModelDestructor(void * self) {
     object_destroy(model->initialSubModelGenerator);
     object_destroy(model->subModel);
     object_destroy(model->initialSubModel);
-
 }
 
 static McxStatus ModelReadComponents(void * self, ComponentsInput * input) {

From 863cf396bdc9e5aafbf5f921dc098738f5cb1b5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 12 May 2022 11:38:02 +0200
Subject: [PATCH 056/166] Fix: Correctly set up ChannelInfo

---
 src/core/Databus.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 67dca95..972570d 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -98,7 +98,7 @@ static ChannelInfo * DatabusReadPortInput(PortInput * input) {
 
         size_t dims[1] = { endIdx - startIdx + 1 };
 
-        if (RETURN_OK != ChannelInfoInit(info,
+        if (RETURN_OK != ChannelInfoSetup(info,
                                          vectorPortInput->name,
                                          vectorPortInput->nameInModel,
                                          vectorPortInput->description,

From 7683fc4e2fa3005fa6efc77d52a299e4cd634f3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 12 May 2022 11:42:14 +0200
Subject: [PATCH 057/166] Fix: Vector does not have PushBackNamed

---
 src/core/Databus.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 972570d..ceddc00 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -310,7 +310,7 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
             mcx_log(LOG_DEBUG, "    Port: \"%s\"", name);
         }
 
-        if (RETURN_OK != dbInfos->PushBack(dbInfos, (Object *) object_strong_reference(info), name)) {
+        if (RETURN_OK != dbInfos->PushBack(dbInfos, info)) {
             mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %d", i);
             return RETURN_ERROR;
         }

From d2b80fb420e36422f30f9a4958664cfb9d4c961e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 12 May 2022 13:45:12 +0200
Subject: [PATCH 058/166] Fix: Pass the correct pointer value

---
 src/core/Databus.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index ceddc00..746a71c 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -168,10 +168,10 @@ static ChannelInfo * DatabusReadPortInput(PortInput * input) {
         ChannelInfoSetID(info, scalarPortInput->id);
         ChannelInfoSetType(info, scalarPortInput->type);
 
-        if (!ChannelInfoIsBinary(&info)) {
-            ChannelInfoSetUnit(&info, scalarPortInput->unit);
+        if (!ChannelInfoIsBinary(info)) {
+            ChannelInfoSetUnit(info, scalarPortInput->unit);
         } else {
-            ChannelInfoSetUnit(&info, "-");
+            ChannelInfoSetUnit(info, "-");
         }
 
         ChannelType * expectedType = info->type;

From 362530329c57aa25e6581fce89a3bb712fb30aee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 17 Sep 2021 08:24:52 +0200
Subject: [PATCH 059/166] Make FilterFactory arguments explicit

---
 src/core/connections/Connection.c         | 89 ++++++++++-------------
 src/core/connections/Connection.h         | 11 ++-
 src/core/connections/FilteredConnection.c | 15 +++-
 3 files changed, 64 insertions(+), 51 deletions(-)

diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 67ec793..0ac45af 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -127,9 +127,7 @@ McxStatus MakeOneConnection(ConnectionInfo * info, InterExtrapolatingType isInte
     return RETURN_OK;
 }
 
-static void LogStepRatios(double sourceStep, double targetStep, double synchStep, ConnectionInfo * info) {
-    char * connString = ConnectionInfoConnectionString(info);
-
+static void LogStepRatios(double sourceStep, double targetStep, double synchStep, const char * connString) {
     if (sourceStep <= synchStep && targetStep <= synchStep) {
         MCX_DEBUG_LOG("CONN %s: source <= synch && target <= synch", connString);
     } else if (sourceStep <= synchStep && targetStep > synchStep) {
@@ -139,18 +137,13 @@ static void LogStepRatios(double sourceStep, double targetStep, double synchStep
     } else {
         MCX_DEBUG_LOG("CONN %s: source > synch && target > synch", connString);
     }
-
-    mcx_free(connString);
 }
 
 static int ComponentMightNotRespectStepSize(Component * comp) {
     return FALSE;
 }
 
-static size_t DetermineFilterBufferSize(ConnectionInfo * info) {
-    Component * source = info->sourceComponent;
-    Component * target = info->targetComponent;
-
+static size_t DetermineFilterBufferSize(Component * source, Component * target, const char * connString) {
     Model * model = source->GetModel(source);
     Task * task = model->GetTask(model);
 
@@ -173,10 +166,8 @@ static size_t DetermineFilterBufferSize(ConnectionInfo * info) {
     buffSize += model->config->interpolationBuffSizeSafetyExt;
 
     if (buffSize > model->config->interpolationBuffSizeLimit) {
-        char * connString = ConnectionInfoConnectionString(info);
         mcx_log(LOG_WARNING, "%s: buffer limit exceeded (%zu > &zu). Limit can be changed via MC_INTERPOLATION_BUFFER_SIZE_LIMIT.",
                 connString, buffSize, model->config->interpolationBuffSizeLimit);
-        mcx_free(connString);
 
         buffSize = model->config->interpolationBuffSizeLimit;
     }
@@ -184,12 +175,9 @@ static size_t DetermineFilterBufferSize(ConnectionInfo * info) {
     return buffSize;
 }
 
-static size_t MemoryFilterHistorySize(ConnectionInfo * info, int extDegree) {
+static size_t MemoryFilterHistorySize(Component * sourceComp, Component * targetComp, int extDegree, const char * connString) {
     size_t size = 0;
 
-    Component * sourceComp = info->sourceComponent;
-    Component * targetComp = info->targetComponent;
-
     Model * model = sourceComp->GetModel(sourceComp);
     Task * task = model->GetTask(model);
 
@@ -929,11 +917,9 @@ static size_t MemoryFilterHistorySize(ConnectionInfo * info, int extDegree) {
     }
 
     if (size + model->config->memFilterHistoryExtra > limit) {
-        char * connString = ConnectionInfoConnectionString(info);
         mcx_log(LOG_WARNING, "%s: history size limit exceeded (%zu > &zu). Limit can be changed via MC_MEM_FILTER_HISTORY_LIMIT. "
                              "Disabling memory filter",
                 connString, size + model->config->memFilterHistoryExtra, limit);
-        mcx_free(connString);
 
         return 0;
     }
@@ -963,46 +949,51 @@ static MemoryFilter * SetMemoryFilter(int reverseSearch, ChannelType * sourceTyp
     return filter;
 }
 
-ChannelFilter * FilterFactory(Connection * connection) {
+ChannelFilter * FilterFactory(ConnectionState * state,
+                              InterExtrapolationType extrapolation_type,
+                              InterExtrapolationParams * extrapolation_params,
+                              ChannelType * channel_type,
+                              InterExtrapolatingType inter_extrapolating_type,
+                              int is_decoupled,
+                              Component * sourceComp,
+                              Component * targetComp,
+                              const char * connString) {
     ChannelFilter * filter = NULL;
     McxStatus retVal;
-    ConnectionInfo * info = connection->GetInfo(connection);
-
-    InterExtrapolationType extrapolType = info->interExtrapolationType;
-    InterExtrapolationParams * params = &info->interExtrapolationParams;
 
-    Component * sourceComp = info->sourceComponent;
     Model * model = sourceComp->GetModel(sourceComp);
     Task * task = model->GetTask(model);
     int useInputsAtEndTime = task->useInputsAtEndTime;
 
-    if (ChannelTypeEq(ConnectionInfoGetType(info), &ChannelTypeDouble)) {
-        if (!(INTERVAL_COUPLING == params->interpolationInterval && INTERVAL_SYNCHRONIZATION == params->extrapolationInterval)) {
+    if (ChannelTypeEq(channel_type, &ChannelTypeDouble)) {
+        if (!(INTERVAL_COUPLING == extrapolation_params->interpolationInterval &&
+              INTERVAL_SYNCHRONIZATION == extrapolation_params->extrapolationInterval))
+        {
             mcx_log(LOG_WARNING, "The use of inter/extrapolation interval settings for double is not supported");
         }
-        if (extrapolType == INTEREXTRAPOLATION_POLYNOMIAL) {
+        if (extrapolation_type == INTEREXTRAPOLATION_POLYNOMIAL) {
 
-            InterExtrapolatingType isInterExtrapol = info->isInterExtrapolating;
-            if (INTERPOLATING == isInterExtrapol && ConnectionInfoIsDecoupled(info)) {
-                isInterExtrapol = INTEREXTRAPOLATING;
+            if (INTERPOLATING == inter_extrapolating_type && is_decoupled) {
+                inter_extrapolating_type = INTEREXTRAPOLATING;
             }
 
-            int degree = (INTERPOLATING == isInterExtrapol) ? params->interpolationOrder : params->extrapolationOrder;
+            int degree = (INTERPOLATING == inter_extrapolating_type) ? extrapolation_params->interpolationOrder :
+                                                                       extrapolation_params->extrapolationOrder;
 
-            if (EXTRAPOLATING == isInterExtrapol || INTEREXTRAPOLATING == isInterExtrapol) {
-                    size_t memFilterHist = MemoryFilterHistorySize(info, params->extrapolationOrder);
+            if (EXTRAPOLATING == inter_extrapolating_type || INTEREXTRAPOLATING == inter_extrapolating_type) {
+                    size_t memFilterHist = MemoryFilterHistorySize(sourceComp, targetComp, extrapolation_params->extrapolationOrder, connString);
                     if (0 != memFilterHist) {
-                        filter = (ChannelFilter *) SetMemoryFilter(useInputsAtEndTime, ConnectionInfoGetType(info), memFilterHist);
+                        filter = (ChannelFilter *) SetMemoryFilter(useInputsAtEndTime, channel_type, memFilterHist);
                         if (!filter) {
                             return NULL;
                         }
-                    } else if (INTEREXTRAPOLATING == isInterExtrapol) {
+                    } else if (INTEREXTRAPOLATING == inter_extrapolating_type) {
                         IntExtFilter * intExtFilter = (IntExtFilter *)object_create(IntExtFilter);
                         filter = (ChannelFilter *)intExtFilter;
                         mcx_log(LOG_DEBUG, "    Setting up dynamic filter. (%p)", filter);
-                        mcx_log(LOG_DEBUG, "    Interpolation order: %d, extrapolation order: %d", params->interpolationOrder, params->extrapolationOrder);
-                        size_t buffSize = DetermineFilterBufferSize(info);
-                        retVal = intExtFilter->Setup(intExtFilter, params->extrapolationOrder, params->interpolationOrder, buffSize);
+                        mcx_log(LOG_DEBUG, "    Interpolation order: %d, extrapolation order: %d", extrapolation_params->interpolationOrder, extrapolation_params->extrapolationOrder);
+                        size_t buffSize = DetermineFilterBufferSize(sourceComp, targetComp, connString);
+                        retVal = intExtFilter->Setup(intExtFilter, extrapolation_params->extrapolationOrder, extrapolation_params->interpolationOrder, buffSize);
                         if (RETURN_OK != retVal) {
                             return NULL;
                         }
@@ -1017,9 +1008,9 @@ ChannelFilter * FilterFactory(Connection * connection) {
                         }
                     }
             } else {
-                size_t memFilterHist = MemoryFilterHistorySize(info, degree);
+                size_t memFilterHist = MemoryFilterHistorySize(sourceComp, targetComp, degree, connString);
                 if (0 != memFilterHist) {
-                    filter = (ChannelFilter *) SetMemoryFilter(useInputsAtEndTime, ConnectionInfoGetType(info), memFilterHist);
+                    filter = (ChannelFilter *) SetMemoryFilter(useInputsAtEndTime, channel_type, memFilterHist);
                     if (!filter) {
                         return NULL;
                     }
@@ -1028,7 +1019,7 @@ ChannelFilter * FilterFactory(Connection * connection) {
                     filter = (ChannelFilter*)intFilter;
                     mcx_log(LOG_DEBUG, "    Setting up coupling step interpolation filter. (%p)", filter);
                     mcx_log(LOG_DEBUG, "    Interpolation order: %d", degree);
-                    size_t buffSize = DetermineFilterBufferSize(info);
+                    size_t buffSize = DetermineFilterBufferSize(sourceComp, targetComp, connString);
                     retVal = intFilter->Setup(intFilter, degree, buffSize);
                     if (RETURN_OK != retVal) {
                         mcx_log(LOG_ERROR, "Connection: Filter: Could not setup");
@@ -1045,28 +1036,28 @@ ChannelFilter * FilterFactory(Connection * connection) {
     } else {
         DiscreteFilter * discreteFilter = NULL;
 
-        if (!(0 == params->extrapolationOrder &&
-              0 == params->interpolationOrder &&
-              INTERVAL_COUPLING == params->interpolationInterval &&
-              INTERVAL_SYNCHRONIZATION == params->extrapolationInterval
+        if (!(0 == extrapolation_params->extrapolationOrder &&
+              0 == extrapolation_params->interpolationOrder &&
+              INTERVAL_COUPLING == extrapolation_params->interpolationInterval &&
+              INTERVAL_SYNCHRONIZATION == extrapolation_params->extrapolationInterval
         )) {
             mcx_log(LOG_WARNING, "Invalid inter/extrapolation settings for non-double connection detected");
         }
         mcx_log(LOG_DEBUG, "Using constant synchronization step extrapolation for non-double connection");
 
         discreteFilter = (DiscreteFilter *) object_create(DiscreteFilter);
-        discreteFilter->Setup(discreteFilter, ConnectionInfoGetType(info));
+        discreteFilter->Setup(discreteFilter, channel_type);
 
 
         filter = (ChannelFilter *) discreteFilter;
     }
 
-    if (NULL == filter && ChannelTypeEq(ConnectionInfoGetType(info), &ChannelTypeDouble)) {
+    if (NULL == filter && ChannelTypeEq(channel_type, &ChannelTypeDouble)) {
         // TODO: add a check to avoid filters for non-multirate cases
 
-        size_t memFilterHist = MemoryFilterHistorySize(info, 0);
+        size_t memFilterHist = MemoryFilterHistorySize(sourceComp, targetComp, 0, connString);
         if (0 != memFilterHist) {
-            filter = (ChannelFilter *) SetMemoryFilter(useInputsAtEndTime, ConnectionInfoGetType(info), memFilterHist);
+            filter = (ChannelFilter *) SetMemoryFilter(useInputsAtEndTime, channel_type, memFilterHist);
             if (!filter) {
                 return NULL;
             }
@@ -1077,7 +1068,7 @@ ChannelFilter * FilterFactory(Connection * connection) {
         }
     }
 
-    filter->AssignState(filter, &connection->state_);
+    filter->AssignState(filter, state);
 
     return filter;
 }
diff --git a/src/core/connections/Connection.h b/src/core/connections/Connection.h
index 648ed86..94d720f 100644
--- a/src/core/connections/Connection.h
+++ b/src/core/connections/Connection.h
@@ -211,7 +211,16 @@ struct Connection {
 // Common Functionality for Subclasses
 McxStatus ConnectionSetup(Connection * connection, struct ChannelOut * out, struct ChannelIn * in, ConnectionInfo * info);
 
-struct ChannelFilter * FilterFactory(Connection * connection);
+struct ChannelFilter *FilterFactory(ConnectionState *state,
+                                    InterExtrapolationType extrapolation_type,
+                                    InterExtrapolationParams *extrapolation_params,
+                                    ChannelType *channel_type,
+                                    InterExtrapolatingType inter_extrapolating_type,
+                                    int is_decoupled,
+                                    Component * sourceComp,
+                                    Component * targetComp,
+                                    const char * connString);
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index c8fd206..a4b069e 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -192,7 +192,20 @@ static McxStatus AddFilter(Connection * connection) {
     if (filteredConnection->data->filter) {
         mcx_log(LOG_DEBUG, "Connection: Not inserting filter");
     } else {
-        filteredConnection->data->filter = FilterFactory(connection);
+        ConnectionInfo *info = connection->GetInfo(connection);
+        const char * connString = ConnectionInfoConnectionString(info);
+
+        filteredConnection->data->filter = FilterFactory(&connection->state_,
+                                                         info->interExtrapolationType,
+                                                         &info->interExtrapolationParams,
+                                                         ConnectionInfoGetType(info),
+                                                         info->isInterExtrapolating,
+                                                         ConnectionInfoIsDecoupled(info),
+                                                         info->sourceComponent,
+                                                         info->targetComponent,
+                                                         connString);
+        mcx_free(connString);
+
         if (NULL == filteredConnection->data->filter) {
             mcx_log(LOG_DEBUG, "Connection: No Filter created");
             retVal = RETURN_ERROR;

From 6e7077fd0f09113f3658c11b5f6fc7d9c68a57d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 27 Sep 2021 12:57:26 +0200
Subject: [PATCH 060/166] Create a separate filter for every array element

---
 src/core/channels/ChannelValue.c              | 159 ++++++++------
 src/core/channels/ChannelValue.h              |   2 +
 src/core/connections/FilteredConnection.c     | 202 ++++++++++++++----
 src/core/connections/FilteredConnection.h     |   2 +-
 .../connections/FilteredConnection_impl.h     |   3 +-
 5 files changed, 260 insertions(+), 108 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 7df70b3..12a9fd0 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -222,6 +222,40 @@ size_t mcx_array_num_elements(mcx_array * a) {
     return n;
 }
 
+McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element) {
+    size_t num_elems = mcx_array_num_elements(a);
+
+    if (idx >= num_elems) {
+        mcx_log(LOG_ERROR, "mcx_array_get_elem: Array index out of range (idx: %d, num_elems: %d)", idx, num_elems);
+        return RETURN_ERROR;
+    }
+
+    switch (a->type->con) {
+        case CHANNEL_DOUBLE:
+            ChannelValueDataSetFromReference(element, a->type, ((double*)a->data) + idx);
+            break;
+        case CHANNEL_INTEGER:
+        case CHANNEL_BOOL:
+            ChannelValueDataSetFromReference(element, a->type, ((int *) a->data) + idx);
+            break;
+        case CHANNEL_STRING:
+            ChannelValueDataSetFromReference(element, a->type, ((char **) a->data) + idx);
+            break;
+        case CHANNEL_BINARY:
+        case CHANNEL_BINARY_REFERENCE:
+            ChannelValueDataSetFromReference(element, a->type, ((binary_string *) a->data) + idx);
+            break;
+        case CHANNEL_ARRAY:
+            ChannelValueDataSetFromReference(element, a->type, ((mcx_array *) a->data) + idx);
+            break;
+        default:
+            mcx_log(LOG_ERROR, "mcx_array_get_elem: Unknown array type");
+            return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
 void ChannelValueInit(ChannelValue * value, ChannelType * type) {
     value->type = type;
     ChannelValueDataInit(&value->value, type);
@@ -617,77 +651,82 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
     return RETURN_OK;
 }
 
-McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
-    switch (value->type->con) {
-    case CHANNEL_DOUBLE:
-        * (double *) reference = value->value.d;
-        break;
-    case CHANNEL_INTEGER:
-        * (int *) reference = value->value.i;
-        break;
-    case CHANNEL_BOOL:
-        * (int *) reference = value->value.i;
-        break;
-    case CHANNEL_STRING:
-        if (* (char **) reference) {
-            mcx_free(* (char **) reference);
-            * (char **) reference = NULL;
-        }
-        if (value->value.s) {
-            * (char **) reference = (char *) mcx_calloc(strlen(value->value.s) + 1, sizeof(char));
-            if (* (char **) reference) {
-                strncpy(* (char **) reference, value->value.s, strlen(value->value.s) + 1);
+McxStatus ChannelValueDataSetToReference(ChannelValueData * value, ChannelType * type, void * reference) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            *(double *) reference = value->d;
+            break;
+        case CHANNEL_INTEGER:
+            *(int *) reference = value->i;
+            break;
+        case CHANNEL_BOOL:
+            *(int *) reference = value->i;
+            break;
+        case CHANNEL_STRING:
+            if (*(char **) reference) {
+                mcx_free(*(char **) reference);
+                *(char **) reference = NULL;
             }
-        }
-        break;
-    case CHANNEL_BINARY:
-        if (NULL != reference && NULL != ((binary_string *) reference)->data) {
-            mcx_free(((binary_string *) reference)->data);
-            ((binary_string *) reference)->data = NULL;
-        }
-        if (value->value.b.data) {
-            ((binary_string *) reference)->len = value->value.b.len;
-            ((binary_string *) reference)->data = (char *) mcx_calloc(value->value.b.len, 1);
-            if (((binary_string *) reference)->data) {
-                memcpy(((binary_string *) reference)->data, value->value.b.data, value->value.b.len);
+            if (value->s) {
+                *(char **) reference = (char *) mcx_calloc(strlen(value->s) + 1, sizeof(char));
+                if (*(char **) reference) {
+                    strncpy(*(char **) reference, value->s, strlen(value->s) + 1);
+                }
             }
-        }
-        break;
-    case CHANNEL_BINARY_REFERENCE:
-        if (NULL != reference) {
-            ((binary_string *) reference)->len = value->value.b.len;
-            ((binary_string *) reference)->data = value->value.b.data;
-        }
-        break;
-    case CHANNEL_ARRAY:
-        if (NULL != reference) {
-            mcx_array * a = (mcx_array *) reference;
+            break;
+        case CHANNEL_BINARY:
+            if (NULL != reference && NULL != ((binary_string *) reference)->data) {
+                mcx_free(((binary_string *) reference)->data);
+                ((binary_string *) reference)->data = NULL;
+            }
+            if (value->b.data) {
+                ((binary_string *) reference)->len = value->b.len;
+                ((binary_string *) reference)->data = (char *) mcx_calloc(value->b.len, 1);
+                if (((binary_string *) reference)->data) {
+                    memcpy(((binary_string *) reference)->data, value->b.data, value->b.len);
+                }
+            }
+            break;
+        case CHANNEL_BINARY_REFERENCE:
+            if (NULL != reference) {
+                ((binary_string *) reference)->len = value->b.len;
+                ((binary_string *) reference)->data = value->b.data;
+            }
+            break;
+        case CHANNEL_ARRAY:
+            if (NULL != reference) {
+                mcx_array * a = (mcx_array *) reference;
+
+                // First Set fixes the dimensions
+                if (value->a.numDims && !a->numDims) {
+                    if (RETURN_OK != mcx_array_init(a, value->a.numDims, value->a.dims, value->a.type)) {
+                        return RETURN_ERROR;
+                    }
+                }
 
-            // First Set fixes the dimensions
-            if (value->value.a.numDims && !a->numDims) {
-                if (RETURN_OK != mcx_array_init(a, value->value.a.numDims, value->value.a.dims, value->value.a.type)) {
+                // Arrays do not support multiplexing (yet)
+                if (!mcx_array_dims_match(a, &value->a)) {
                     return RETURN_ERROR;
                 }
-            }
 
-            // Arrays do not support multiplexing (yet)
-            if (!mcx_array_dims_match(a, &value->value.a)) {
-                return RETURN_ERROR;
-            }
+                if (value->a.data == NULL || a->data == NULL) {
+                    return RETURN_ERROR;
+                }
 
-            if (value->value.a.data == NULL || a->data == NULL) {
-                return RETURN_ERROR;
+                memcpy(a->data, value->a.data, ChannelValueTypeSize(a->type) * mcx_array_num_elements(a));
             }
-
-            memcpy(a->data, value->value.a.data, ChannelValueTypeSize(a->type) * mcx_array_num_elements(a));
-        }
-        break;
-    case CHANNEL_UNKNOWN:
-    default:
-        break;
+            break;
+        case CHANNEL_UNKNOWN:
+        default:
+            break;
     }
 
     return RETURN_OK;
+
+}
+
+McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference) {
+    return ChannelValueDataSetToReference(&value->value, value->type, reference);
 }
 
 #ifdef __cplusplus
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 72501b0..142be36 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -104,6 +104,7 @@ McxStatus mcx_array_init(mcx_array * a, size_t numDims, size_t * dims, ChannelTy
 void mcx_array_destroy(mcx_array * a);
 int mcx_array_dims_match(mcx_array * a, mcx_array * b);
 size_t mcx_array_num_elements(mcx_array * a);
+McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 
 // TODO: change concrete types to McxDouble, McxInteger, etc
 union ChannelValueData {
@@ -133,6 +134,7 @@ void *      ChannelValueReference(ChannelValue * value);
 void ChannelValueDataDestructor(ChannelValueData * data, ChannelType * type);
 void ChannelValueDataInit(ChannelValueData * data, ChannelType * type);
 McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType * type, const void * reference);
+McxStatus ChannelValueDataSetToReference(ChannelValueData * value, ChannelType * type, void * reference);
 
 McxStatus ChannelValueSetFromReference(ChannelValue * value, const void * reference);
 McxStatus ChannelValueSetToReference(ChannelValue * value, void * reference);
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index a4b069e..2caa143 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -21,7 +21,8 @@ extern "C" {
 #endif /* __cplusplus */
 
 static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionData * data) {
-    data->filter = NULL;
+    data->filters = NULL;
+    data->numFilters = 0;
 
     ChannelValueInit(&data->store, ChannelTypeClone(&ChannelTypeUnknown));
 
@@ -30,7 +31,14 @@ static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionD
 
 static void FilteredConnectionDataDestructor(FilteredConnectionData * data) {
     ChannelValueDestructor(&data->store);
-    object_destroy(data->filter);
+
+    if (data->filters) {
+        size_t i = 0;
+        for (i = 0; i < data->numFilters; i++) {
+            object_destroy(data->filters[i]);
+        }
+        mcx_free(data->filters);
+    }
 }
 
 OBJECT_CLASS(FilteredConnectionData, Object);
@@ -51,7 +59,8 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     }
 
     // filter will be added after model is connected
-    filteredConnection->data->filter = NULL;
+    filteredConnection->data->filters = NULL;
+    filteredConnection->data->numFilters = 0;
 
     // value store
     ChannelValueInit(&filteredConnection->data->store, ChannelTypeClone(sourceInfo->type));
@@ -72,15 +81,18 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
 
 static McxStatus FilteredConnectionEnterCommunicationMode(Connection * connection, double time) {
     FilteredConnection * filteredConnection = (FilteredConnection *) connection;
-    ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection);
 
     McxStatus retVal = RETURN_OK;
+    size_t i = 0;
 
-    if (filter) {
-        if (filter->EnterCommunicationMode) {
-            retVal = filter->EnterCommunicationMode(filter, time);
-            if (RETURN_OK != retVal) {
-                return RETURN_ERROR;
+    for (i = 0; i < filteredConnection->data->numFilters; i++) {
+        ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection, i);
+        if (filter) {
+            if (filter->EnterCommunicationMode) {
+                retVal = filter->EnterCommunicationMode(filter, time);
+                if (RETURN_OK != retVal) {
+                    return RETURN_ERROR;
+                }
             }
         }
     }
@@ -93,15 +105,18 @@ static McxStatus FilteredConnectionEnterCouplingStepMode(Connection * connection
     , double communicationTimeStepSize, double sourceTimeStepSize, double targetTimeStepSize)
 {
     FilteredConnection * filteredConnection = (FilteredConnection *) connection;
-    ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection);
 
     McxStatus retVal = RETURN_OK;
+    size_t i = 0;
 
-    if (filter) {
-        if (filter->EnterCouplingStepMode) {
-            retVal = filter->EnterCouplingStepMode(filter, communicationTimeStepSize, sourceTimeStepSize, targetTimeStepSize);
-            if (RETURN_OK != retVal) {
-                return RETURN_ERROR;
+    for (i = 0; i < filteredConnection->data->numFilters; i++) {
+        ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection, i);
+        if (filter) {
+            if (filter->EnterCouplingStepMode) {
+                retVal = filter->EnterCouplingStepMode(filter, communicationTimeStepSize, sourceTimeStepSize, targetTimeStepSize);
+                if (RETURN_OK != retVal) {
+                    return RETURN_ERROR;
+                }
             }
         }
     }
@@ -110,8 +125,15 @@ static McxStatus FilteredConnectionEnterCouplingStepMode(Connection * connection
     return RETURN_OK;
 }
 
-static ChannelFilter * FilteredConnectionGetFilter(FilteredConnection * connection) {
-    return connection->data->filter;
+static ChannelFilter * FilteredConnectionGetFilter(FilteredConnection * connection, size_t idx) {
+    if (connection->data->filters && idx < connection->data->numFilters) {
+        return connection->data->filters[idx];
+    }
+    return NULL;
+}
+
+static size_t FilteredConnectionGetNumFilters(FilteredConnection *connection) {
+    return connection->data->numFilters;
 }
 
 static McxStatus FilteredConnectionSetResult(FilteredConnection * connection, const void * value) {
@@ -120,21 +142,37 @@ static McxStatus FilteredConnectionSetResult(FilteredConnection * connection, co
 
 static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInterval * time) {
     FilteredConnection * filteredConnection = (FilteredConnection *) connection;
-    ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection);
     Channel * channel = (Channel *) connection->GetSource(connection);
+    ChannelInfo * info = &channel->info;
 
 #ifdef MCX_DEBUG
     if (time->startTime < MCX_DEBUG_LOG_TIME) {
-        ChannelInfo * info = &channel->info;
         MCX_DEBUG_LOG("[%f] FCONN   (%s) UpdateFromInput", time->startTime, ChannelInfoGetName(info));
     }
 #endif
 
     // TODO: copy only sourceDimension slice
 
-    if (filter && time->startTime >= 0) {
-        ChannelValueData value = * (ChannelValueData *) channel->GetValueReference(channel);
-        filter->SetValue(filter, time->startTime, value);
+    if (ChannelTypeIsScalar(info->type)) {
+        ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection, 0);
+        if (filter && time->startTime >= 0) {
+            ChannelValueData value = *(ChannelValueData *) channel->GetValueReference(channel);
+            filter->SetValue(filter, time->startTime, value);
+        }
+    } else {
+        size_t i = 0;
+        ChannelValueData element;
+        ChannelValueDataInit(&element, ChannelTypeBaseType(info->type));
+
+        for (i = 0; i < FilteredConnectionGetNumFilters(filteredConnection); i++) {
+            ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection, i);
+
+            if (filter && time->startTime >= 0) {
+                ChannelValueData value = *(ChannelValueData *) channel->GetValueReference(channel);
+                mcx_array_get_elem(&value.a, i, &element);
+                filter->SetValue(filter, time->startTime, element);
+            }
+        }
     }
 }
 
@@ -144,11 +182,11 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
     ChannelFilter * filter = NULL;
 
     Channel * channel = (Channel *) connection->GetSource(connection);
+    ChannelInfo * info = &channel->info;
     ChannelOut * out  = (ChannelOut *) channel;
 
 #ifdef MCX_DEBUG
     if (time->startTime < MCX_DEBUG_LOG_TIME) {
-        ChannelInfo * info = &channel->info;
         MCX_DEBUG_LOG("[%f] FCONN   (%s) UpdateToOutput", time->startTime, ChannelInfoGetName(info));
     }
 #endif
@@ -167,15 +205,38 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
         }
     } else {
         // only filter if time is not negative (negative time means filter disabled)
-        if (filteredConnection->GetReadFilter(filteredConnection) && time->startTime >= 0) {
+        if (filteredConnection->GetReadFilter(filteredConnection, 0) && time->startTime >= 0) {
             ChannelValueData value = { 0 };
 
-            filter = filteredConnection->GetReadFilter(filteredConnection);
-            value = filter->GetValue(filter, time->startTime);
-
-            if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
-                mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
-                return RETURN_ERROR;
+            if (ChannelTypeIsScalar(info->type)) {
+                filter = filteredConnection->GetReadFilter(filteredConnection, 0);
+                value = filter->GetValue(filter, time->startTime);
+
+                if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
+                    mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
+                    return RETURN_ERROR;
+                }
+            } else {
+                size_t i = 0;
+                size_t numFilters = FilteredConnectionGetNumFilters(filteredConnection);
+                ChannelType * type = info->type;
+
+                mcx_array elements = {0};
+                mcx_array_init(&elements, type->ty.a.numDims, type->ty.a.dims, type->ty.a.inner);
+
+                char * dest = (char *) elements.data;
+                for (i = 0; i < numFilters; i++) {
+                    filter = filteredConnection->GetReadFilter(filteredConnection, i);
+                    value = filter->GetValue(filter, time->startTime);
+
+                    ChannelValueDataSetToReference(&value, ChannelTypeBaseType(type), (void *) dest);
+                    dest += ChannelValueTypeSize(ChannelTypeBaseType(type));
+                }
+
+                if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &elements)) {
+                    mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
+                    return RETURN_ERROR;
+                }
             }
         }
     }
@@ -189,30 +250,79 @@ static McxStatus AddFilter(Connection * connection) {
 
     McxStatus retVal = RETURN_OK;
 
-    if (filteredConnection->data->filter) {
+    if (filteredConnection->data->filters) {
         mcx_log(LOG_DEBUG, "Connection: Not inserting filter");
     } else {
-        ConnectionInfo *info = connection->GetInfo(connection);
+        ConnectionInfo * info = connection->GetInfo(connection);
         const char * connString = ConnectionInfoConnectionString(info);
+        ChannelDimension * dimension = info->sourceDimension;
 
-        filteredConnection->data->filter = FilterFactory(&connection->state_,
-                                                         info->interExtrapolationType,
-                                                         &info->interExtrapolationParams,
-                                                         ConnectionInfoGetType(info),
-                                                         info->isInterExtrapolating,
-                                                         ConnectionInfoIsDecoupled(info),
-                                                         info->sourceComponent,
-                                                         info->targetComponent,
-                                                         connString);
-        mcx_free(connString);
+        if (dimension) {    // array
+            size_t i = 0;
+
+            if (dimension->num > 1) {
+                mcx_log(LOG_ERROR, "Setting filters for multi-dimensional connections is not supported");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            filteredConnection->data->numFilters = dimension->endIdxs[0] - dimension->startIdxs[0] + 1;
+            filteredConnection->data->filters = (ChannelFilter **) mcx_calloc(filteredConnection->data->numFilters, sizeof(ChannelFilter*));
+            if (!filteredConnection->data->filters) {
+                mcx_log(LOG_ERROR, "Creating array filters failed: no memory");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            for (i = 0; i < filteredConnection->data->numFilters; i++) {
+                filteredConnection->data->filters[i] = FilterFactory(&connection->state_,
+                                                                     info->interExtrapolationType,
+                                                                     &info->interExtrapolationParams,
+                                                                     ChannelTypeBaseType(ConnectionInfoGetType(info)),
+                                                                     info->isInterExtrapolating,
+                                                                     ConnectionInfoIsDecoupled(info),
+                                                                     info->sourceComponent,
+                                                                     info->targetComponent,
+                                                                     connString);
+                if (NULL == filteredConnection->data->filters[i]) {
+                    mcx_log(LOG_DEBUG, "Connection: Array filter creation failed for index %d", i);
+                    retVal = RETURN_ERROR;
+                    goto cleanup;
+                }
+            }
+        } else {
+            filteredConnection->data->filters = (ChannelFilter **) mcx_calloc(1, sizeof(ChannelFilter *));
+            if (!filteredConnection->data->filters) {
+                mcx_log(LOG_ERROR, "Creating filter failed: no memory");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
 
-        if (NULL == filteredConnection->data->filter) {
-            mcx_log(LOG_DEBUG, "Connection: No Filter created");
-            retVal = RETURN_ERROR;
+            filteredConnection->data->numFilters = 1;
+            filteredConnection->data->filters[0] = FilterFactory(&connection->state_,
+                                                                 info->interExtrapolationType,
+                                                                 &info->interExtrapolationParams,
+                                                                 ConnectionInfoGetType(info),
+                                                                 info->isInterExtrapolating,
+                                                                 ConnectionInfoIsDecoupled(info),
+                                                                 info->sourceComponent,
+                                                                 info->targetComponent,
+                                                                 connString);
+            if (NULL == filteredConnection->data->filters[0]) {
+                mcx_log(LOG_DEBUG, "Connection: No Filter created");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+        }
+
+cleanup:
+        mcx_free(connString);
+        if (retVal != RETURN_OK) {
+            return retVal;
         }
     }
 
-    return retVal;
+    return RETURN_OK;
 }
 
 static void FilteredConnectionDestructor(FilteredConnection * filteredConnection) {
diff --git a/src/core/connections/FilteredConnection.h b/src/core/connections/FilteredConnection.h
index 00dc94a..01f0f4e 100644
--- a/src/core/connections/FilteredConnection.h
+++ b/src/core/connections/FilteredConnection.h
@@ -20,7 +20,7 @@ extern "C" {
 
 typedef struct FilteredConnection FilteredConnection;
 
-typedef struct ChannelFilter * (* fConnectionGetFilter)(FilteredConnection * connection);
+typedef struct ChannelFilter * (* fConnectionGetFilter)(FilteredConnection * connection, size_t idx);
 
 typedef McxStatus (* fFilteredConnectionSetResult)(FilteredConnection * connection, const void * value);
 
diff --git a/src/core/connections/FilteredConnection_impl.h b/src/core/connections/FilteredConnection_impl.h
index 09ab299..3a534d0 100644
--- a/src/core/connections/FilteredConnection_impl.h
+++ b/src/core/connections/FilteredConnection_impl.h
@@ -28,7 +28,8 @@ typedef struct FilteredConnectionData {
     // storage of the filtered value provided by the output channel
     ChannelValue store;
 
-    ChannelFilter * filter;
+    ChannelFilter ** filters;
+    size_t numFilters;
 
 } FilteredConnectionData;
 

From 0a9c099400b37071108ee1326eca635eeffb1fbc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 6 Oct 2021 13:56:52 +0200
Subject: [PATCH 061/166] Remove unused function

---
 src/core/Databus.c | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 746a71c..7db70c0 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -736,16 +736,6 @@ size_t DatabusInfoGetChannelNum(DatabusInfo * info) {
     return info->data->infos->Size(info->data->infos);
 }
 
-// Only returns SIZE_T_ERROR if info was NULL
-size_t DatabusInfoGetVectorChannelNum(DatabusInfo * info) {
-    if (!info) {
-        mcx_log(LOG_ERROR, "Ports: Get vector port number: Invalid structure");
-        return SIZE_T_ERROR;
-    }
-
-    return info->data->infos->Size(info->data->infos);
-}
-
 ChannelInfo * DatabusInfoGetChannel(DatabusInfo * info, size_t i) {
     if (!info) {
         mcx_log(LOG_ERROR, "Ports: Get port info: Invalid structure");

From 378e26bcf074c4d1e12f2ab114c371301c4ef94a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 12 Oct 2021 11:06:11 +0200
Subject: [PATCH 062/166] Add functions for calculating the number of in/out
 databus elements

When all channels are scalars, the functions behave the same way
as DatabusGetIn/OutChannelsNum. If some channels are array, they
will contribute to the results with the total number of their
elements.
---
 src/core/Databus.c | 26 ++++++++++++++++++++++++++
 src/core/Databus.h |  3 +++
 2 files changed, 29 insertions(+)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 7db70c0..b29083e 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -736,6 +736,24 @@ size_t DatabusInfoGetChannelNum(DatabusInfo * info) {
     return info->data->infos->Size(info->data->infos);
 }
 
+size_t DatabusInfoGetChannelElemNum(DatabusInfo * info) {
+    size_t numInfos = info->data->infos->Size(info->data->infos);
+    size_t i = 0;
+    size_t numElems = 0;
+
+    for (i = 0; i < numInfos; i++) {
+        ChannelInfo * chInfo = (ChannelInfo*)info->data->infos->At(info->data->infos, i);
+        if (chInfo->dimension) {
+            // array
+            numElems += ChannelDimensionNumElements(chInfo->dimension);
+        } else {
+            numElems += 1;
+        }
+    }
+
+    return numElems;
+}
+
 ChannelInfo * DatabusInfoGetChannel(DatabusInfo * info, size_t i) {
     if (!info) {
         mcx_log(LOG_ERROR, "Ports: Get port info: Invalid structure");
@@ -882,6 +900,14 @@ size_t DatabusGetRTFactorChannelsNum(Databus * db) {
     return DatabusInfoGetChannelNum(DatabusGetRTFactorInfo(db));
 }
 
+size_t DatabusGetOutChannelsElemNum(Databus * db) {
+    return DatabusInfoGetChannelElemNum(DatabusGetOutInfo(db));
+}
+
+size_t DatabusGetInChannelsElemNum(Databus * db) {
+    return DatabusInfoGetChannelElemNum(DatabusGetInInfo(db));
+}
+
 
 McxStatus DatabusSetOutReference(Databus * db, size_t channel, const void * reference, ChannelType * type) {
     ChannelOut * out = NULL;
diff --git a/src/core/Databus.h b/src/core/Databus.h
index d69a9ca..8ae0cfe 100644
--- a/src/core/Databus.h
+++ b/src/core/Databus.h
@@ -69,6 +69,9 @@ size_t DatabusGetInChannelsNum(struct Databus * db);
  */
 size_t DatabusGetLocalChannelsNum(struct Databus * db);
 
+size_t DatabusGetInChannelsElemNum(Databus * db);
+size_t DatabusGetOutChannelsElemNum(Databus * db);
+
 /**
  * \return The number of rtfactor channels of \a db or -1 if \a db is not initialized
  * correctly.

From 15b99662c342afebdb9df4c39cf4e9cf1a7ff227 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 12 Oct 2021 12:11:59 +0200
Subject: [PATCH 063/166] Pre-allocate memory for channel value data used by
 channel functions

---
 src/core/channels/Channel.c                    | 17 +++++++++++++----
 src/core/channels/ChannelValue.h               |  2 +-
 src/core/channels/Channel_impl.h               |  3 +++
 src/core/connections/FilteredConnection.c      | 12 +++++++++---
 src/core/connections/FilteredConnection_impl.h |  3 +++
 5 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 4d7688f..42fff71 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -468,6 +468,7 @@ static ChannelIn * ChannelInCreate(ChannelIn * in) {
 
 static ChannelOutData * ChannelOutDataCreate(ChannelOutData * data) {
     data->valueFunction = NULL;
+    ChannelValueInit(&data->valueFunctionRes, ChannelTypeClone(&ChannelTypeUnknown));
     data->rangeConversion = NULL;
     data->linearConversion = NULL;
 
@@ -499,6 +500,8 @@ static void ChannelOutDataDestructor(ChannelOutData * data) {
         object_destroy(conns->elements[i]);
     }
     object_destroy(data->connections);
+
+    ChannelValueDestructor(&data->valueFunctionRes);
 }
 
 OBJECT_CLASS(ChannelOutData, Object);
@@ -678,6 +681,9 @@ static McxStatus ChannelOutSetReferenceFunction(ChannelOut * out, const proc * r
     // Save channel procedure
     out->data->valueFunction = (const proc *) reference;
 
+    // Initialize (and allocate necessary memory)
+    ChannelValueInit(&out->data->valueFunctionRes, ChannelTypeClone(type));
+
     // Setup value reference to point to internal value
     channel->internalValue = ChannelValueReference(&channel->value);
 
@@ -716,17 +722,20 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
         if (out->GetFunction(out)) {
             // function value
             proc * p = (proc *) out->GetFunction(out);
-            ChannelValueData val = { 0 };
-            if (p->fn(time, p->env, &val) != 0) {
+            if (p->fn(time, p->env, &out->data->valueFunctionRes) != 0) {
                 mcx_log(LOG_ERROR, "Port %s: Update outport: Function failed", ChannelInfoGetLogName(info));
                 return RETURN_ERROR;
             }
 #ifdef MCX_DEBUG
             if (time->startTime < MCX_DEBUG_LOG_TIME) {
-                MCX_DEBUG_LOG("[%f] CH OUT (%s) (%f, %f)", time->startTime, ChannelInfoGetLogName(info), time->startTime, val.d);
+                MCX_DEBUG_LOG("[%f] CH OUT (%s) (%f, %f)",
+                              time->startTime,
+                              ChannelInfoGetLogName(info),
+                              time->startTime,
+                              out->data->valueFunctionRes.value.d);
             }
 #endif // MCX_DEBUG
-            if (RETURN_OK != ChannelValueSetFromReference(&channel->value, &val)) {
+            if (RETURN_OK != ChannelValueSetFromReference(&channel->value, ChannelValueReference(&out->data->valueFunctionRes))) {
                 return RETURN_ERROR;
             }
         } else {
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 142be36..34489b6 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -84,7 +84,7 @@ typedef union ChannelValueData ChannelValueData;
 typedef struct ChannelValue ChannelValue;
 
 typedef struct {
-    int (* fn)(TimeInterval * arg, void * env, ChannelValueData * res);
+    int (* fn)(TimeInterval * arg, void * env, ChannelValue * res);
     void * env;
 } proc;
 
diff --git a/src/core/channels/Channel_impl.h b/src/core/channels/Channel_impl.h
index 83c0133..8708cc6 100644
--- a/src/core/channels/Channel_impl.h
+++ b/src/core/channels/Channel_impl.h
@@ -57,6 +57,9 @@ typedef struct ChannelOutData {
     // Function pointer that provides the value of the channel when called
     const proc * valueFunction;
 
+    // Used to store results of channel-internal valueFunction calls
+    ChannelValue valueFunctionRes;
+
     // ----------------------------------------------------------------------
     // Conversion
 
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 2caa143..024fdad 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -24,6 +24,7 @@ static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionD
     data->filters = NULL;
     data->numFilters = 0;
 
+    ChannelValueInit(&data->fnResBuffer, ChannelTypeClone(&ChannelTypeUnknown));
     ChannelValueInit(&data->store, ChannelTypeClone(&ChannelTypeUnknown));
 
     return data;
@@ -31,6 +32,7 @@ static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionD
 
 static void FilteredConnectionDataDestructor(FilteredConnectionData * data) {
     ChannelValueDestructor(&data->store);
+    ChannelValueDestructor(&data->fnResBuffer);
 
     if (data->filters) {
         size_t i = 0;
@@ -68,6 +70,10 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     // value reference
     connection->value_ = ChannelValueReference(&filteredConnection->data->store);
 
+    // initialize the buffer for channel function calls
+    if (out->GetFunction(out)) {
+        ChannelValueInit(&filteredConnection->data->fnResBuffer, sourceInfo->type);
+    }
 
     // Connection::Setup()
     // this has to be done last as it connects the channels
@@ -193,13 +199,13 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
 
     if (out->GetFunction(out)) {
         proc * p = (proc *) out->GetFunction(out);
-        ChannelValueData value = { 0 };
 
-        if (p->fn(time, p->env, &value) != 0) {
+        if (p->fn(time, p->env, &filteredConnection->data->fnResBuffer) != 0) {
             mcx_log(LOG_ERROR, "FilteredConnection: Function failed");
             return RETURN_ERROR;
         }
-        if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &value)) {
+
+        if (RETURN_OK != filteredConnection->SetResult(filteredConnection, ChannelValueReference(&filteredConnection->data->fnResBuffer))) {
             mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
             return RETURN_ERROR;
         }
diff --git a/src/core/connections/FilteredConnection_impl.h b/src/core/connections/FilteredConnection_impl.h
index 3a534d0..c586c4c 100644
--- a/src/core/connections/FilteredConnection_impl.h
+++ b/src/core/connections/FilteredConnection_impl.h
@@ -28,6 +28,9 @@ typedef struct FilteredConnectionData {
     // storage of the filtered value provided by the output channel
     ChannelValue store;
 
+    // storage for temporary results of channel function calls
+    ChannelValue fnResBuffer;
+
     ChannelFilter ** filters;
     size_t numFilters;
 

From 2d7da5618d581409e1c39ddd5a625861f8065e4b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 14 Oct 2021 11:15:51 +0200
Subject: [PATCH 064/166] Do not allocate memory for arrays in UpdateToOutput

---
 src/core/connections/FilteredConnection.c     | 20 ++++++++-----------
 .../connections/FilteredConnection_impl.h     |  4 ++--
 2 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 024fdad..4140637 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -24,7 +24,7 @@ static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionD
     data->filters = NULL;
     data->numFilters = 0;
 
-    ChannelValueInit(&data->fnResBuffer, ChannelTypeClone(&ChannelTypeUnknown));
+    ChannelValueInit(&data->updateBuffer, ChannelTypeClone(&ChannelTypeUnknown));
     ChannelValueInit(&data->store, ChannelTypeClone(&ChannelTypeUnknown));
 
     return data;
@@ -32,7 +32,7 @@ static FilteredConnectionData * FilteredConnectionDataCreate(FilteredConnectionD
 
 static void FilteredConnectionDataDestructor(FilteredConnectionData * data) {
     ChannelValueDestructor(&data->store);
-    ChannelValueDestructor(&data->fnResBuffer);
+    ChannelValueDestructor(&data->updateBuffer);
 
     if (data->filters) {
         size_t i = 0;
@@ -71,9 +71,7 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     connection->value_ = ChannelValueReference(&filteredConnection->data->store);
 
     // initialize the buffer for channel function calls
-    if (out->GetFunction(out)) {
-        ChannelValueInit(&filteredConnection->data->fnResBuffer, sourceInfo->type);
-    }
+    ChannelValueInit(&filteredConnection->data->updateBuffer, ChannelTypeClone(sourceInfo->type));
 
     // Connection::Setup()
     // this has to be done last as it connects the channels
@@ -200,12 +198,12 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
     if (out->GetFunction(out)) {
         proc * p = (proc *) out->GetFunction(out);
 
-        if (p->fn(time, p->env, &filteredConnection->data->fnResBuffer) != 0) {
+        if (p->fn(time, p->env, &filteredConnection->data->updateBuffer) != 0) {
             mcx_log(LOG_ERROR, "FilteredConnection: Function failed");
             return RETURN_ERROR;
         }
 
-        if (RETURN_OK != filteredConnection->SetResult(filteredConnection, ChannelValueReference(&filteredConnection->data->fnResBuffer))) {
+        if (RETURN_OK != filteredConnection->SetResult(filteredConnection, ChannelValueReference(&filteredConnection->data->updateBuffer))) {
             mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
             return RETURN_ERROR;
         }
@@ -227,10 +225,8 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
                 size_t numFilters = FilteredConnectionGetNumFilters(filteredConnection);
                 ChannelType * type = info->type;
 
-                mcx_array elements = {0};
-                mcx_array_init(&elements, type->ty.a.numDims, type->ty.a.dims, type->ty.a.inner);
-
-                char * dest = (char *) elements.data;
+                mcx_array * elements = (mcx_array *) ChannelValueReference(&filteredConnection->data->updateBuffer);
+                char * dest = (char *) elements->data;
                 for (i = 0; i < numFilters; i++) {
                     filter = filteredConnection->GetReadFilter(filteredConnection, i);
                     value = filter->GetValue(filter, time->startTime);
@@ -239,7 +235,7 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
                     dest += ChannelValueTypeSize(ChannelTypeBaseType(type));
                 }
 
-                if (RETURN_OK != filteredConnection->SetResult(filteredConnection, &elements)) {
+                if (RETURN_OK != filteredConnection->SetResult(filteredConnection, elements)) {
                     mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
                     return RETURN_ERROR;
                 }
diff --git a/src/core/connections/FilteredConnection_impl.h b/src/core/connections/FilteredConnection_impl.h
index c586c4c..8071a00 100644
--- a/src/core/connections/FilteredConnection_impl.h
+++ b/src/core/connections/FilteredConnection_impl.h
@@ -28,8 +28,8 @@ typedef struct FilteredConnectionData {
     // storage of the filtered value provided by the output channel
     ChannelValue store;
 
-    // storage for temporary results of channel function calls
-    ChannelValue fnResBuffer;
+    // storage for temporary results during out channel updates
+    ChannelValue updateBuffer;
 
     ChannelFilter ** filters;
     size_t numFilters;

From d3842b831b93ace0e6748c870539fddebc2d8822 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 14 Oct 2021 15:35:18 +0200
Subject: [PATCH 065/166] Properly initialize the type in ChannelInData

---
 src/core/channels/Channel.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 42fff71..a42b980 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -87,6 +87,7 @@ static Channel * ChannelCreate(Channel * channel) {
 static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
     data->connection = NULL;
     data->reference  = NULL;
+    data->type = ChannelTypeClone(&ChannelTypeUnknown);
 
     data->unitConversion = NULL;
     data->typeConversion = NULL;

From fc8a20bb1227ffeb3eb3171bd17d7b0feabf0677 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:12:26 +0200
Subject: [PATCH 066/166] Do not forget to call ChannelInfoInit

---
 src/core/Databus.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index b29083e..78b57d1 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -57,6 +57,11 @@ static ChannelInfo * DatabusReadPortInput(PortInput * input) {
         return NULL;
     }
 
+    retVal = ChannelInfoInit(info);
+    if (RETURN_ERROR == retVal) {
+        goto cleanup_0;
+    }
+
     if (input->type == PORT_VECTOR) {
         VectorPortInput * vectorPortInput = input->port.vectorPort;
         InputElement * vectorPortElement = (InputElement *) vectorPortInput;

From 0530ea23ced06aac92b9f92da5b36223c4560908 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:12:42 +0200
Subject: [PATCH 067/166] Fix indentation

---
 src/core/Databus.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 78b57d1..067b514 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -104,12 +104,12 @@ static ChannelInfo * DatabusReadPortInput(PortInput * input) {
         size_t dims[1] = { endIdx - startIdx + 1 };
 
         if (RETURN_OK != ChannelInfoSetup(info,
-                                         vectorPortInput->name,
-                                         vectorPortInput->nameInModel,
-                                         vectorPortInput->description,
-                                         vectorPortInput->unit,
-                                         ChannelTypeArray(vectorPortInput->type, 1, dims),
-                                         vectorPortInput->id)) {
+                                          vectorPortInput->name,
+                                          vectorPortInput->nameInModel,
+                                          vectorPortInput->description,
+                                          vectorPortInput->unit,
+                                          ChannelTypeArray(vectorPortInput->type, 1, dims),
+                                          vectorPortInput->id)) {
             mcx_log(LOG_ERROR, "Could not Init ChannelInfo");
             retVal = RETURN_ERROR;
             goto vector_cleanup_0;

From 2106dd488d195b27404e29e7d1475acc5bbb3d8f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:13:00 +0200
Subject: [PATCH 068/166] Fix ChannelDimension definition

---
 src/core/channels/ChannelDimension.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index d8763c7..d107edf 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -20,7 +20,7 @@ extern "C" {
 extern const struct ObjectClass _ChannelDimension;
 
 typedef struct ChannelDimension {
-    Object * _; // super class first
+    Object _; // super class first
 
     size_t num;
     size_t * startIdxs;

From 2178a44ae4b418bf131fd6465f4c446bdbd2f84b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:13:39 +0200
Subject: [PATCH 069/166] Remove obsolete explicit destruction of channel info

---
 src/storage/ChannelStorage.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index 6921ba4..e1c0f24 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -306,15 +306,12 @@ static void ChannelStorageDestructor(ChannelStorage * channelStore) {
 
         if (channels) {
             size_t i = 0;
-            if (channels->Size(channels) > 0) {
-                Channel * channel = (Channel *) channels->At(channels, 0);
-                ChannelInfo * timeInfo = &channel->info;
-                object_destroy(timeInfo);
-            }
+
             for (i = 0; i < channels->Size(channels); i++) {
                 Channel * channel = (Channel *) channels->At(channels, i);
                 object_destroy(channel);
             }
+
             object_destroy(channels);
         }
     }

From eeece338944ed50f28e5de8c0c49dac48cd18f04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:14:14 +0200
Subject: [PATCH 070/166] Do not forget to clone types

---
 src/core/Model.c                            | 2 +-
 src/core/channels/ChannelInfo.c             | 8 ++++----
 src/core/connections/filters/MemoryFilter.c | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/core/Model.c b/src/core/Model.c
index 35c8f6e..f828ec0 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -197,7 +197,7 @@ static McxStatus ModelPreprocessConstConnections(Model * model) {
             goto cleanup_1;
         }
 
-        ChannelValueInit(src, srcChannelInfo->type);
+        ChannelValueInit(src, ChannelTypeClone(srcChannelInfo->type));
         retVal = ChannelValueSet(src, srcCompConst->GetValue(srcCompConst, info->sourceChannel));
         if (retVal == RETURN_ERROR) {
             goto cleanup_1;
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index b54717f..dcfa340 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -82,7 +82,7 @@ McxStatus ChannelInfoSetType(ChannelInfo * info, ChannelType * type) {
         return RETURN_ERROR;
     }
 
-    info->type = type;
+    info->type = ChannelTypeClone(type);
 
     if (ChannelInfoIsBinary(info)) {
         // the default for binary is off
@@ -168,7 +168,7 @@ McxStatus ChannelInfoSetFrom(ChannelInfo * info, const ChannelInfo * other) {
         return RETURN_ERROR;
     }
 
-    info->type = other->type;
+    info->type = ChannelTypeClone(other->type);
     info->mode = other->mode;
     info->writeResult = other->writeResult;
     info->connected = other->connected;
@@ -265,7 +265,7 @@ void ChannelInfoDestroy(ChannelInfo * info) {
 
     info->channel = NULL;
     info->initialValueIsExact = FALSE;
-    info->type = &ChannelTypeUnknown;
+    info->type = ChannelTypeClone(&ChannelTypeUnknown);
     info->connected = FALSE;
     info->writeResult = TRUE;
 }
@@ -288,7 +288,7 @@ McxStatus ChannelInfoInit(ChannelInfo * info) {
     info->scale = NULL;
     info->offset = NULL;
 
-    info->type = &ChannelTypeUnknown;
+    info->type = ChannelTypeClone(&ChannelTypeUnknown);
     info->defaultValue = NULL;
     info->initialValue = NULL;
 
diff --git a/src/core/connections/filters/MemoryFilter.c b/src/core/connections/filters/MemoryFilter.c
index d37e8c9..ac14fa0 100644
--- a/src/core/connections/filters/MemoryFilter.c
+++ b/src/core/connections/filters/MemoryFilter.c
@@ -241,11 +241,11 @@ static McxStatus MemoryFilterSetup(MemoryFilter * filter, ChannelType * type, si
     }
 
     for (i = 0; i < filter->historySize; i++) {
-        ChannelValueInit(filter->valueHistoryRead + i, type);
+        ChannelValueInit(filter->valueHistoryRead + i, ChannelTypeClone(type));
     }
 
     for (i = 0; i < filter->historySize; i++) {
-        ChannelValueInit(filter->valueHistoryWrite + i, type);
+        ChannelValueInit(filter->valueHistoryWrite + i, ChannelTypeClone(type));
     }
 
     return RETURN_OK;

From 92567b756c83edb09d561b40568cbc676e3c93f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:14:25 +0200
Subject: [PATCH 071/166] Fix ChannelInfo

---
 src/core/channels/ChannelDimension.c | 36 ++++++++++++++++++++++++++++
 src/core/channels/ChannelDimension.h |  1 +
 src/core/channels/ChannelInfo.c      |  9 +++++++
 3 files changed, 46 insertions(+)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index 7a01564..6b97627 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -76,6 +76,42 @@ size_t ChannelDimensionNumElements(ChannelDimension * dimension) {
     return n;
 }
 
+ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension) {
+    ChannelDimension * clone = NULL;
+    McxStatus retVal = RETURN_OK;
+    size_t i = 0;
+
+    if (!dimension) {
+        return NULL;
+    }
+
+    clone = (ChannelDimension *) object_create(ChannelDimension);
+    if (!clone) {
+        mcx_log(LOG_ERROR, "ChannelDimensionClone: Not enough memory");
+        return NULL;
+    }
+
+    retVal = ChannelDimensionSetup(clone, dimension->num);
+    if (RETURN_ERROR == retVal) {
+        mcx_log(LOG_ERROR, "Channel dimension setup failed");
+        goto cleanup;
+    }
+
+    for (i = 0; i < dimension->num; i++) {
+        retVal = ChannelDimensionSetDimension(clone, i, dimension->startIdxs[i], dimension->endIdxs[i]);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "Channel dimension %zu set failed", i);
+            goto cleanup;
+        }
+    }
+
+    return clone;
+
+cleanup:
+    object_destroy(clone);
+    return NULL;
+}
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index d107edf..2e361eb 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -30,6 +30,7 @@ typedef struct ChannelDimension {
 
 McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num);
 McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end);
+ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 size_t ChannelDimensionNumElements(ChannelDimension * dimension);
 
 #ifdef __cplusplus
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index dcfa340..b88b83c 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -231,6 +231,15 @@ McxStatus ChannelInfoSetFrom(ChannelInfo * info, const ChannelInfo * other) {
         }
     }
 
+    object_destroy(info->dimension);
+    if (other->dimension) {
+        info->dimension = ChannelDimensionClone(other->dimension);
+        if (!info->dimension) {
+            mcx_log(LOG_ERROR, "ChannelInfoSetFrom: Failed to set dimension");
+            return RETURN_ERROR;
+        }
+    }
+
     return RETURN_OK;
 }
 

From 1dd1f5cf9d0b11bab09095f67b94f60c7a4611c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:16:29 +0200
Subject: [PATCH 072/166] Fix Constant::GetValue

---
 src/components/comp_constant.c | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/components/comp_constant.c b/src/components/comp_constant.c
index b670cd8..57556fb 100644
--- a/src/components/comp_constant.c
+++ b/src/components/comp_constant.c
@@ -57,19 +57,14 @@ static ChannelValue * GetValue(CompConstant * compConstant, size_t idx) {
     Component * comp = (Component *) (compConstant);
     Databus * db = comp->GetDatabus(comp);
     size_t numOut = DatabusGetOutChannelsNum(db);
-    size_t i = 0;
-    size_t sum = 0;
     ChannelValue * value = NULL;
-    size_t numCh = 0;
-    size_t startIdx = 0;
-    size_t endIdx = 0;
 
-    if (i >= numOut) {
+    if (idx >= numOut) {
         ComponentLog(comp, LOG_ERROR, "GetValue: Invalid index (%zu) provided", idx);
         return NULL;
     }
 
-    value = compConstant->values[i];
+    value = compConstant->values[idx];
 
     return value;
 }

From dce9d34ce50a001c160a88220608df421b698609 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 13 May 2022 11:21:53 +0200
Subject: [PATCH 073/166] Fix ConnectionInfo construction

---
 src/core/connections/ConnectionInfoFactory.c | 61 ++++++++++----------
 1 file changed, 30 insertions(+), 31 deletions(-)

diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index 0db5751..344d6a9 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -115,28 +115,6 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
         }
 
         // TODO: multiplexing here?
-        if (connInput->fromType == ENDPOINT_VECTOR) {
-            ChannelDimension * sourceDimension = (ChannelDimension *) object_create(ChannelDimension);
-            if (!sourceDimension) {
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            }
-
-            if (RETURN_OK != ChannelDimensionSetup(sourceDimension, 1)) {
-                mcx_log(LOG_ERROR, "Could not setup ChannelDimension");
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            }
-
-            if (RETURN_OK != ChannelDimensionSetDimension(sourceDimension, 0, (size_t) connInput->from.vectorEndpoint->startIndex, (size_t) connInput->from.vectorEndpoint->endIndex)) {
-                mcx_log(LOG_ERROR, "Could not SetDimension");
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            }
-
-            info->sourceDimension = sourceDimension;
-        }
-
         info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
         if (info->sourceChannel < 0) {
             // the connection might be inverted, see SSP 1.0 specification (section 5.3.2.1, page 47)
@@ -168,15 +146,6 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             goto cleanup;
         }
 
-        if (connInput->toType == ENDPOINT_VECTOR) {
-            mcx_free(strToChannel);
-            strToChannel = CreateIndexedName(inputToChannel, connInput->to.vectorEndpoint->startIndex);
-            if (!strToChannel) {
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            }
-        }
-
         if (0 == connectionInverted) {
             databusInfo = DatabusGetInInfo(databus);
         } else {
@@ -212,6 +181,36 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             info->targetComponent->GetName(info->targetComponent), strFromChannel, info->sourceComponent->GetName(info->sourceComponent), strToChannel);
     }
 
+    // source dimension
+    {
+        EndpointInputType endpointType = connectionInverted ? connInput->toType : connInput->fromType;
+
+        if (endpointType == ENDPOINT_VECTOR) {
+            size_t startIndex = (size_t) (connectionInverted ? connInput->to.vectorEndpoint->startIndex : connInput->from.vectorEndpoint->startIndex);
+            size_t endIndex = (size_t)(connectionInverted ? connInput->to.vectorEndpoint->endIndex : connInput->from.vectorEndpoint->endIndex);
+
+            ChannelDimension* sourceDimension = (ChannelDimension*)object_create(ChannelDimension);
+            if (!sourceDimension) {
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            if (RETURN_OK != ChannelDimensionSetup(sourceDimension, 1)) {
+                mcx_log(LOG_ERROR, "Could not setup ChannelDimension");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            if (RETURN_OK != ChannelDimensionSetDimension(sourceDimension, 0, startIndex, endIndex)) {
+                mcx_log(LOG_ERROR, "Could not SetDimension");
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            info->sourceDimension = sourceDimension;
+        }
+    }
+
     // extrapolation
     if (connInput->interExtrapolationType.defined) {
         info->interExtrapolationType = connInput->interExtrapolationType.value;

From a70a831446899464b519a7e340cec34784fadb0e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 18 Oct 2021 10:05:22 +0200
Subject: [PATCH 074/166] Extend ConnectionInfo with slice information

---
 src/core/channels/ChannelDimension.h         |  1 +
 src/core/connections/ConnectionInfo.c        |  1 +
 src/core/connections/ConnectionInfo.h        |  1 +
 src/core/connections/ConnectionInfoFactory.c | 55 +++++++++++++++++++-
 src/core/connections/ConnectionInfo_impl.h   |  1 +
 5 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 2e361eb..9fd8909 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -32,6 +32,7 @@ McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num);
 McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end);
 ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 size_t ChannelDimensionNumElements(ChannelDimension * dimension);
+ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/connections/ConnectionInfo.c b/src/core/connections/ConnectionInfo.c
index 1675ae6..eec8b3b 100644
--- a/src/core/connections/ConnectionInfo.c
+++ b/src/core/connections/ConnectionInfo.c
@@ -161,6 +161,7 @@ McxStatus ConnectionInfoInit(ConnectionInfo * info) {
     info->connType_ = &ChannelTypeUnknown;
 
     info->sourceDimension = NULL;
+    info->targetDimension = NULL;
 
     return RETURN_OK;
 }
diff --git a/src/core/connections/ConnectionInfo.h b/src/core/connections/ConnectionInfo.h
index 8c18150..8d9a171 100644
--- a/src/core/connections/ConnectionInfo.h
+++ b/src/core/connections/ConnectionInfo.h
@@ -50,6 +50,7 @@ typedef struct ConnectionInfo {
     int decouplePriority;
 
     ChannelDimension * sourceDimension;
+    ChannelDimension * targetDimension;
 } ConnectionInfo;
 
 
diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index 344d6a9..4c1c23e 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -114,7 +114,29 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             goto cleanup;
         }
 
-        // TODO: multiplexing here?
+        // arrays/multiplexing: source slice dimensions
+        if (connInput->fromType == ENDPOINT_VECTOR) {
+            ChannelDimension* sourceDimension = (ChannelDimension*)object_create(ChannelDimension);
+            if (!sourceDimension) {
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            if (RETURN_OK != ChannelDimensionSetup(sourceDimension, 1)) {
+                mcx_log(LOG_ERROR, "Source port %s: Could not set number of dimensions", strFromChannel);
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            if (RETURN_OK != ChannelDimensionSetDimension(sourceDimension, 0, connInput->from.vectorEndpoint->startIndex, connInput->from.vectorEndpoint->endIndex)) {
+                mcx_log(LOG_ERROR, "Source port %s: Could not set dimension boundaries", strFromChannel);
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            info->sourceDimension = sourceDimension;
+        }
+
         info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
         if (info->sourceChannel < 0) {
             // the connection might be inverted, see SSP 1.0 specification (section 5.3.2.1, page 47)
@@ -152,6 +174,33 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             databusInfo = DatabusGetOutInfo(databus);
         }
 
+        // arrays/multiplexing: target slice dimensions
+        if (connInput->toType == ENDPOINT_VECTOR) {
+            ChannelDimension * targetDimension = (ChannelDimension *) object_create(ChannelDimension);
+            if (!targetDimension) {
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            if (RETURN_OK != ChannelDimensionSetup(targetDimension, 1)) {
+                mcx_log(LOG_ERROR, "Target port %s: Could not set number of dimensions", strToChannel);
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            if (RETURN_OK != ChannelDimensionSetDimension(targetDimension,
+                                                          0,
+                                                          (size_t) connInput->to.vectorEndpoint->startIndex,
+                                                          (size_t) connInput->to.vectorEndpoint->endIndex))
+            {
+                mcx_log(LOG_ERROR, "Target port %s: Could not set dimension boundaries", strToChannel);
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+
+            info->targetDimension = targetDimension;
+        }
+
         info->targetChannel = DatabusInfoGetChannelID(databusInfo, strToChannel);
         if (info->targetChannel < 0) {
             if (0 == connectionInverted) {
@@ -170,6 +219,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
     if (connectionInverted) {
         int tmp = info->sourceChannel;
         Component * tmpCmp = info->sourceComponent;
+        ChannelDimension * tmpDim = info->sourceDimension;
 
         info->sourceChannel = info->targetChannel;
         info->targetChannel = tmp;
@@ -177,6 +227,9 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
         info->sourceComponent = info->targetComponent;
         info->targetComponent = tmpCmp;
 
+        info->sourceDimension = info->targetDimension;
+        info->targetDimension = tmpDim;
+
         mcx_log(LOG_DEBUG, "Connection: Inverted connection (%s, %s) -- (%s, %s)",
             info->targetComponent->GetName(info->targetComponent), strFromChannel, info->sourceComponent->GetName(info->sourceComponent), strToChannel);
     }
diff --git a/src/core/connections/ConnectionInfo_impl.h b/src/core/connections/ConnectionInfo_impl.h
index bd7bc91..455b13a 100644
--- a/src/core/connections/ConnectionInfo_impl.h
+++ b/src/core/connections/ConnectionInfo_impl.h
@@ -42,6 +42,7 @@ typedef struct ConnectionInfoData {
     int targetChannel;
 
     ChannelDimension * sourceDimension;
+    ChannelDimension * targetDimension;
 
     // Decouple Info: If this connection is decoupled because of an algebraic loop
     // in the model (this means that the value of the source for the target is

From 3899951fbcc49a93fdaf601813345fe3547c893f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 18 Oct 2021 13:20:45 +0200
Subject: [PATCH 075/166] Do not fill internalValue as it is not used anywhere

---
 src/core/channels/Channel.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index a42b980..1d816b7 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -323,7 +323,6 @@ static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection,
     McxStatus retVal;
 
     in->data->connection = connection;
-    channel->internalValue = connection->GetValueReference(connection);
 
     // setup unit conversion
     inInfo = &channel->info;
@@ -388,7 +387,6 @@ static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
         }
 
         channel->SetDefinedDuringInit(channel);
-        channel->internalValue = ChannelValueReference(&channel->value);
     }
 
     // unit conversion is setup when a connection is set

From 8079f30ac40abd9e11b817fd7e5964d84037b69e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 29 Oct 2021 13:41:09 +0200
Subject: [PATCH 076/166] Allow registering multiple connections with the same
 ChannelIn

---
 src/core/Component.c                      |   8 +-
 src/core/Component.h                      |   4 +-
 src/core/SubModel.c                       |  60 +++++++---
 src/core/channels/Channel.c               | 128 ++++++++++++++++------
 src/core/channels/Channel.h               |  15 +--
 src/core/channels/ChannelDimension.c      |  22 ++++
 src/core/channels/ChannelDimension.h      |   1 +
 src/core/channels/ChannelValueReference.c |  48 ++++++++
 src/core/channels/ChannelValueReference.h |  54 +++++++++
 src/core/channels/Channel_impl.h          |   4 +-
 src/core/connections/Connection.c         |   2 +-
 11 files changed, 280 insertions(+), 66 deletions(-)
 create mode 100644 src/core/channels/ChannelValueReference.c
 create mode 100644 src/core/channels/ChannelValueReference.h

diff --git a/src/core/Component.c b/src/core/Component.c
index 5bab659..93b8193 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -840,22 +840,22 @@ static void ComponentSetModel(Component * comp, Model * model) {
     comp->data->model = model;
 }
 
-ConnectionInfo * GetInConnectionInfo(const Component * comp, size_t channelID) {
+ObjectContainer * GetInConnectionInfos(const Component * comp, size_t channelID) {
     size_t channelNum = DatabusInfoGetChannelNum(DatabusGetInInfo(comp->data->databus));
 
     if (channelID < channelNum) {
         ChannelIn * in = DatabusGetInChannel(comp->data->databus, channelID);
-        return in->GetConnectionInfo(in);
+        return in->GetConnectionInfos(in);
     }
 
     return NULL;
 }
 
-Connection * GetInConnection(const Component * comp, size_t channelID) {
+ObjectContainer * GetInConnections(const Component * comp, size_t channelID) {
     size_t channelNum = DatabusInfoGetChannelNum(DatabusGetInInfo(comp->data->databus));
     if (channelID < channelNum) {
         ChannelIn * in = DatabusGetInChannel(comp->data->databus, channelID);
-        return in->GetConnection(in);
+        return in->GetConnections(in);
     }
 
     return NULL;
diff --git a/src/core/Component.h b/src/core/Component.h
index 9d6f1cc..8abede0 100644
--- a/src/core/Component.h
+++ b/src/core/Component.h
@@ -250,8 +250,8 @@ McxStatus ComponentDoCommunicationStep(Component * comp, size_t group, struct St
 McxStatus ComponentEnterCommunicationPoint(Component * comp, TimeInterval * time);
 McxStatus ComponentEnterCommunicationPointForConnections(Component * comp, ObjectList * connections, TimeInterval * time);
 
-ConnectionInfo * GetInConnectionInfo(const Component * comp, size_t channelID);
-struct Connection * GetInConnection(const Component * comp, size_t channelID);
+struct ObjectContainer * GetInConnectionInfos(const Component * comp, size_t channelID);
+struct ObjectContainer * GetInConnections(const Component * comp, size_t channelID);
 
 size_t ComponentGetNumOutGroups(const Component * comp);
 size_t ComponentGetNumInitialOutGroups(const Component * comp);
diff --git a/src/core/SubModel.c b/src/core/SubModel.c
index 87feb06..eeb36ce 100644
--- a/src/core/SubModel.c
+++ b/src/core/SubModel.c
@@ -689,27 +689,59 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
                 // initial inputs are always exact
                 if (info->initialValue) {
                     //check if connection exists (cosim init values are not deoupling connections, they only have lower priority than connection values)
-                    ConnectionInfo * info = GetInConnectionInfo(targetComp, targetInChannelID);
-                    if (NULL != info) {
-                        if (ConnectionInfoIsDecoupled(info)) {//decoupled connection
+                    ObjectContainer * infos = GetInConnectionInfos(targetComp, targetInChannelID);
+                    size_t numInfos = infos->Size(infos);
+                    size_t i = 0;
+
+                    if (numInfos == 0) {        // no connections
+                        dependency = DEP_INDEPENDENT;
+                    } else {
+                        int allDecoupled = TRUE;
+                        for (i = 0; i < numInfos; i++) {
+                            ConnectionInfo * info = (ConnectionInfo *) infos->At(infos, i);
+                            if (!ConnectionInfoIsDecoupled(info)) {
+                                allDecoupled = FALSE;
+                            }
+                        }
+
+                        if (allDecoupled) {     // decoupled connections
                             dependency = DEP_INDEPENDENT;
                         }
-                    } else {//no connection
-                        dependency = DEP_INDEPENDENT;
                     }
                 }
             }
 
             if (DEP_INDEPENDENT != dependency) {
-                ConnectionInfo * info = GetInConnectionInfo(targetComp, targetInChannelID);
-                Connection * conn = GetInConnection(targetComp, targetInChannelID);
-
-                if (info
-                    && (info->decoupleType & (DECOUPLE_NEVER | DECOUPLE_IFNEEDED))
-                    && (!ConnectionInfoIsDecoupled(info))
-                    && conn
-                    && conn->IsActiveDependency(conn))
-                {
+                ObjectContainer * infos = GetInConnectionInfos(targetComp, targetInChannelID);
+                ObjectContainer * conns = GetInConnections(targetComp, targetInChannelID);
+                size_t numInfos = infos->Size(infos);
+                size_t numConns = conns->Size(conns);
+                size_t i = 0;
+
+                int isDecoupled = TRUE;
+                size_t decoupleType = (size_t) -1;
+                int isActiveDependency = FALSE;
+
+                for (i = 0; i < numInfos; i++) {
+                    ConnectionInfo * info = (ConnectionInfo *) infos->At(infos, i);
+                    if (!ConnectionInfoIsDecoupled(info)) {
+                        isDecoupled = FALSE;
+                    }
+
+                    decoupleType &= info->decoupleType & (DECOUPLE_NEVER | DECOUPLE_IFNEEDED);
+                }
+
+                for (i = 0; i < numConns; i++) {
+                    Connection * conn = (Connection *) conns->At(conns, i);
+                    if (conn->IsActiveDependency(conn)) {
+                        isActiveDependency = TRUE;
+                        break;
+                    }
+                }
+
+                if (numInfos > 0 && decoupleType && !isDecoupled && numConns > 0 && isActiveDependency) {
+                    ConnectionInfo * info = (ConnectionInfo *) infos->At(infos, 0);
+
                     Component * sourceComp = info->sourceComponent;
                     size_t sourceOutGroup, sourceNode;
                     Databus * db = targetComp->GetDatabus(targetComp);
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 1d816b7..4ef43f3 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -15,6 +15,7 @@
 #include "core/Conversion.h"
 
 #include "core/channels/ChannelInfo.h"
+#include "core/channels/ChannelValueReference.h"
 #include "core/channels/Channel.h"
 #include "core/channels/ChannelValue.h"
 #include "core/channels/Channel_impl.h"
@@ -85,7 +86,16 @@ static Channel * ChannelCreate(Channel * channel) {
 
 
 static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
-    data->connection = NULL;
+    data->connections = (ObjectContainer *) object_create(ObjectContainer);
+    if (!data->connections) {
+        return NULL;
+    }
+
+    data->valueReferences = (ObjectContainer *) object_create(ObjectContainer);
+    if (!data->valueReferences) {
+        return NULL;
+    }
+
     data->reference  = NULL;
     data->type = ChannelTypeClone(&ChannelTypeUnknown);
 
@@ -115,6 +125,8 @@ static void ChannelInDataDestructor(ChannelInData * data) {
     if (data->type) {
         ChannelTypeDestructor(data->type);
     }
+
+    // TODO destroy connections/valueReference ????
 }
 
 OBJECT_CLASS(ChannelInData, Object);
@@ -177,34 +189,37 @@ static const void * ChannelInGetValueReference(Channel * channel) {
 static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
     ChannelIn * in = (ChannelIn *) channel;
     ChannelInfo * info = &channel->info;
-    Connection * conn = in->data->connection;
 
     McxStatus retVal = RETURN_OK;
 
     /* if no connection is present we have nothing to update*/
-    if (conn) {
-        ConnectionInfo * connInfo = NULL;
-        ChannelValue * val = &channel->value;
-
-        connInfo = &conn->info;
+    size_t i = 0;
+    size_t numConns = in->data->connections->Size(in->data->connections);
+    for (i = 0; i < numConns; i++) {
+        Connection * conn = (Connection *) in->data->connections->At(in->data->connections, i);
+        ChannelValueRef * valueRef = (ChannelValueRef *) in->data->valueReferences->At(in->data->valueReferences, i);
+        ConnectionInfo * connInfo = &conn->info;
+        char * connString = ConnectionInfoConnectionString(connInfo);
 
-        ChannelValueDestructor(val);
-        ChannelValueInit(val, ChannelTypeClone(ConnectionInfoGetType(connInfo)));
+        // TODO do we need this Init ???
+        /*ChannelValueDestructor(val);
+        ChannelValueInit(val, ChannelTypeClone(connInfo->GetType(connInfo)));*/
 
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
-            mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection failed", ChannelInfoGetLogName(info));
+            mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection %s failed", ChannelInfoGetLogName(info), connString);
             return RETURN_ERROR;
         }
-        if (RETURN_OK != ChannelValueSetFromReference(val, conn->GetValueReference(conn))) {
-            mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueSetFromReference failed", ChannelInfoGetLogName(info));
+        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn))) {  // TODO conn->GetValueReference - let it maybe return our reference
+            mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueRefSetFromReference for connection %s failed", ChannelInfoGetLogName(info), connString);
             return RETURN_ERROR;
         }
 
-        //type
+        // type
+        // TODO per connection
         if (in->data->typeConversion) {
             Conversion * conversion = (Conversion *) in->data->typeConversion;
-            retVal = conversion->convert(conversion, val);
+            retVal = conversion->convert(conversion, valueRef->ref.value);  // TODO convert valueRef directly
             if (RETURN_OK != retVal) {
                 mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute type conversion", ChannelInfoGetLogName(info));
                 return RETURN_ERROR;
@@ -292,7 +307,7 @@ static int ChannelInIsConnected(Channel * channel) {
         return TRUE;
     } else {
         ChannelIn * in = (ChannelIn *) channel;
-        if (NULL != in->data->connection) {
+        if (in->data->connections->Size(in->data->connections) > 0) {
             return TRUE;
         }
     }
@@ -300,32 +315,68 @@ static int ChannelInIsConnected(Channel * channel) {
     return FALSE;
 }
 
-static ConnectionInfo * ChannelInGetConnectionInfo(ChannelIn * in) {
-    if (in->data->connection) {
-        return &in->data->connection->info;
-    } else {
+static ObjectContainer * ChannelInGetConnectionInfos(ChannelIn * in) {
+    ObjectContainer * infos = (ObjectContainer *) object_create(ObjectContainer);
+    size_t numConns = in->data->connections->Size(in->data->connections);
+    size_t i = 0;
+
+    if (!infos) {
         return NULL;
     }
-}
 
-static Connection * ChannelInGetConnection(ChannelIn * in) {
-    if (in->data->connection) {
-        return in->data->connection;
-    } else {
-        return NULL;
+    for (i = 0; i < numConns; i++) {
+        Connection * conn = in->data->connections->At(in->data->connections, i);
+        ConnectionInfo * connInfo = &conn->info;
+        if (RETURN_ERROR == infos->PushBack(infos, (Object *) connInfo)) {
+            object_destroy(infos);
+            return NULL;
+        }
     }
+
+    return infos;
+}
+
+static ObjectContainer * ChannelInGetConnections(ChannelIn * in) {
+    return in->data->connections;
 }
 
-static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection, const char * unit, ChannelType * type) {
+static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connection, const char * unit, ChannelType * type) {
+    ConnectionInfo * connInfo = &connection->info;
+    char * connString = ConnectionInfoConnectionString(connInfo);
     Channel * channel = (Channel *) in;
-    ChannelInfo * inInfo = NULL;
+    ChannelInfo * inInfo = &channel->info;
 
-    McxStatus retVal;
+    McxStatus retVal = RETURN_OK;
 
-    in->data->connection = connection;
+    retVal = in->data->connections->PushBack(in->data->connections, (Object *) connection);
+    if (RETURN_OK != retVal) {
+        mcx_log(LOG_ERROR, "Port %s: Register inport connection %s: Could not register connection", ChannelInfoGetLogName(inInfo), connString);
+        mcx_free(connString);
+        return RETURN_ERROR;
+    }
 
-    // setup unit conversion
-    inInfo = &channel->info;
+    // TODO setup valueReference
+    ChannelValueRef * valRef = (ChannelValueRef *) object_create(ChannelValueRef);
+    if (!valRef) {
+        return RETURN_ERROR;
+    }
+
+    ChannelDimension * dimension = connInfo->targetDimension;
+    // TODO check ret values
+    // TODO do we need some plausibility checks?
+    // TODO is it fine to use connInfo here?
+    if (dimension && !ChannelDimensionEq(dimension, inInfo->dimension)) {
+        valRef->type = CHANNEL_VALUE_REF_SLICE;
+        valRef->ref.slice = (ArraySlice *) mcx_calloc(1, sizeof(ArraySlice));
+        valRef->ref.slice->ref = &channel->value;
+        valRef->ref.slice->dimension = ChannelDimensionClone(dimension);
+    } else {
+        valRef->type = CHANNEL_VALUE_REF_VALUE;
+        valRef->ref.value = &channel->value;
+    }
+
+    retVal = in->data->valueReferences->PushBack(in->data->valueReferences, (Object *) valRef);
+    // TODO check retVal
 
     if (ChannelTypeEq(inInfo->type, &ChannelTypeDouble)) {
         in->data->unitConversion = (UnitConversion *) object_create(UnitConversion);
@@ -342,6 +393,7 @@ static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection,
         }
     }
 
+    // TODO - array
     // setup type conversion
     if (!ChannelTypeEq(inInfo->type, type)) {
         in->data->typeConversion = (TypeConversion *) object_create(TypeConversion);
@@ -354,8 +406,14 @@ static McxStatus ChannelInSetConnection(ChannelIn * in, Connection * connection,
         }
     }
 
-    return RETURN_OK;
+cleanup:
+    if (RETURN_ERROR == retVal) {
+        if (connString) {
+            mcx_free(connString);
+        }
+    }
 
+    return retVal;
 }
 
 static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
@@ -450,10 +508,10 @@ static ChannelIn * ChannelInCreate(ChannelIn * in) {
     in->Setup        = ChannelInSetup;
     in->SetReference = ChannelInSetReference;
 
-    in->GetConnectionInfo = ChannelInGetConnectionInfo;
+    in->GetConnectionInfos = ChannelInGetConnectionInfos;
 
-    in->GetConnection = ChannelInGetConnection;
-    in->SetConnection = ChannelInSetConnection;
+    in->GetConnections = ChannelInGetConnections;
+    in->RegisterConnection = ChannelInRegisterConnection;
 
     in->IsDiscrete = ChannelInIsDiscrete;
     in->SetDiscrete = ChannelInSetDiscrete;
diff --git a/src/core/channels/Channel.h b/src/core/channels/Channel.h
index e022dfb..7dae1cb 100644
--- a/src/core/channels/Channel.h
+++ b/src/core/channels/Channel.h
@@ -115,14 +115,11 @@ typedef McxStatus  (* fChannelInSetReference) (ChannelIn   * in,
                                                void        * reference,
                                                ChannelType * type);
 
-typedef struct ConnectionInfo * (* fChannelInGetConnectionInfo)(ChannelIn * in);
+typedef struct ObjectContainer * (* fChannelInGetConnectionInfos)(ChannelIn * in);
 
-typedef struct Connection * (* fChannelInGetConnection)(ChannelIn * in);
+typedef struct ObjectContainer * (* fChannelInGetConnections)(ChannelIn * in);
 
-typedef McxStatus (* fChannelInSetConnection)(ChannelIn * in,
-                                              struct Connection * connection,
-                                              const char * unit,
-                                              ChannelType * type);
+typedef McxStatus (*fChannelInRegisterConnection)(ChannelIn * in, struct Connection * connection, const char * unit, ChannelType * type);
 
 typedef int (*fChannelInIsDiscrete)(ChannelIn * in);
 typedef void (*fChannelInSetDiscrete)(ChannelIn * in);
@@ -150,15 +147,15 @@ struct ChannelIn {
     /**
      * Returns the ConnectionInfo of the incoming connection.
      */
-    fChannelInGetConnectionInfo GetConnectionInfo;
+    fChannelInGetConnectionInfos GetConnectionInfos;
 
-    fChannelInGetConnection GetConnection;
+    fChannelInGetConnections GetConnections;
 
     /**
      * Set the connection from which the channel retrieves the values in the
      * specified unit.
      */
-    fChannelInSetConnection SetConnection;
+    fChannelInRegisterConnection RegisterConnection;
 
     /**
     * Returns true if a channel value is discrete
diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index 6b97627..ea3965e 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -112,6 +112,28 @@ ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension) {
     return NULL;
 }
 
+int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second) {
+    size_t i = 0;
+
+    if (!first && !second) {
+        return TRUE;
+    } else if (!first || !second) {
+        return FALSE;
+    }
+
+    if (first->num != second->num) {
+        return FALSE;
+    }
+
+    for (i = 0; i < first->num; i++) {
+        if (first->startIdxs[i] != second->startIdxs[i] || first->endIdxs[i] != second->endIdxs[i]) {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 9fd8909..f654c3e 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -33,6 +33,7 @@ McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num,
 ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 size_t ChannelDimensionNumElements(ChannelDimension * dimension);
 ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
+int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second);
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
new file mode 100644
index 0000000..974d8ec
--- /dev/null
+++ b/src/core/channels/ChannelValueReference.c
@@ -0,0 +1,48 @@
+/********************************************************************************
+ * Copyright (c) 2021 AVL List GmbH and others
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache Software License 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#include "core/channels/ChannelValueReference.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+void ChannelValueRefDestructor(ChannelValueRef * ref) {
+    // TODO ???
+}
+
+ChannelValueRef * ChannelValueRefCreate(ChannelValueRef * ref) {
+    ref->type = CHANNEL_VALUE_REF_VALUE;
+    ref->ref.value = NULL;
+
+    return ref;
+}
+
+OBJECT_CLASS(ChannelValueRef, Object);
+
+
+McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference) {
+    if (ref->type == CHANNEL_VALUE_REF_VALUE) {
+        // value
+        return ChannelValueDataSetFromReference(&ref->ref.value->value, ref->ref.value->type, reference);
+    } else {
+        // slice
+
+        // TODO
+    }
+
+    return RETURN_OK;
+}
+
+
+#ifdef __cplusplus
+} /* closing brace for extern "C" */
+#endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
new file mode 100644
index 0000000..13ab9e5
--- /dev/null
+++ b/src/core/channels/ChannelValueReference.h
@@ -0,0 +1,54 @@
+/********************************************************************************
+ * Copyright (c) 2021 AVL List GmbH and others
+ * 
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache Software License 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ * 
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef MCX_CORE_CHANNELS_CHANNEL_VALUE_REFERENCE_H
+#define MCX_CORE_CHANNELS_CHANNEL_VALUE_REFERENCE_H
+
+#include "CentralParts.h"
+#include "core/channels/ChannelDimension.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+typedef struct ArraySlice {
+    ChannelDimension * dimension;
+    ChannelValue * ref;
+} ArraySlice;
+
+typedef enum ChannelValueRefType {
+    CHANNEL_VALUE_REF_VALUE,
+    CHANNEL_VALUE_REF_SLICE
+} ChannelValueRefType;
+
+
+extern const struct ObjectClass _ChannelValueRef;
+
+typedef struct ChannelValueRef {
+    Object * _;
+
+    ChannelValueRefType type;
+    union {
+        ChannelValue * value;
+        ArraySlice * slice;
+    } ref;
+} ChannelValueRef;
+
+
+McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference);
+
+
+#ifdef __cplusplus
+} /* closing brace for extern "C" */
+#endif /* __cplusplus */
+
+#endif // MCX_CORE_CHANNELS_CHANNEL_VALUE_REFERENCE_H
\ No newline at end of file
diff --git a/src/core/channels/Channel_impl.h b/src/core/channels/Channel_impl.h
index 8708cc6..16d8d45 100644
--- a/src/core/channels/Channel_impl.h
+++ b/src/core/channels/Channel_impl.h
@@ -28,7 +28,9 @@ extern "C" {
 typedef struct ChannelInData {
     Object _; // base class
 
-    struct Connection * connection;
+    ObjectContainer * connections;      // connections (non-overlapping) going into the channel
+    ObjectContainer * valueReferences;  // references to non-overlapping parts of ChannelData::value, where
+                                        // values gotten from connections are going to be stored
 
     // ----------------------------------------------------------------------
     // Conversions
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 0ac45af..8923fc1 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1345,7 +1345,7 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
         return RETURN_ERROR;
     }
 
-    retVal = in->SetConnection(in, connection, outInfo->unitString, outInfo->type);
+    retVal = in->RegisterConnection(in, connection, outInfo->unitString, outInfo->type);
     if (RETURN_OK != retVal) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_ERROR, "Connection %s: Setup connection: Could not register with inport", buffer);

From 497b74391106531eed459b95caf5b36b4390ba5d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 3 Nov 2021 08:37:28 +0100
Subject: [PATCH 077/166] Modify type conversions to work with
 destination/source arguments

Reason: Avoid memory allocation in ChannelInUpdate that would happen
due to ChannelValueInit allocating memory for array data of an
array channel
---
 src/core/Conversion.c                     | 119 ++++++++++------------
 src/core/Conversion.h                     |  12 ++-
 src/core/channels/Channel.c               |  26 +++--
 src/core/channels/ChannelValueReference.c |  21 +++-
 src/core/channels/ChannelValueReference.h |   6 +-
 5 files changed, 94 insertions(+), 90 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 942af6f..f3191d0 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -10,6 +10,7 @@
 
 #include "CentralParts.h"
 #include "core/Conversion.h"
+#include "core/channels/ChannelValueReference.h"
 #include "units/Units.h"
 
 #ifdef __cplusplus
@@ -545,122 +546,114 @@ McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue
     return retVal;
 }
 
-static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeInteger)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeInteger));
+static McxStatus CheckTypesValidForConversion(ChannelType * destType,
+                                              ChannelType * expectedDestType)
+{
+    if (!ChannelTypeEq(destType, expectedDestType)) {
+        mcx_log(LOG_ERROR,
+                "Type conversion: Destination value has wrong type %s, expected: %s",
+                ChannelTypeToString(ChannelValueType(destType)),
+                ChannelTypeToString(expectedDestType));
         return RETURN_ERROR;
     }
 
-    value->type = &ChannelTypeDouble;
-    value->value.d = (double)value->value.i;
-
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertDoubleInt(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeDouble)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeDouble));
+static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
-    value->type = &ChannelTypeInteger;
-    value->value.i = (int)floor(value->value.d + 0.5);
+    dest->ref.value->value.d = (double) *((int *) src);
 
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertBoolDouble(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeBool)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeBool));
+static McxStatus TypeConversionConvertDoubleInt(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
 
-    value->type = &ChannelTypeDouble;
-    value->value.d = (value->value.i != 0) ? 1. : 0.;
+    dest->ref.value->value.i = (int) floor(*((double *) src) + 0.5);
 
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertDoubleBool(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeDouble)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeDouble));
+static McxStatus TypeConversionConvertBoolDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
-    value->type = &ChannelTypeBool;
-    value->value.i = (value->value.d > 0) ? 1 : 0;
+    dest->ref.value->value.d = *((int *) src) != 0 ? 1. : 0.;
 
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertBoolInteger(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeBool)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeBool));
+static McxStatus TypeConversionConvertDoubleBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
 
-    value->type = &ChannelTypeInteger;
-    value->value.i = (value->value.i != 0) ? 1 : 0;
+    dest->ref.value->value.i = *((double *) src) > 0 ? 1 : 0;
 
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, ChannelValue * value) {
-    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeInteger)) {
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeInteger));
+static McxStatus TypeConversionConvertBoolInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
 
-    value->type = &ChannelTypeBool;
-    value->value.i = (value->value.i != 0) ? 1 : 0;
+    dest->ref.value->value.i = *((int *) src) != 0 ? 1 : 0;
 
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertSingletonDoubleToDouble(Conversion * conversion, ChannelValue * value) {
-    if (!(ChannelTypeIsArray(ChannelValueType(value)) && value->value.a.type, &ChannelTypeDouble)) {
-        ChannelType * array = ChannelTypeArray(&ChannelTypeDouble, 0, NULL);
-        mcx_log(LOG_ERROR, "Type conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), array);
-        ChannelTypeDestructor(array);
+static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
 
-    double val = *(double *)value->value.a.data;
+    dest->ref.value->value.i = *((int *) src) != 0 ? 1 : 0;
+
+    return RETURN_OK;
+}
 
-    ChannelValueDataDestructor(&value->value, value->type);
-    ChannelTypeDestructor(value->type);
-    value->type = &ChannelTypeDouble;
+static McxStatus TypeConversionConvertSingletonDoubleToDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+        return RETURN_ERROR;
+    }
 
-    value->value.d = val;
+    dest->ref.value->value.d = *(double *) ((mcx_array*)src)->data;
 
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertId(Conversion * conversion, ChannelValue * value) {
-    return RETURN_OK;
+static McxStatus TypeConversionConvertId(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    return ChannelValueRefSetFromReference(dest, src, NULL);
 }
 
-static McxStatus TypeConversionSetup(TypeConversion * typeConversion,
+static McxStatus TypeConversionSetup(TypeConversion * conversion,
                                      ChannelType * fromType,
                                      ChannelType * toType) {
-    Conversion * conversion = (Conversion *) typeConversion;
 
     if (ChannelTypeEq(fromType, toType)) {
-        conversion->convert = TypeConversionConvertId;
+        conversion->Convert = TypeConversionConvertId;
     } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
-        conversion->convert = TypeConversionConvertIntDouble;
+        conversion->Convert = TypeConversionConvertIntDouble;
     } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
-        conversion->convert = TypeConversionConvertDoubleInt;
+        conversion->Convert = TypeConversionConvertDoubleInt;
     } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
-        conversion->convert = TypeConversionConvertBoolDouble;
+        conversion->Convert = TypeConversionConvertBoolDouble;
     } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeBool)) {
-        conversion->convert = TypeConversionConvertDoubleBool;
+        conversion->Convert = TypeConversionConvertDoubleBool;
     } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
-        conversion->convert = TypeConversionConvertBoolInteger;
+        conversion->Convert = TypeConversionConvertBoolInteger;
     } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeBool)) {
-        conversion->convert = TypeConversionConvertIntegerBool;
+        conversion->Convert = TypeConversionConvertIntegerBool;
     } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
-        conversion->convert = TypeConversionConvertSingletonDoubleToDouble;
+        conversion->Convert = TypeConversionConvertSingletonDoubleToDouble;
     } else {
         mcx_log(LOG_ERROR, "Setup type conversion: Illegal conversion selected");
         return RETURN_ERROR;
@@ -669,28 +662,18 @@ static McxStatus TypeConversionSetup(TypeConversion * typeConversion,
     return RETURN_OK;
 }
 
-static int TypeConversionIsEmpty(TypeConversion * typeConversion) {
-    Conversion * conversion = (Conversion *) typeConversion;
-
-    return (conversion->convert == TypeConversionConvertId);
-}
-
 static void TypeConversionDestructor(TypeConversion * conversion) {
 
 }
 
-static TypeConversion * TypeConversionCreate(TypeConversion * typeConversion) {
-    Conversion * conversion = (Conversion *) typeConversion;
+static TypeConversion * TypeConversionCreate(TypeConversion * conversion) {
+    conversion->Setup = TypeConversionSetup;
+    conversion->Convert = NULL;
 
-    conversion->convert = TypeConversionConvertId;
-
-    typeConversion->Setup   = TypeConversionSetup;
-    typeConversion->IsEmpty = TypeConversionIsEmpty;
-
-    return typeConversion;
+    return conversion;
 }
 
-OBJECT_CLASS(TypeConversion, Conversion);
+OBJECT_CLASS(TypeConversion, Object);
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/Conversion.h b/src/core/Conversion.h
index 90ab771..22cf68e 100644
--- a/src/core/Conversion.h
+++ b/src/core/Conversion.h
@@ -13,6 +13,7 @@
 
 #include "units/Units.h"
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
@@ -112,18 +113,21 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 // ----------------------------------------------------------------------
 // Type Conversion
 
+typedef struct ChannelValueRef ChannelValueRef;
+
+
 typedef struct TypeConversion TypeConversion;
 
-typedef McxStatus (* fTypeConversionSetup)(TypeConversion * conversion, ChannelType * fromType, ChannelType * toType);
-typedef int (* fTypeConversionIsEmpty)(TypeConversion * conversion);
+typedef McxStatus (*fTypeConversionSetup)(TypeConversion * conversion, const ChannelType * fromType, const ChannelType * toType);
+typedef McxStatus (*fTypeConversionConvert)(TypeConversion * conversion, ChannelValueRef * dest, void * src);
 
 extern const struct ObjectClass _TypeConversion;
 
 struct TypeConversion {
-    Conversion _;
+    Object _;
 
     fTypeConversionSetup Setup;
-    fTypeConversionIsEmpty IsEmpty;
+    fTypeConversionConvert Convert;
 };
 
 McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue * value);
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 4ef43f3..6e756cc 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -210,21 +210,21 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
             mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection %s failed", ChannelInfoGetLogName(info), connString);
             return RETURN_ERROR;
         }
-        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn))) {  // TODO conn->GetValueReference - let it maybe return our reference
+        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), in->data->typeConversion)) {  // TODO conn->GetValueReference - let it maybe return our reference
             mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueRefSetFromReference for connection %s failed", ChannelInfoGetLogName(info), connString);
             return RETURN_ERROR;
         }
 
-        // type
-        // TODO per connection
-        if (in->data->typeConversion) {
-            Conversion * conversion = (Conversion *) in->data->typeConversion;
-            retVal = conversion->convert(conversion, valueRef->ref.value);  // TODO convert valueRef directly
-            if (RETURN_OK != retVal) {
-                mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute type conversion", ChannelInfoGetLogName(info));
-                return RETURN_ERROR;
-            }
-        }
+        //// type
+        //// TODO per connection
+        //if (in->data->typeConversion) {
+        //    Conversion * conversion = (Conversion *) in->data->typeConversion;
+        //    retVal = conversion->convert(conversion, valueRef->ref.value);  // TODO convert valueRef directly
+        //    if (RETURN_OK != retVal) {
+        //        mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute type conversion", info->GetLogName(info));
+        //        return RETURN_ERROR;
+        //    }
+        //}
     }
 
 
@@ -397,9 +397,7 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
     // setup type conversion
     if (!ChannelTypeEq(inInfo->type, type)) {
         in->data->typeConversion = (TypeConversion *) object_create(TypeConversion);
-        retVal = in->data->typeConversion->Setup(in->data->typeConversion,
-                                                 type,
-                                                 inInfo->type);
+        retVal = in->data->typeConversion->Setup(in->data->typeConversion, type, inInfo->type);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "Port %s: Set connection: Could not setup type conversion", ChannelInfoGetLogName(inInfo));
             return RETURN_ERROR;
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 974d8ec..e97dff5 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -9,6 +9,7 @@
  ********************************************************************************/
 
 #include "core/channels/ChannelValueReference.h"
+#include "common/logging.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -29,9 +30,12 @@ ChannelValueRef * ChannelValueRefCreate(ChannelValueRef * ref) {
 OBJECT_CLASS(ChannelValueRef, Object);
 
 
-McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference) {
+McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, TypeConversion * conv) {
     if (ref->type == CHANNEL_VALUE_REF_VALUE) {
-        // value
+        if (conv) {
+            return conv->Convert(conv, ref, reference);
+        }
+
         return ChannelValueDataSetFromReference(&ref->ref.value->value, ref->ref.value->type, reference);
     } else {
         // slice
@@ -42,6 +46,19 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
     return RETURN_OK;
 }
 
+ChannelType * ChannelValueRefGetType(ChannelValueRef * ref) {
+    switch (ref->type) {
+        case CHANNEL_VALUE_REF_VALUE:
+            return ChannelValueType(ref->ref.value);
+        case CHANNEL_VALUE_REF_SLICE:
+            mcx_log(LOG_ERROR, "TODO - change the dimension in ArraySlice to a type and return that to avoid memory allocation");
+            return NULL;
+        default:
+            mcx_log(LOG_ERROR, "Invalid internal channel value reference type (%d)", ref->type);
+            return NULL;
+    }
+}
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index 13ab9e5..a1a7990 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -14,6 +14,8 @@
 #include "CentralParts.h"
 #include "core/channels/ChannelDimension.h"
 
+#include "core/Conversion.h"
+
 
 #ifdef __cplusplus
 extern "C" {
@@ -43,8 +45,8 @@ typedef struct ChannelValueRef {
     } ref;
 } ChannelValueRef;
 
-
-McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference);
+McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, TypeConversion * typeConv);
+ChannelType * ChannelValueRefGetType(const ChannelValueRef * ref);
 
 
 #ifdef __cplusplus

From f01ff41c033ec49714e8bf5c6e5e6ddd15c438b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 3 Nov 2021 08:38:27 +0100
Subject: [PATCH 078/166] Fix ChannelValueRef definition

---
 src/core/channels/ChannelValueReference.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index a1a7990..7290a4d 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -36,7 +36,7 @@ typedef enum ChannelValueRefType {
 extern const struct ObjectClass _ChannelValueRef;
 
 typedef struct ChannelValueRef {
-    Object * _;
+    Object _;
 
     ChannelValueRefType type;
     union {

From ff0c24e37e5a19150a89f3d9912f760a759aa4dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 3 Nov 2021 15:38:13 +0100
Subject: [PATCH 079/166] Define 1 type conversion per connection

---
 src/core/Conversion.h            |  3 ++
 src/core/channels/Channel.c      | 52 ++++++++++++++++++--------------
 src/core/channels/Channel_impl.h |  2 +-
 3 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/src/core/Conversion.h b/src/core/Conversion.h
index 22cf68e..dbef44d 100644
--- a/src/core/Conversion.h
+++ b/src/core/Conversion.h
@@ -119,6 +119,9 @@ typedef struct ChannelValueRef ChannelValueRef;
 typedef struct TypeConversion TypeConversion;
 
 typedef McxStatus (*fTypeConversionSetup)(TypeConversion * conversion, const ChannelType * fromType, const ChannelType * toType);
+
+// TODO: Ideally the `src` argument would also be ChannelValueRef, but that requires quite of lot of changes
+//       in the API of databus definition (i.e. DatabusSetIn(Out)Reference)
 typedef McxStatus (*fTypeConversionConvert)(TypeConversion * conversion, ChannelValueRef * dest, void * src);
 
 extern const struct ObjectClass _TypeConversion;
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 6e756cc..b84c885 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -99,8 +99,12 @@ static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
     data->reference  = NULL;
     data->type = ChannelTypeClone(&ChannelTypeUnknown);
 
+    data->typeConversions = (ObjectContainer *) object_create(ObjectContainer);
+    if (!data->typeConversions) {
+        return NULL;
+    }
+
     data->unitConversion = NULL;
-    data->typeConversion = NULL;
     data->linearConversion = NULL;
     data->rangeConversion = NULL;
 
@@ -110,12 +114,13 @@ static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
 }
 
 static void ChannelInDataDestructor(ChannelInData * data) {
+    // clean up conversion objects
+    data->typeConversions->DestroyObjects(data->typeConversions);
+    object_destroy(data->typeConversions);
+
     if (data->unitConversion) {
         object_destroy(data->unitConversion);
     }
-    if (data->typeConversion) {
-        object_destroy(data->typeConversion);
-    }
     if (data->linearConversion) {
         object_destroy(data->linearConversion);
     }
@@ -197,34 +202,22 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
     size_t numConns = in->data->connections->Size(in->data->connections);
     for (i = 0; i < numConns; i++) {
         Connection * conn = (Connection *) in->data->connections->At(in->data->connections, i);
+        TypeConversion * typeConv = (TypeConversion *) in->data->typeConversions->At(in->data->typeConversions, i);
         ChannelValueRef * valueRef = (ChannelValueRef *) in->data->valueReferences->At(in->data->valueReferences, i);
         ConnectionInfo * connInfo = &conn->info;
         char * connString = ConnectionInfoConnectionString(connInfo);
 
-        // TODO do we need this Init ???
-        /*ChannelValueDestructor(val);
-        ChannelValueInit(val, ChannelTypeClone(connInfo->GetType(connInfo)));*/
-
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
             mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection %s failed", ChannelInfoGetLogName(info), connString);
             return RETURN_ERROR;
         }
-        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), in->data->typeConversion)) {  // TODO conn->GetValueReference - let it maybe return our reference
+
+        // TODO: ideally make conn->GetValueReference return ChannelValueRef
+        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), typeConv)) {
             mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueRefSetFromReference for connection %s failed", ChannelInfoGetLogName(info), connString);
             return RETURN_ERROR;
         }
-
-        //// type
-        //// TODO per connection
-        //if (in->data->typeConversion) {
-        //    Conversion * conversion = (Conversion *) in->data->typeConversion;
-        //    retVal = conversion->convert(conversion, valueRef->ref.value);  // TODO convert valueRef directly
-        //    if (RETURN_OK != retVal) {
-        //        mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute type conversion", info->GetLogName(info));
-        //        return RETURN_ERROR;
-        //    }
-        //}
     }
 
 
@@ -396,10 +389,23 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
     // TODO - array
     // setup type conversion
     if (!ChannelTypeEq(inInfo->type, type)) {
-        in->data->typeConversion = (TypeConversion *) object_create(TypeConversion);
-        retVal = in->data->typeConversion->Setup(in->data->typeConversion, type, inInfo->type);
+        TypeConversion * typeConv = (TypeConversion *) object_create(TypeConversion);
+        retVal = typeConv->Setup(typeConv, type, inInfo->type);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "Port %s: Register inport connection: Could not set up type conversion", ChannelInfoGetLogName(inInfo));
+            return RETURN_ERROR;
+        }
+
+
+        retVal = in->data->typeConversions->PushBack(in->data->typeConversions, (Object *) typeConv);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "Port %s: Register inport connection: Could not add type conversion", ChannelInfoGetLogName(inInfo));
+            return RETURN_ERROR;
+        }
+    } else {
+        retVal = in->data->typeConversions->PushBack(in->data->typeConversions, NULL);
         if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Port %s: Set connection: Could not setup type conversion", ChannelInfoGetLogName(inInfo));
+            mcx_log(LOG_ERROR, "Port %s: Register inport connection: Could not add empty type conversion", ChannelInfoGetLogName(inInfo));
             return RETURN_ERROR;
         }
     }
diff --git a/src/core/channels/Channel_impl.h b/src/core/channels/Channel_impl.h
index 16d8d45..f0aca73 100644
--- a/src/core/channels/Channel_impl.h
+++ b/src/core/channels/Channel_impl.h
@@ -35,7 +35,7 @@ typedef struct ChannelInData {
     // ----------------------------------------------------------------------
     // Conversions
 
-    struct TypeConversion * typeConversion;
+    ObjectContainer * typeConversions;  // conversion objects (or NULL) for each connection in `connections`
     struct UnitConversion * unitConversion;
     struct LinearConversion * linearConversion;
     struct RangeConversion * rangeConversion;

From f7948fc2392d1b9b68dfb37761c592a00197e28b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 3 Nov 2021 16:04:47 +0100
Subject: [PATCH 080/166] Avoid getting connection string (mem allocation)
 during runtime

---
 src/core/channels/Channel.c | 102 +++++++++++++++++++++++++++---------
 1 file changed, 77 insertions(+), 25 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index b84c885..906312e 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -20,10 +20,79 @@
 #include "core/channels/ChannelValue.h"
 #include "core/channels/Channel_impl.h"
 
+#include <stdarg.h>
+#include <string.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+
+static McxStatus ReportConnStringError(ChannelInfo * chInfo, const char * prefixFmt, ConnectionInfo * connInfo, const char * fmt, ...) {
+    // create format string
+    const char * portPrefix = "Port %s: ";
+    char * connString = NULL;
+    char * formatString = NULL;
+    char * prefix = NULL;
+
+    if (connInfo) {
+        char * connString = ConnectionInfoConnectionString(connInfo);
+
+        prefix = (char *) mcx_calloc(strlen(portPrefix) - 2 /* format specifier %s */ +
+                                     strlen(prefixFmt) - (connInfo == NULL ? 0 : 2 /* format specifier %s */) +
+                                     (connInfo == NULL ? 0 : connString ? strlen(connString) : strlen("(null)")) +
+                                     strlen(ChannelInfoGetLogName(chInfo)) + 1 /* \0 at the end of the string */,
+                                     sizeof(char));
+        if (!prefix) {
+            goto cleanup;
+        }
+
+        sprintf(prefix, portPrefix, ChannelInfoGetLogName(chInfo));
+        sprintf(prefix + strlen(prefix), prefixFmt, connString);
+    } else {
+        prefix = (char *) mcx_calloc(strlen(portPrefix) - 2 /* format specifier %s */ + strlen(prefixFmt) +
+                                     strlen(ChannelInfoGetLogName(chInfo)) + 1 /* \0 at the end of the string */,
+                                     sizeof(char));
+        if (!prefix) {
+            goto cleanup;
+        }
+
+        sprintf(prefix, portPrefix, ChannelInfoGetLogName(chInfo));
+    }
+
+    formatString = (char *) mcx_calloc(strlen(fmt) + strlen(prefix) + 1, sizeof(char));
+    if (!formatString) {
+        goto cleanup;
+    }
+
+    strcat(formatString, prefix);
+    strcat(formatString, fmt);
+
+    // log error message
+    va_list args;
+    va_start(args, fmt);
+
+    mcx_vlog(LOG_ERROR, formatString, args);
+
+    va_end(args);
+
+cleanup:
+    // free connection string
+    if (connString) {
+        mcx_free(connString);
+    }
+
+    if (prefix) {
+        mcx_free(prefix);
+    }
+
+    if (formatString) {
+        mcx_free(formatString);
+    }
+
+    return RETURN_ERROR;
+}
+
 // ----------------------------------------------------------------------
 // Channel
 
@@ -202,21 +271,18 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
     size_t numConns = in->data->connections->Size(in->data->connections);
     for (i = 0; i < numConns; i++) {
         Connection * conn = (Connection *) in->data->connections->At(in->data->connections, i);
+        ConnectionInfo * connInfo = &conn->info;
         TypeConversion * typeConv = (TypeConversion *) in->data->typeConversions->At(in->data->typeConversions, i);
         ChannelValueRef * valueRef = (ChannelValueRef *) in->data->valueReferences->At(in->data->valueReferences, i);
-        ConnectionInfo * connInfo = &conn->info;
-        char * connString = ConnectionInfoConnectionString(connInfo);
 
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
-            mcx_log(LOG_ERROR, "Port %s: Update inport: UpdateToOutput of connection %s failed", ChannelInfoGetLogName(info), connString);
-            return RETURN_ERROR;
+            return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "UpdateToOutput failed");
         }
 
         // TODO: ideally make conn->GetValueReference return ChannelValueRef
         if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), typeConv)) {
-            mcx_log(LOG_ERROR, "Port %s: Update inport: ChannelValueRefSetFromReference for connection %s failed", ChannelInfoGetLogName(info), connString);
-            return RETURN_ERROR;
+            return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "ChannelValueRefSetFromReference failed");
         }
     }
 
@@ -335,7 +401,6 @@ static ObjectContainer * ChannelInGetConnections(ChannelIn * in) {
 
 static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connection, const char * unit, ChannelType * type) {
     ConnectionInfo * connInfo = &connection->info;
-    char * connString = ConnectionInfoConnectionString(connInfo);
     Channel * channel = (Channel *) in;
     ChannelInfo * inInfo = &channel->info;
 
@@ -343,9 +408,7 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
 
     retVal = in->data->connections->PushBack(in->data->connections, (Object *) connection);
     if (RETURN_OK != retVal) {
-        mcx_log(LOG_ERROR, "Port %s: Register inport connection %s: Could not register connection", ChannelInfoGetLogName(inInfo), connString);
-        mcx_free(connString);
-        return RETURN_ERROR;
+        return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not register connection");
     }
 
     // TODO setup valueReference
@@ -377,8 +440,7 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
                                                  unit,
                                                  inInfo->unitString);
         if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Port %s: Set inport connection: Could not setup unit conversion", ChannelInfoGetLogName(inInfo));
-            return RETURN_ERROR;
+            return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not set up unit conversion");
         }
 
         if (in->data->unitConversion->IsEmpty(in->data->unitConversion)) {
@@ -392,28 +454,18 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         TypeConversion * typeConv = (TypeConversion *) object_create(TypeConversion);
         retVal = typeConv->Setup(typeConv, type, inInfo->type);
         if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Port %s: Register inport connection: Could not set up type conversion", ChannelInfoGetLogName(inInfo));
-            return RETURN_ERROR;
+            return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not set up type conversion");
         }
 
 
         retVal = in->data->typeConversions->PushBack(in->data->typeConversions, (Object *) typeConv);
         if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Port %s: Register inport connection: Could not add type conversion", ChannelInfoGetLogName(inInfo));
-            return RETURN_ERROR;
+            return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not add type conversion");
         }
     } else {
         retVal = in->data->typeConversions->PushBack(in->data->typeConversions, NULL);
         if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Port %s: Register inport connection: Could not add empty type conversion", ChannelInfoGetLogName(inInfo));
-            return RETURN_ERROR;
-        }
-    }
-
-cleanup:
-    if (RETURN_ERROR == retVal) {
-        if (connString) {
-            mcx_free(connString);
+            return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not add empty type conversion");
         }
     }
 

From efcde0469b8480f5a51810a7e40855a46e3c718a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 3 Nov 2021 17:00:43 +0100
Subject: [PATCH 081/166] Fix vector integrator

---
 src/components/comp_vector_integrator.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 92e28fe..2d054a4 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -72,7 +72,7 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
         ChannelInfo * info = outInfo;
         ChannelType * type = info->type;
 
-        if (!ChannelTypeEq(type, &ChannelTypeDouble) || ChannelTypeIsArray(type)) {
+        if (!ChannelTypeEq(ChannelTypeBaseType(type), &ChannelTypeDouble)) {
             ComponentLog(comp, LOG_ERROR, "Inport %s: Invalid type", ChannelInfoGetName(info));
             return RETURN_ERROR;
         }
@@ -124,14 +124,14 @@ static McxStatus DoStep(Component * comp, size_t group, double time, double delt
 
             size_t j = 0;
             for (j = 0; j < mcx_array_num_elements(state); j++) {
-                ((double *)state->data)[j] = ((double *)state->data)[j] * ((double *)deriv->data)[j] + deltaTime;
+                ((double *)state->data)[j] = ((double *)state->data)[j] + ((double *)deriv->data)[j] * deltaTime;
             }
 
         } else {
             double * state = (double *) ChannelValueReference(&integrator->state[i]);
             double * deriv = (double *) ChannelValueReference(&integrator->deriv[i]);
 
-            (*state) = (*state) * (*deriv) + deltaTime;
+            (*state) = (*state) + (*deriv) * deltaTime;
         }
     }
 

From cb154dce4b50d07b81b6a87dde3ddf1386598a77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 4 Nov 2021 14:00:21 +0100
Subject: [PATCH 082/166] Make filtered connections operate on sliced data

---
 src/core/connections/FilteredConnection.c | 55 ++++++++++++++++++++---
 1 file changed, 50 insertions(+), 5 deletions(-)

diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 4140637..5901d6f 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -46,6 +46,32 @@ static void FilteredConnectionDataDestructor(FilteredConnectionData * data) {
 OBJECT_CLASS(FilteredConnectionData, Object);
 
 
+static ChannelType * SliceDimensionToType(ChannelType * sourceType, ChannelDimension * dimension) {
+    if (dimension) {
+        // source data is an array
+        size_t i = 0;
+        ChannelType * type = NULL;
+        size_t * dims = (size_t *) mcx_calloc(sizeof(size_t), dimension->num);
+
+        if (!dims) {
+            mcx_log(LOG_ERROR, "DetermineSliceType: Not enough memory for dimension calculation");
+            return NULL;
+        }
+
+        for (i = 0; i < dimension->num; i++) {
+            dims[i] = dimension->endIdxs[i] - dimension->startIdxs[i] + 1;    // indices are inclusive
+        }
+
+        type = ChannelTypeArray(ChannelTypeClone(ChannelTypeBaseType(sourceType)), dimension->num, dims);
+        mcx_free(dims);
+        return type;
+    } else {
+        // source data is a scalar
+        return ChannelTypeClone(sourceType);
+    }
+}
+
+
 static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * out,
                                          ChannelIn * in, ConnectionInfo * info) {
     FilteredConnection * filteredConnection = (FilteredConnection *) connection;
@@ -53,6 +79,8 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     ChannelInfo * sourceInfo = &((Channel *)out)->info;
     ChannelInfo * targetInfo = &((Channel *)in)->info;
 
+    ChannelType * storeType = NULL;
+
     McxStatus retVal = RETURN_OK;
 
     // Decoupling
@@ -64,14 +92,19 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     filteredConnection->data->filters = NULL;
     filteredConnection->data->numFilters = 0;
 
+    storeType = SliceDimensionToType(sourceInfo->type, info->sourceDimension);
+    if (!storeType) {
+        return RETURN_ERROR;
+    }
+
     // value store
-    ChannelValueInit(&filteredConnection->data->store, ChannelTypeClone(sourceInfo->type));
+    ChannelValueInit(&filteredConnection->data->store, storeType);  // steals ownership of storeType -> no clone needed
 
     // value reference
     connection->value_ = ChannelValueReference(&filteredConnection->data->store);
 
     // initialize the buffer for channel function calls
-    ChannelValueInit(&filteredConnection->data->updateBuffer, ChannelTypeClone(sourceInfo->type));
+    ChannelValueInit(&filteredConnection->data->updateBuffer, ChannelTypeClone(storeType));
 
     // Connection::Setup()
     // this has to be done last as it connects the channels
@@ -144,6 +177,18 @@ static McxStatus FilteredConnectionSetResult(FilteredConnection * connection, co
     return ChannelValueSetFromReference(&connection->data->store, value);
 }
 
+static size_t GetSliceShift(Connection * connection) {
+    Channel * channel = (Channel *) connection->GetSource(connection);
+    ChannelInfo * channelInfo = &channel->info;
+    ChannelDimension * sourceDimension = channelInfo->dimension;
+
+    ConnectionInfo * connInfo = connection->GetInfo(connection);
+    ChannelDimension * sliceDimension = connInfo->sourceDimension;
+
+    // only 1D at the moment
+    return sliceDimension->startIdxs[0] - sourceDimension->startIdxs[0];
+}
+
 static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInterval * time) {
     FilteredConnection * filteredConnection = (FilteredConnection *) connection;
     Channel * channel = (Channel *) connection->GetSource(connection);
@@ -155,8 +200,6 @@ static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInter
     }
 #endif
 
-    // TODO: copy only sourceDimension slice
-
     if (ChannelTypeIsScalar(info->type)) {
         ChannelFilter * filter = filteredConnection->GetWriteFilter(filteredConnection, 0);
         if (filter && time->startTime >= 0) {
@@ -165,6 +208,7 @@ static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInter
         }
     } else {
         size_t i = 0;
+        size_t shift = GetSliceShift(connection);
         ChannelValueData element;
         ChannelValueDataInit(&element, ChannelTypeBaseType(info->type));
 
@@ -173,7 +217,7 @@ static void FilteredConnectionUpdateFromInput(Connection * connection, TimeInter
 
             if (filter && time->startTime >= 0) {
                 ChannelValueData value = *(ChannelValueData *) channel->GetValueReference(channel);
-                mcx_array_get_elem(&value.a, i, &element);
+                mcx_array_get_elem(&value.a, i + shift, &element);
                 filter->SetValue(filter, time->startTime, element);
             }
         }
@@ -198,6 +242,7 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
     if (out->GetFunction(out)) {
         proc * p = (proc *) out->GetFunction(out);
 
+        // TODO: Update functions to only update the slices ?
         if (p->fn(time, p->env, &filteredConnection->data->updateBuffer) != 0) {
             mcx_log(LOG_ERROR, "FilteredConnection: Function failed");
             return RETURN_ERROR;

From 8ae0b54bb31e814925eee2d1f1cac42cf7c55356 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 5 Nov 2021 12:12:12 +0100
Subject: [PATCH 083/166] Drop indexed vector element indexing in connection
 definitions

---
 src/core/channels/ChannelDimension.c         | 68 ++++++++++++++++++++
 src/core/channels/ChannelDimension.h         |  2 +
 src/core/connections/ConnectionInfoFactory.c | 63 ++++++++++++++++++
 3 files changed, 133 insertions(+)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index ea3965e..a2ed9df 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -9,6 +9,7 @@
  ********************************************************************************/
 
 #include "core/channels/ChannelDimension.h"
+#include "util/stdlib.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -134,6 +135,73 @@ int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second) {
     return TRUE;
 }
 
+int ChannelDimensionIncludedIn(const ChannelDimension* first, const ChannelDimension* second) {
+    size_t i = 0;
+
+    if (!first && !second) {
+        return TRUE;
+    } else if (!first || !second) {
+        return FALSE;
+    }
+
+    if (first->num != second->num) {
+        return FALSE;  // only same number of dimensions is comparable
+    }
+
+    for (i = 0; i < first->num; i++) {
+        if (first->startIdxs[i] < second->startIdxs[i] || first->startIdxs[i] > second->endIdxs[i]) {
+            return FALSE;
+        }
+
+        if (first->endIdxs[i] > second->endIdxs[i] || first->endIdxs[i] < second->startIdxs[i]) {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+char * ChannelDimensionString(const ChannelDimension * dimension) {
+    char * str = NULL;
+    size_t length = 0;
+    size_t i = 0;
+    int n = 0;
+
+    if (!dimension) {
+        return NULL;
+    }
+
+    for (i = 0; i < dimension->num; i++) {
+        length += 1;                                        // '('
+        length += mcx_digits10(dimension->startIdxs[i]);    // a
+        length += 2;                                        // ', '
+        length += mcx_digits10(dimension->endIdxs[i]);      // b
+        length += 1;                                        // ')'
+    }
+
+    length += dimension->num - 1;                           // spaces between dimensions
+    length += 2;                                            // '[' at the beginning and ']' at the end
+    length += 1;                                            // '\0'
+
+    str = (char *) mcx_calloc(sizeof(char), length);
+    if (!str) {
+        mcx_log(LOG_ERROR, "ChannelDimensionString: Not enough memory");
+        return NULL;
+    }
+
+    n += sprintf(str, "[");
+    for (i = 0; i < dimension->num; i++) {
+        if (i > 0) {
+            n += sprintf(str + n, " ");
+        }
+        n += sprintf(str + n, "(%zu, %zu)", dimension->startIdxs[i], dimension->endIdxs[i]);
+    }
+    sprintf(str + n, "]");
+
+    return str;
+}
+
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index f654c3e..493adc3 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -34,6 +34,8 @@ ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 size_t ChannelDimensionNumElements(ChannelDimension * dimension);
 ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second);
+int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second);
+char * ChannelDimensionString(const ChannelDimension * dimension);
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index 4c1c23e..32079b9 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -104,6 +104,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
     {
         Databus * databus = info->sourceComponent->GetDatabus(info->sourceComponent);
         DatabusInfo * databusInfo = DatabusGetOutInfo(databus);
+        ChannelInfo * sourceInfo = NULL;
 
         char * inputFromChannel = connInput->fromType == ENDPOINT_SCALAR ? connInput->from.scalarEndpoint->channel :
                                                                            connInput->from.vectorEndpoint->channel;
@@ -137,6 +138,29 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             info->sourceDimension = sourceDimension;
         }
 
+        // check that the source endpoint "fits" into the channel
+        sourceInfo = DatabusInfoGetChannel(databusInfo, info->sourceChannel);
+        if (!ChannelDimensionIncludedIn(info->sourceDimension, sourceInfo->dimension)) {
+            char* channelDimString = ChannelDimensionString(sourceInfo->dimension);
+            char* connDimString = ChannelDimensionString(info->sourceDimension);
+            mcx_log(LOG_ERROR,
+                    "Connection: Dimension index mismatch between source port %s of element %s and the connection endpoint: %s vs %s",
+                    strFromChannel,
+                    info->sourceComponent->GetName(info->sourceComponent),
+                    channelDimString,
+                    connDimString);
+            retVal = RETURN_ERROR;
+
+            if (channelDimString) {
+                mcx_free(channelDimString);
+            }
+            if (connDimString) {
+                mcx_free(connDimString);
+            }
+
+            goto cleanup;
+        }
+
         info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
         if (info->sourceChannel < 0) {
             // the connection might be inverted, see SSP 1.0 specification (section 5.3.2.1, page 47)
@@ -159,6 +183,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
     {
         Databus * databus = info->targetComponent->GetDatabus(info->targetComponent);
         DatabusInfo * databusInfo = NULL;
+        ChannelInfo * targetInfo = NULL;
 
         char * inputToChannel = connInput->toType == ENDPOINT_SCALAR ? connInput->to.scalarEndpoint->channel :
                                                                        connInput->to.vectorEndpoint->channel;
@@ -201,6 +226,29 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             info->targetDimension = targetDimension;
         }
 
+        // check that the target endpoint "fits" into the channel
+        targetInfo = DatabusInfoGetChannel(databusInfo, info->targetChannel);
+        if (!ChannelDimensionIncludedIn(info->targetDimension, targetInfo->dimension)) {
+            char * channelDimString = ChannelDimensionString(targetInfo->dimension);
+            char * connDimString = ChannelDimensionString(info->targetDimension);
+            mcx_log(LOG_ERROR,
+                    "Connection: Dimension index mismatch between connection endpoint and the target port %s of element %s: %s vs %s",
+                    strToChannel,
+                    info->targetComponent->GetName(info->targetComponent),
+                    connDimString,
+                    channelDimString);
+            retVal = RETURN_ERROR;
+
+            if (channelDimString) {
+                mcx_free(channelDimString);
+            }
+            if (connDimString) {
+                mcx_free(connDimString);
+            }
+
+            goto cleanup;
+        }
+
         info->targetChannel = DatabusInfoGetChannelID(databusInfo, strToChannel);
         if (info->targetChannel < 0) {
             if (0 == connectionInverted) {
@@ -264,6 +312,21 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
         }
     }
 
+    {
+        // check that connection endpoint dimensions match
+        ChannelDimension * sourceDim = info->sourceDimension;
+        ChannelDimension * targetDim = info->targetDimension;
+
+        size_t numSourceElems = sourceDim ? ChannelDimensionNumElements(sourceDim) : 1;
+        size_t numTargetElems = targetDim ? ChannelDimensionNumElements(targetDim) : 1;
+
+        if (numSourceElems != numTargetElems) {
+            mcx_log(LOG_ERROR, "Connection: Lengths of vectors do not match");
+            retVal = RETURN_ERROR;
+            goto cleanup;
+        }
+    }
+
     // extrapolation
     if (connInput->interExtrapolationType.defined) {
         info->interExtrapolationType = connInput->interExtrapolationType.value;

From afa3ef0aa3083bf22b168e96e20d8399f124b904 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 8 Nov 2021 10:12:50 +0100
Subject: [PATCH 084/166] Add ChannelTypeNumElements

---
 src/core/channels/ChannelValue.c | 15 +++++++++++++++
 src/core/channels/ChannelValue.h |  2 ++
 2 files changed, 17 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 12a9fd0..91225ed 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -148,6 +148,21 @@ ChannelType * ChannelTypeBaseType(ChannelType * a) {
     }
 }
 
+size_t ChannelTypeNumElements(ChannelType * type) {
+    if (ChannelTypeIsArray(type)) {
+        size_t i = 0;
+        size_t num_elems = 1;
+
+        for (i = 0; i < type->ty.a.numDims; i++) {
+            num_elems *= type->ty.a.dims[i];
+        }
+
+        return num_elems;
+    } else {
+        return 1;
+    }
+}
+
 int ChannelTypeEq(ChannelType * a, ChannelType * b) {
     if (a->con == CHANNEL_ARRAY && b->con == CHANNEL_ARRAY) {
         size_t i = 0;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 34489b6..eb126db 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -65,6 +65,8 @@ int ChannelTypeIsScalar(ChannelType * a);
 int ChannelTypeIsArray(ChannelType * a);
 int ChannelTypeIsBinary(ChannelType * a);
 
+size_t ChannelTypeNumElements(ChannelType * type);
+
 ChannelType * ChannelTypeBaseType(ChannelType * a);
 
 int ChannelTypeEq(ChannelType * a, ChannelType * b);

From 1c1dd6048917d3d806a149548f1a537c43ece589 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 8 Nov 2021 10:15:36 +0100
Subject: [PATCH 085/166] Add const qualifiers

---
 src/core/channels/ChannelValue.c | 10 +++++-----
 src/core/channels/ChannelValue.h | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 91225ed..9922278 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -124,19 +124,19 @@ ChannelType * ChannelTypeArrayInner(ChannelType * array) {
     return array->ty.a.inner;
 }
 
-int ChannelTypeIsValid(ChannelType * a) {
+int ChannelTypeIsValid(const ChannelType * a) {
     return a->con != CHANNEL_UNKNOWN;
 }
 
-int ChannelTypeIsScalar(ChannelType * a) {
+int ChannelTypeIsScalar(const ChannelType * a) {
     return a->con != CHANNEL_ARRAY;
 }
 
-int ChannelTypeIsArray(ChannelType * a) {
+int ChannelTypeIsArray(const ChannelType * a) {
     return a->con == CHANNEL_ARRAY;
 }
 
-int ChannelTypeIsBinary(ChannelType * a) {
+int ChannelTypeIsBinary(const ChannelType * a) {
     return a->con == CHANNEL_BINARY || a->con == CHANNEL_BINARY_REFERENCE;
 }
 
@@ -148,7 +148,7 @@ ChannelType * ChannelTypeBaseType(ChannelType * a) {
     }
 }
 
-size_t ChannelTypeNumElements(ChannelType * type) {
+size_t ChannelTypeNumElements(const ChannelType * type) {
     if (ChannelTypeIsArray(type)) {
         size_t i = 0;
         size_t num_elems = 1;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index eb126db..c90990d 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -60,12 +60,12 @@ void ChannelTypeDestructor(ChannelType * type);
 
 ChannelType * ChannelTypeArrayInner(ChannelType * array);
 
-int ChannelTypeIsValid(ChannelType * a);
-int ChannelTypeIsScalar(ChannelType * a);
-int ChannelTypeIsArray(ChannelType * a);
-int ChannelTypeIsBinary(ChannelType * a);
+int ChannelTypeIsValid(const ChannelType * a);
+int ChannelTypeIsScalar(const ChannelType * a);
+int ChannelTypeIsArray(const ChannelType * a);
+int ChannelTypeIsBinary(const ChannelType * a);
 
-size_t ChannelTypeNumElements(ChannelType * type);
+size_t ChannelTypeNumElements(const ChannelType * type);
 
 ChannelType * ChannelTypeBaseType(ChannelType * a);
 

From b1ec11354ac29fc933c99c2db1a8433b66099a2f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 8 Nov 2021 10:34:39 +0100
Subject: [PATCH 086/166] Add type conversions scalar -> double array

---
 src/core/Conversion.c | 80 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index f3191d0..e344a96 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -11,6 +11,7 @@
 #include "CentralParts.h"
 #include "core/Conversion.h"
 #include "core/channels/ChannelValueReference.h"
+#include "core/channels/ChannelValue.h"
 #include "units/Units.h"
 
 #ifdef __cplusplus
@@ -560,6 +561,32 @@ static McxStatus CheckTypesValidForConversion(ChannelType * destType,
     return RETURN_OK;
 }
 
+static McxStatus CheckArrayReferencingOnlyOneElement(ChannelValueRef * dest, ChannelType * expectedDestType) {
+    if (!ChannelTypeIsArray(ChannelValueRefGetType(dest))) {
+        mcx_log(LOG_ERROR, "Type conversion: Destination value is not an array");
+        return RETURN_ERROR;
+    }
+
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelTypeBaseType(ChannelValueRefGetType(dest)), expectedDestType)) {
+        return RETURN_ERROR;
+    }
+
+    // check only one element referenced
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        if (ChannelTypeNumElements(dest->ref.value->type) != 1) {
+            mcx_log(LOG_ERROR, "Type conversion: Destination value is not an array of size 1");
+            return RETURN_ERROR;
+        }
+    } else {
+        if (ChannelDimensionNumElements(dest->ref.slice->dimension) != 1) {
+            mcx_log(LOG_ERROR, "Type conversion: Destination value is not an array of size 1");
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
 static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
     if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
@@ -630,6 +657,51 @@ static McxStatus TypeConversionConvertSingletonDoubleToDouble(Conversion * conve
     return RETURN_OK;
 }
 
+static McxStatus TypeConversionConvertDoubleToArrayDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeDouble)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(double *) dest->ref.value->value.a.data = *(double *) src;
+    } else {
+        double * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = *(double *) src;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertIntegerToArrayDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeDouble)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(double *) dest->ref.value->value.a.data = (double) *((int *) src);
+    } else {
+        double * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = (double) *((int *) src);
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertBoolToArrayDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeDouble)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(double *) dest->ref.value->value.a.data = *((int *) src) != 0 ? 1. : 0.;
+    } else {
+        double * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((int *) src) != 0 ? 1. : 0.;
+    }
+
+    return RETURN_OK;
+}
+
 static McxStatus TypeConversionConvertId(Conversion * conversion, ChannelValueRef * dest, void * src) {
     return ChannelValueRefSetFromReference(dest, src, NULL);
 }
@@ -640,6 +712,7 @@ static McxStatus TypeConversionSetup(TypeConversion * conversion,
 
     if (ChannelTypeEq(fromType, toType)) {
         conversion->Convert = TypeConversionConvertId;
+    /* scalar <-> scalar */
     } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
         conversion->Convert = TypeConversionConvertIntDouble;
     } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
@@ -652,8 +725,15 @@ static McxStatus TypeConversionSetup(TypeConversion * conversion,
         conversion->Convert = TypeConversionConvertBoolInteger;
     } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeBool)) {
         conversion->Convert = TypeConversionConvertIntegerBool;
+    /* scalar <-> array */
     } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
         conversion->Convert = TypeConversionConvertSingletonDoubleToDouble;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeDouble)) {
+        conversion->Convert = TypeConversionConvertDoubleToArrayDouble;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeDouble)) {
+        conversion->Convert = TypeConversionConvertIntegerToArrayDouble;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeDouble)) {
+        conversion->Convert = TypeConversionConvertBoolToArrayDouble;
     } else {
         mcx_log(LOG_ERROR, "Setup type conversion: Illegal conversion selected");
         return RETURN_ERROR;

From 6c24cb3f7528483076a15eadbe49ea4c95fa736d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 8 Nov 2021 10:42:54 +0100
Subject: [PATCH 087/166] Add ChannelDimension utility functions

---
 src/core/channels/ChannelDimension.c | 45 ++++++++++++++++++++++++++++
 src/core/channels/ChannelDimension.h |  2 ++
 2 files changed, 47 insertions(+)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index a2ed9df..266184d 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -201,6 +201,51 @@ char * ChannelDimensionString(const ChannelDimension * dimension) {
     return str;
 }
 
+McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension * base) {
+    size_t i = 0;
+    if (!target && !base) {
+        return RETURN_OK;
+    } else if (!target || !base) {
+        return RETURN_ERROR;
+    }
+
+    if (target->num != base->num) {
+        return RETURN_ERROR;
+    }
+
+    for (i = 0; i < target->num; i++) {
+        target->startIdxs[i] -= base->startIdxs[i];
+        target->endIdxs[i] -= base->startIdxs[i];
+    }
+
+    return RETURN_OK;
+}
+
+ChannelType * ChannelDimensionToChannelType(ChannelDimension * dimension, ChannelType * sourceType) {
+    if (dimension) {
+        // source data is an array
+        size_t i = 0;
+        ChannelType * type = NULL;
+        size_t * dims = (size_t *) mcx_calloc(sizeof(size_t), dimension->num);
+
+        if (!dims) {
+            mcx_log(LOG_ERROR, "ChannelDimensionToChannelType: Not enough memory for dimension calculation");
+            return NULL;
+        }
+
+        for (i = 0; i < dimension->num; i++) {
+            dims[i] = dimension->endIdxs[i] - dimension->startIdxs[i] + 1;    // indices are inclusive
+        }
+
+        type = ChannelTypeArray(ChannelTypeClone(ChannelTypeBaseType(sourceType)), dimension->num, dims);
+        mcx_free(dims);
+        return type;
+    } else {
+        // source data is a scalar
+        return ChannelTypeClone(sourceType);
+    }
+}
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 493adc3..555bb6a 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -36,6 +36,8 @@ ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second);
 int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second);
 char * ChannelDimensionString(const ChannelDimension * dimension);
+McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension * base);
+ChannelType * ChannelDimensionToChannelType(ChannelDimension * dimension, ChannelType * sourceType);
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */

From 7e7c135349728b6cdbfd24a6cbf66fc96971653c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 8 Nov 2021 10:48:14 +0100
Subject: [PATCH 088/166] Remove const qualifier

---
 src/core/channels/ChannelValueReference.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index 7290a4d..fc9d164 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -46,7 +46,7 @@ typedef struct ChannelValueRef {
 } ChannelValueRef;
 
 McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, TypeConversion * typeConv);
-ChannelType * ChannelValueRefGetType(const ChannelValueRef * ref);
+ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
 
 
 #ifdef __cplusplus

From 79dbc0c8fc6d105d97aa32d842ae2684a759956f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 8 Nov 2021 10:49:07 +0100
Subject: [PATCH 089/166] Extend ChannelValueRefSetFromReference to work with
 slice conversions

---
 src/core/channels/ChannelValueReference.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index e97dff5..9aa1165 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -41,6 +41,12 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
         // slice
 
         // TODO
+
+        if (conv) {
+            return conv->Convert(conv, ref, reference);
+        }
+
+        return ChannelValueDataSetFromReference(&ref->ref.slice->ref, ref->ref.value->type, reference);
     }
 
     return RETURN_OK;

From d08347c259011e72d6ac234298ec485edce70acc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 8 Nov 2021 10:52:53 +0100
Subject: [PATCH 090/166] Forward correct types to TypeConversion constructor

---
 src/core/channels/Channel.c | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 906312e..5c26b5f 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -426,6 +426,11 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         valRef->ref.slice = (ArraySlice *) mcx_calloc(1, sizeof(ArraySlice));
         valRef->ref.slice->ref = &channel->value;
         valRef->ref.slice->dimension = ChannelDimensionClone(dimension);
+        retVal = ChannelDimensionNormalize(valRef->ref.slice->dimension, inInfo->dimension);
+        if (retVal == RETURN_ERROR) {
+            ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Normalizing array slice dimension failed");
+            return RETURN_ERROR;
+        }
     } else {
         valRef->type = CHANNEL_VALUE_REF_VALUE;
         valRef->ref.value = &channel->value;
@@ -450,9 +455,15 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
 
     // TODO - array
     // setup type conversion
+
+    ChannelType * connType = ChannelDimensionToChannelType(connInfo->sourceDimension, type);
+    if (!connType) {
+        return RETURN_ERROR;
+    }
+
     if (!ChannelTypeEq(inInfo->type, type)) {
         TypeConversion * typeConv = (TypeConversion *) object_create(TypeConversion);
-        retVal = typeConv->Setup(typeConv, type, inInfo->type);
+        retVal = typeConv->Setup(typeConv, connType, inInfo->type);
         if (RETURN_ERROR == retVal) {
             return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not set up type conversion");
         }
@@ -469,6 +480,8 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         }
     }
 
+    ChannelTypeDestructor(connType);
+
     return retVal;
 }
 

From 1d51dd643b8477ee08d0eabd7b2f9c7a0bfc85db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 9 Nov 2021 14:38:07 +0100
Subject: [PATCH 091/166] Define writeResults flag as a scalar for SSP as well

---
 scripts/SSP/Ports.xsd  |  6 +-----
 src/reader/ssp/Ports.c | 15 +++------------
 2 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/scripts/SSP/Ports.xsd b/scripts/SSP/Ports.xsd
index dee8489..448802c 100644
--- a/scripts/SSP/Ports.xsd
+++ b/scripts/SSP/Ports.xsd
@@ -25,10 +25,6 @@
         <xs:list itemType="xs:int"/>
     </xs:simpleType>
 
-    <xs:simpleType name="BooleanVectorT">
-        <xs:list itemType="xs:boolean"/>
-    </xs:simpleType>
-
     <!-- common attributes -->
     <xs:attributeGroup name="CommonScalarPortAttributes">
         <xs:attribute name="writeResults" type="xs:boolean"/>
@@ -38,7 +34,7 @@
         <xs:attribute name="startIndex" type="xs:unsignedInt" use="required"/>
         <xs:attribute name="endIndex" type="xs:unsignedInt" use="required"/>
 
-        <xs:attribute name="writeResults" type="mse:BooleanVectorT"/>
+        <xs:attribute name="writeResults" type="xs:boolean"/>
     </xs:attributeGroup>
 
     <!-- scalar ports -->
diff --git a/src/reader/ssp/Ports.c b/src/reader/ssp/Ports.c
index 466520c..93c4b08 100644
--- a/src/reader/ssp/Ports.c
+++ b/src/reader/ssp/Ports.c
@@ -239,18 +239,9 @@ VectorPortInput * SSDReadComponentVectorPort(xmlNodePtr connectorNode, const cha
                         goto cleanup;
                     }
 
-                    {
-                        size_t n = 0;
-                        retVal = xml_attr_bool_vec(vectorNode, "writeResults", &n, &vectorPortInput->writeResults, SSD_OPTIONAL);
-                        if (RETURN_ERROR == retVal) {
-                            goto cleanup;
-                        } else if (RETURN_OK == retVal) {
-                            if (n != num) {
-                                mcx_log(LOG_ERROR, "xml_attr_vec_len: Expected length (%d) does not match actual length (%d)", num, n);
-                                retVal = RETURN_ERROR;
-                                goto cleanup;
-                            }
-                        }
+                    retVal = xml_opt_attr_bool(vectorNode, "writeResults", &vectorPortInput->writeResults);
+                    if (RETURN_ERROR == retVal) {
+                        goto cleanup;
                     }
                 }
             }

From 374777ec0ca518e3f0f0207602380371bde067ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 12:16:45 +0100
Subject: [PATCH 092/166] Define mcx_array_set_elem

---
 src/core/channels/ChannelValue.c | 66 ++++++++++++++++++++++++++++++++
 src/core/channels/ChannelValue.h |  1 +
 2 files changed, 67 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 9922278..60eaa44 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -271,6 +271,72 @@ McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * eleme
     return RETURN_OK;
 }
 
+McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * element) {
+    size_t num_elems = mcx_array_num_elements(a);
+
+    if (idx >= num_elems) {
+        mcx_log(LOG_ERROR, "mcx_array_set_elem: Array index out of range (idx: %d, num_elems: %d)", idx, num_elems);
+        return RETURN_ERROR;
+    }
+
+    switch (a->type->con) {
+        case CHANNEL_DOUBLE:
+            *((double *) a->data + idx) = element->d;
+            break;
+        case CHANNEL_INTEGER:
+            *((int *) a->data + idx) = element->i;
+            break;
+        case CHANNEL_BOOL:
+            *((int *) a->data + idx) = element->i != 0 ? 1 : 0;
+            break;
+        case CHANNEL_STRING:
+            {
+                char ** elements = (char **) a->data;
+
+                if (elements[idx]) {
+                    mcx_free(elements[idx]);
+                }
+
+                elements[idx] = (char *) mcx_calloc(strlen(element->s) + 1, sizeof(char));
+                if (!elements[idx]) {
+                    mcx_log(LOG_ERROR, "mcx_array_set_elem: Not enough memory");
+                    return RETURN_ERROR;
+                }
+
+                strncpy(elements[idx], element->s, strlen(element->s) + 1);
+                break;
+            }
+        case CHANNEL_BINARY:
+            {
+                binary_string * elements = (binary_string *) a->data;
+                if (elements[idx].data) {
+                    mcx_free(elements[idx].data);
+                }
+
+                elements[idx].len = element->b.len;
+                elements[idx].data = (char *) mcx_calloc(elements[idx].len, 1);
+                if (!elements[idx].data) {
+                    mcx_log(LOG_ERROR, "mcx_array_set_elem: Not enough memory");
+                    return RETURN_ERROR;
+                }
+                memcpy(elements[idx].data, element->b.data, elements[idx].len);
+                break;
+            }
+        case CHANNEL_BINARY_REFERENCE:
+            ((binary_string *) a->data)[idx].len = element->b.len;
+            ((binary_string *) a->data)[idx].data = element->b.data;
+            break;
+        case CHANNEL_ARRAY:
+            mcx_log(LOG_ERROR, "mcx_array_set_elem: Nested arrays are not supported");
+            return RETURN_ERROR;
+        default:
+            mcx_log(LOG_ERROR, "mcx_array_set_elem: Unknown array type");
+            return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
 void ChannelValueInit(ChannelValue * value, ChannelType * type) {
     value->type = type;
     ChannelValueDataInit(&value->value, type);
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index c90990d..9abe021 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -107,6 +107,7 @@ void mcx_array_destroy(mcx_array * a);
 int mcx_array_dims_match(mcx_array * a, mcx_array * b);
 size_t mcx_array_num_elements(mcx_array * a);
 McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element);
+McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 
 // TODO: change concrete types to McxDouble, McxInteger, etc
 union ChannelValueData {

From dc5fc053a6fc404b9157ba30cb0abfb957311fd9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 12:30:01 +0100
Subject: [PATCH 093/166] Define mcx_array_all and mcx_array_leq

---
 src/core/channels/ChannelValue.c | 48 ++++++++++++++++++++++++++++++++
 src/core/channels/ChannelValue.h |  4 +++
 2 files changed, 52 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 60eaa44..f6c1aba 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -203,6 +203,54 @@ void mcx_array_destroy(mcx_array * a) {
     if (a->type) { ChannelTypeDestructor(a->type); }
 }
 
+int mcx_array_all(mcx_array * a, mcx_array_predicate_f_ptr predicate) {
+    size_t i = 0;
+    ChannelValueData element = {0};
+
+    for (i = 0; i < mcx_array_num_elements(a); i++) {
+        if (RETURN_OK != mcx_array_get_elem(a, i, &element)) {
+            mcx_log(LOG_WARNING, "mcx_array_all: Getting element %zu failed", i);
+            return 0;
+        }
+
+        if (!predicate(&element, a->type)) {
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+int mcx_array_leq(const mcx_array * left, const mcx_array * right) {
+    size_t numElems = 0;
+    size_t i = 0;
+
+    if (!ChannelTypeEq(left->type, right->type)) {
+        return 0;
+    }
+
+    numElems = mcx_array_num_elements(left);
+
+    for (i = 0; i < numElems; i++) {
+        switch (left->type->con) {
+            case CHANNEL_DOUBLE:
+                if (((double *)left->data)[i] > ((double*)right->data)[i]) {
+                    return 0;
+                }
+                break;
+            case CHANNEL_INTEGER:
+                if (((int *) left->data)[i] > ((int *) right->data)[i]) {
+                    return 0;
+                }
+                break;
+            default:
+                return 0;
+        }
+    }
+
+    return 1;
+}
+
 int mcx_array_dims_match(mcx_array * a, mcx_array * b) {
     size_t i = 0;
 
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 9abe021..3fa733e 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -109,6 +109,10 @@ size_t mcx_array_num_elements(mcx_array * a);
 McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 
+typedef int (*mcx_array_predicate_f_ptr)(void * element, ChannelType * type);
+int mcx_array_all(mcx_array * a, mcx_array_predicate_f_ptr predicate);
+int mcx_array_leq(const mcx_array * left, const mcx_array * right);
+
 // TODO: change concrete types to McxDouble, McxInteger, etc
 union ChannelValueData {
     /* the order is significant. double needs to be the first entry for union initialization to work */

From b94183ceda353da32ff4ba27bd343023abcf388e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 12:31:22 +0100
Subject: [PATCH 094/166] Implement conditional ChannelValueData element-wise
 setter

---
 src/core/channels/ChannelValue.c | 55 ++++++++++++++++++++++++++++++++
 src/core/channels/ChannelValue.h |  5 +++
 2 files changed, 60 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index f6c1aba..a36d19a 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -690,6 +690,61 @@ void ChannelValueDataInit(ChannelValueData * data, ChannelType * type) {
     }
 }
 
+McxStatus ChannelValueDataSetFromReferenceIfElemwisePred(ChannelValueData * data,
+                                                         ChannelType * type,
+                                                         const void * reference,
+                                                         fChannelValueDataSetterPredicate predicate) {
+    if (!reference) {
+        return RETURN_OK;
+    }
+
+    if (ChannelTypeIsArray(type)) {
+        mcx_array * a = (mcx_array *) reference;
+        size_t i = 0;
+        ChannelValueData first = {0};
+        ChannelValueData second = {0};
+
+        if (!mcx_array_dims_match(&data->a, a)) {
+            mcx_log(LOG_ERROR, "ChannelValueDataSetFromReferenceIfElemwisePred: Mismatching array dimensions");
+            return RETURN_ERROR;
+        }
+
+        if (a->data == NULL || data->a.data == NULL) {
+            mcx_log(LOG_ERROR, "ChannelValueDataSetFromReferenceIfElemwisePred: Array data not initialized");
+            return RETURN_ERROR;
+        }
+
+        for (i = 0; i < mcx_array_num_elements(&data->a); i++) {
+            if (RETURN_OK != mcx_array_get_elem(&data->a, i, &first)) {
+                mcx_log(LOG_ERROR, "ChannelValueDataSetFromReferenceIfElemwisePred: Getting destination element %zu failed", i);
+                return RETURN_ERROR;
+            }
+
+            if (RETURN_OK != mcx_array_get_elem(a, i, &second)) {
+                mcx_log(LOG_ERROR, "ChannelValueDataSetFromReferenceIfElemwisePred: Getting source element %zu failed", i);
+                return RETURN_ERROR;
+            }
+
+            if (predicate(&first, &second, a->type)) {
+                mcx_array_set_elem(&data->a, i, &second);
+            }
+        }
+
+        return RETURN_OK;
+    } else {
+
+    }
+    switch (type->con) {
+        default:
+            if (predicate(data, reference, type)) {
+                return ChannelValueDataSetFromReference(data, type, reference);
+            }
+            break;
+    }
+
+    return RETURN_OK;
+}
+
 McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType * type, const void * reference) {
     if (!reference) { return RETURN_OK; }
 
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 3fa733e..025770d 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -141,6 +141,11 @@ void *      ChannelValueReference(ChannelValue * value);
 void ChannelValueDataDestructor(ChannelValueData * data, ChannelType * type);
 void ChannelValueDataInit(ChannelValueData * data, ChannelType * type);
 McxStatus ChannelValueDataSetFromReference(ChannelValueData * data, ChannelType * type, const void * reference);
+typedef int (*fChannelValueDataSetterPredicate)(void * first, void * second, ChannelType * type);
+McxStatus ChannelValueDataSetFromReferenceIfElemwisePred(ChannelValueData * data,
+                                                         ChannelType * type,
+                                                         const void * reference,
+                                                         fChannelValueDataSetterPredicate predicate);
 McxStatus ChannelValueDataSetToReference(ChannelValueData * value, ChannelType * type, void * reference);
 
 McxStatus ChannelValueSetFromReference(ChannelValue * value, const void * reference);

From 4536533204a9b29fa4c346342db39268d91e2452 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 12:33:08 +0100
Subject: [PATCH 095/166] Support array in RangeConversion

---
 src/core/Conversion.c            | 103 ++++++++++++++++++++++++-------
 src/core/channels/Channel.c      |  12 ++--
 src/core/channels/ChannelValue.c |   2 +
 3 files changed, 87 insertions(+), 30 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index e344a96..9851623 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -104,24 +104,56 @@ McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * va
     return retVal;
 }
 
+static int RangeConversionElemwiseLeq(void * first, void * second, ChannelType * type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) first <= *(double *) second;
+        case CHANNEL_INTEGER:
+            return *(int *) first <= *(int *) second;
+        default:
+            return 0;
+    }
+}
+
+static int RangeConversionElemwiseGeq(void * first, void * second, ChannelType * type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) first >= *(double *) second;
+        case CHANNEL_INTEGER:
+            return *(int *) first >= *(int *) second;
+        default:
+            return 0;
+    }
+}
+
 static McxStatus RangeConversionConvert(Conversion * conversion, ChannelValue * value) {
     RangeConversion * rangeConversion = (RangeConversion *) conversion;
-
     McxStatus retVal = RETURN_OK;
 
     if (!ChannelTypeEq(ChannelValueType(value), rangeConversion->type)) {
-        mcx_log(LOG_ERROR, "Range conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(rangeConversion->type));
+        mcx_log(LOG_ERROR,
+                "Range conversion: Value has wrong type %s, expected: %s",
+                ChannelTypeToString(ChannelValueType(value)),
+                ChannelTypeToString(rangeConversion->type));
         return RETURN_ERROR;
     }
 
-    if (rangeConversion->min && ChannelValueLeq(value, rangeConversion->min)) {
-        retVal = ChannelValueSet(value, rangeConversion->min);
+    if (rangeConversion->min) {
+        retVal = ChannelValueDataSetFromReferenceIfElemwisePred(&value->value,
+                                                                value->type,
+                                                                &rangeConversion->min->value,
+                                                                RangeConversionElemwiseLeq);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Range conversion: Set value to min failed");
             return RETURN_ERROR;
         }
-    } else if (rangeConversion->max && ChannelValueGeq(value, rangeConversion->max)) {
-        retVal = ChannelValueSet(value, rangeConversion->max);
+    }
+
+    if (rangeConversion->max) {
+        retVal = ChannelValueDataSetFromReferenceIfElemwisePred(&value->value,
+                                                                value->type,
+                                                                &rangeConversion->max->value,
+                                                                RangeConversionElemwiseGeq);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Range conversion: Set value to max failed");
             return RETURN_ERROR;
@@ -146,15 +178,11 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
         return RETURN_ERROR;
     }
 
-    if (min) {
-        conversion->type = ChannelValueType(min);
-    } else {
-        conversion->type = ChannelValueType(max);
-    }
+    conversion->type = ChannelTypeClone(ChannelValueType(min ? min : max));
 
-    if (!(ChannelTypeEq(conversion->type, &ChannelTypeDouble)
-          || ChannelTypeEq(conversion->type, &ChannelTypeInteger)
-          || ChannelTypeIsArray(conversion->type))) {
+    if (!(ChannelTypeEq(ChannelTypeBaseType(conversion->type), &ChannelTypeDouble) ||
+          ChannelTypeEq(ChannelTypeBaseType(conversion->type), &ChannelTypeInteger)))
+    {
         mcx_log(LOG_ERROR, "Range conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -165,22 +193,49 @@ static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue
     return RETURN_OK;
 }
 
+static int RangeConversionElementEqualsMin(void * element, ChannelType * type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) element == (-DBL_MAX);
+        case CHANNEL_INTEGER:
+            return *(int *) element == INT_MIN;
+        default:
+            return 0;
+    }
+}
+
+static int RangeConversionElementEqualsMax(void * element, ChannelType * type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) element == DBL_MAX;
+        case CHANNEL_INTEGER:
+            return *(int *) element == INT_MAX;
+        default:
+            return 0;
+    }
+}
+
 static int RangeConversionIsEmpty(RangeConversion * conversion) {
     switch (conversion->type->con) {
-    case CHANNEL_DOUBLE:
-        return
-            (!conversion->min || * (double *) ChannelValueReference(conversion->min) == (-DBL_MAX)) &&
-            (!conversion->max || * (double *) ChannelValueReference(conversion->max) ==   DBL_MAX);
-    case CHANNEL_INTEGER:
-        return
-            (!conversion->min || * (int *) ChannelValueReference(conversion->min) == INT_MIN) &&
-            (!conversion->max || * (int *) ChannelValueReference(conversion->max) == INT_MAX);
-    default:
-        return 1;
+        case CHANNEL_DOUBLE:
+            return (!conversion->min || *(double *) ChannelValueReference(conversion->min) == (-DBL_MAX)) &&
+                   (!conversion->max || *(double *) ChannelValueReference(conversion->max) == DBL_MAX);
+        case CHANNEL_INTEGER:
+            return (!conversion->min || *(int *) ChannelValueReference(conversion->min) == INT_MIN) &&
+                   (!conversion->max || *(int *) ChannelValueReference(conversion->max) == INT_MAX);
+        case CHANNEL_ARRAY:
+            return (!conversion->min || mcx_array_all(&conversion->min->value.a, RangeConversionElementEqualsMin)) &&
+                   (!conversion->max || mcx_array_all(&conversion->max->value.a, RangeConversionElementEqualsMax));
+        default:
+            return 1;
     }
 }
 
 static void RangeConversionDestructor(RangeConversion * rangeConversion) {
+    if (rangeConversion->type) {
+        ChannelTypeDestructor(rangeConversion->type);
+    }
+
     if (rangeConversion->min) {
         mcx_free(rangeConversion->min);
     }
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 5c26b5f..4d4ce08 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -519,8 +519,8 @@ static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
     // unit conversion is setup when a connection is set
 
     // min/max conversions are only used for double types
-    if (ChannelTypeEq(info->type, &ChannelTypeDouble)
-        || ChannelTypeEq(info->type, &ChannelTypeInteger))
+    if (ChannelTypeEq(ChannelTypeBaseType(info->type), &ChannelTypeDouble) ||
+        ChannelTypeEq(ChannelTypeBaseType(info->type), &ChannelTypeInteger))
     {
         ChannelValue * min = info->min;
         ChannelValue * max = info->max;
@@ -661,8 +661,8 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
 
 
     // min/max conversions are only used for double types
-    if (ChannelTypeEq(info->type, &ChannelTypeDouble)
-        || ChannelTypeEq(info->type, &ChannelTypeInteger))
+    if (ChannelTypeEq(ChannelTypeBaseType(info->type), &ChannelTypeDouble)
+        || ChannelTypeEq(ChannelTypeBaseType(info->type), &ChannelTypeInteger))
     {
         out->data->rangeConversion = (RangeConversion *) object_create(RangeConversion);
         retVal = out->data->rangeConversion->Setup(out->data->rangeConversion, min, max);
@@ -885,8 +885,8 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
         }
 
         // Apply conversion
-        if (ChannelTypeEq(info->type, &ChannelTypeDouble) ||
-            ChannelTypeEq(info->type, &ChannelTypeInteger)) {
+        if (ChannelTypeEq(ChannelTypeBaseType(info->type), &ChannelTypeDouble) ||
+            ChannelTypeEq(ChannelTypeBaseType(info->type), &ChannelTypeInteger)) {
             ChannelValue * val = &channel->value;
 
             // range
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index a36d19a..139e48a 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -1011,6 +1011,8 @@ int ChannelValueLeq(ChannelValue * val1, ChannelValue * val2) {
         return val1->value.d <= val2->value.d;
     case CHANNEL_INTEGER:
         return val1->value.i <= val2->value.i;
+    case CHANNEL_ARRAY:
+        return mcx_array_leq(&val1->value.a, &val2->value.a);
     default:
         return 0;
     }

From a5c6860b20ea5ec556d10917266245d7432b68b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 12:35:38 +0100
Subject: [PATCH 096/166] Do not define ChannelValueArrays if
 min/max/offset/etc. are not specified

---
 src/core/Databus.c | 60 +++++++++++++++++++++++++++-------------------
 1 file changed, 36 insertions(+), 24 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 067b514..85da1a2 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -115,40 +115,52 @@ static ChannelInfo * DatabusReadPortInput(PortInput * input) {
             goto vector_cleanup_0;
         }
 
-        info->min = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->min);
-        if (!info->min) {
-            retVal = RETURN_ERROR;
-            goto vector_cleanup_0;
+        if (vectorPortInput->min) {
+            info->min = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->min);
+            if (!info->min) {
+                retVal = RETURN_ERROR;
+                goto vector_cleanup_0;
+            }
         }
 
-        info->max = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->max);
-        if (!info->max) {
-            retVal = RETURN_ERROR;
-            goto vector_cleanup_0;
+        if (vectorPortInput->max) {
+            info->max = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->max);
+            if (!info->max) {
+                retVal = RETURN_ERROR;
+                goto vector_cleanup_0;
+            }
         }
 
-        info->scale = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->scale);
-        if (!info->scale) {
-            retVal = RETURN_ERROR;
-            goto vector_cleanup_0;
+        if (vectorPortInput->scale) {
+            info->scale = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->scale);
+            if (!info->scale) {
+                retVal = RETURN_ERROR;
+                goto vector_cleanup_0;
+            }
         }
 
-        info->offset = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->offset);
-        if (!info->offset) {
-            retVal = RETURN_ERROR;
-            goto vector_cleanup_0;
+        if (vectorPortInput->offset) {
+            info->offset = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->offset);
+            if (!info->offset) {
+                retVal = RETURN_ERROR;
+                goto vector_cleanup_0;
+            }
         }
 
-        info->initialValue = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->initial);
-        if (!info->initialValue) {
-            retVal = RETURN_ERROR;
-            goto vector_cleanup_0;
+        if (vectorPortInput->initial) {
+            info->initialValue = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->initial);
+            if (!info->initialValue) {
+                retVal = RETURN_ERROR;
+                goto vector_cleanup_0;
+            }
         }
 
-        info->defaultValue = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->default_);
-        if (!info->defaultValue) {
-            retVal = RETURN_ERROR;
-            goto vector_cleanup_0;
+        if (vectorPortInput->default_) {
+            info->defaultValue = ChannelValueNewArray(1, dims, vectorPortInput->type, vectorPortInput->default_);
+            if (!info->defaultValue) {
+                retVal = RETURN_ERROR;
+                goto vector_cleanup_0;
+            }
         }
 
         if (vectorPortInput->writeResults.defined) {

From 85b9c3c38ba3b23315da915efc6964b74dd34de8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 12:36:20 +0100
Subject: [PATCH 097/166] Fix ChannelDimensionNormalize

---
 src/core/channels/ChannelDimension.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index 266184d..1b42ef4 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -214,8 +214,8 @@ McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension
     }
 
     for (i = 0; i < target->num; i++) {
-        target->startIdxs[i] -= base->startIdxs[i];
         target->endIdxs[i] -= base->startIdxs[i];
+        target->startIdxs[i] -= base->startIdxs[i];
     }
 
     return RETURN_OK;

From ba594c25c1e41b957cb94d3e20eb17349a7867dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 14:13:16 +0100
Subject: [PATCH 098/166] Define scale and offset operation on ChannelValue

---
 src/core/channels/ChannelValue.c | 53 ++++++++++++++++++++++++++++++++
 src/core/channels/ChannelValue.h |  4 +++
 2 files changed, 57 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 139e48a..4e23412 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -285,6 +285,19 @@ size_t mcx_array_num_elements(mcx_array * a) {
     return n;
 }
 
+McxStatus mcx_array_map(mcx_array * a, mcx_array_map_f_ptr fn, void * ctx) {
+    size_t num_elems = mcx_array_num_elements(a);
+    size_t i = 0;
+
+    for (i = 0; i < num_elems; i++) {
+        if (fn((char *) a->data + i * ChannelValueTypeSize(a->type), i, a->type, ctx)) {
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
 McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element) {
     size_t num_elems = mcx_array_num_elements(a);
 
@@ -1051,6 +1064,24 @@ int ChannelValueEq(ChannelValue * val1, ChannelValue * val2) {
     }
 }
 
+static int ChannelValueArrayElemAddOffset(void * elem, size_t idx, ChannelType * type, void * ctx) {
+    mcx_array * offset = (mcx_array *) ctx;
+
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            *(double *) elem = *(double *) elem + ((double *) offset->data)[idx];
+            break;
+        case CHANNEL_INTEGER:
+            *(int *) elem = *(int *) elem + ((int *) offset->data)[idx];
+            break;
+        default:
+            mcx_log(LOG_ERROR, "ChannelValueArrayElemAddOffset: Type %s not allowed", ChannelTypeToString(type));
+            return 1;
+    }
+
+    return 0;
+}
+
 McxStatus ChannelValueAddOffset(ChannelValue * val, ChannelValue * offset) {
     if (!ChannelTypeEq(val->type, offset->type)) {
         mcx_log(LOG_ERROR, "Port: Add offset: Mismatching types. Value type: %s, offset type: %s",
@@ -1065,12 +1096,32 @@ McxStatus ChannelValueAddOffset(ChannelValue * val, ChannelValue * offset) {
     case CHANNEL_INTEGER:
         val->value.i += offset->value.i;
         return RETURN_OK;
+    case CHANNEL_ARRAY:
+        return mcx_array_map(&val->value.a, ChannelValueArrayElemAddOffset, &offset->value.a);
     default:
         mcx_log(LOG_ERROR, "Port: Add offset: Type %s not allowed", ChannelTypeToString(ChannelValueType(val)));
         return RETURN_ERROR;
     }
 }
 
+static int ChannelValueArrayElemScale(void * elem, size_t idx, ChannelType * type, void * ctx) {
+    mcx_array * factor = (mcx_array *) ctx;
+
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            *(double *) elem = *(double *) elem * ((double *) factor->data)[idx];
+            break;
+        case CHANNEL_INTEGER:
+            *(int *) elem = *(int *) elem * ((int *) factor->data)[idx];
+            break;
+        default:
+            mcx_log(LOG_ERROR, "ChannelValueArrayElemScale: Type %s not allowed", ChannelTypeToString(type));
+            return 1;
+    }
+
+    return 0;
+}
+
 McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
     if (!ChannelTypeEq(val->type, factor->type)) {
         mcx_log(LOG_ERROR, "Port: Scale: Mismatching types. Value type: %s, factor type: %s",
@@ -1085,6 +1136,8 @@ McxStatus ChannelValueScale(ChannelValue * val, ChannelValue * factor) {
     case CHANNEL_INTEGER:
         val->value.i *= factor->value.i;
         return RETURN_OK;
+    case CHANNEL_ARRAY:
+        return mcx_array_map(&val->value.a, ChannelValueArrayElemScale, &factor->value.a);
     default:
         mcx_log(LOG_ERROR, "Port: Scale: Type %s not allowed", ChannelTypeToString(ChannelValueType(val)));
         return RETURN_ERROR;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 025770d..53fe10b 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -106,6 +106,10 @@ McxStatus mcx_array_init(mcx_array * a, size_t numDims, size_t * dims, ChannelTy
 void mcx_array_destroy(mcx_array * a);
 int mcx_array_dims_match(mcx_array * a, mcx_array * b);
 size_t mcx_array_num_elements(mcx_array * a);
+
+typedef int (*mcx_array_map_f_ptr)(void * element, size_t idx, ChannelType * type, void * ctx);
+
+McxStatus mcx_array_map(mcx_array * a, mcx_array_map_f_ptr fn, void * ctx);
 McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 

From e3105627f4a07c49b98716513f72ae5f232962ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 10 Nov 2021 14:14:17 +0100
Subject: [PATCH 099/166] Linear conversion for arrays

---
 src/core/Conversion.c | 47 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 37 insertions(+), 10 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 9851623..5762663 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -501,20 +501,18 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
     }
 
     if (factor && offset && !ChannelTypeEq(ChannelValueType(factor), ChannelValueType(offset))) {
-        mcx_log(LOG_WARNING, "Linear conversion: Types of factor value (%s) and offset value (%s) do not match",
-            ChannelTypeToString(ChannelValueType(factor)), ChannelTypeToString(ChannelValueType(offset)));
+        mcx_log(LOG_WARNING,
+                "Linear conversion: Types of factor value (%s) and offset value (%s) do not match",
+                ChannelTypeToString(ChannelValueType(factor)),
+                ChannelTypeToString(ChannelValueType(offset)));
         return RETURN_ERROR;
     }
 
-    if (factor) {
-        conversion->type = ChannelValueType(factor);
-    } else {
-        conversion->type = ChannelValueType(offset);
-    }
+    conversion->type = ChannelTypeClone(ChannelValueType(factor ? factor : offset));
 
-    if (!(ChannelTypeEq(conversion->type, &ChannelTypeDouble)
-          || ChannelTypeEq(conversion->type, &ChannelTypeInteger)
-          || ChannelTypeIsArray(conversion->type))) {
+    if (!(ChannelTypeEq(ChannelTypeBaseType(conversion->type), &ChannelTypeDouble) ||
+          ChannelTypeEq(ChannelTypeBaseType(conversion->type), &ChannelTypeInteger)))
+    {
         mcx_log(LOG_WARNING, "Linear conversion is not defined for type %s", ChannelTypeToString(conversion->type));
         return RETURN_ERROR;
     }
@@ -525,6 +523,28 @@ static McxStatus LinearConversionSetup(LinearConversion * conversion, ChannelVal
     return RETURN_OK;
 }
 
+static int LinearConversionElementEqualsOne(void* element, ChannelType* type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) element == 1.0;
+        case CHANNEL_INTEGER:
+            return *(int *) element == 1;
+        default:
+            return 0;
+    }
+}
+
+static int LinearConversionElementEqualsZero(void * element, ChannelType * type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) element == 0.0;
+        case CHANNEL_INTEGER:
+            return *(int *) element == 0;
+        default:
+            return 0;
+    }
+}
+
 static int LinearConversionIsEmpty(LinearConversion * conversion) {
     switch (conversion->type->con) {
     case CHANNEL_DOUBLE:
@@ -535,12 +555,19 @@ static int LinearConversionIsEmpty(LinearConversion * conversion) {
         return
             (!conversion->factor || * (int *) ChannelValueReference(conversion->factor) == 1) &&
             (!conversion->offset || * (int *) ChannelValueReference(conversion->offset) == 0);
+    case CHANNEL_ARRAY:
+        return (!conversion->factor || mcx_array_all(&conversion->factor->value.a, LinearConversionElementEqualsOne)) &&
+               (!conversion->offset || mcx_array_all(&conversion->offset->value.a, LinearConversionElementEqualsZero));
     default:
         return 1;
     }
 }
 
 static void LinearConversionDestructor(LinearConversion * linearConversion) {
+    if (linearConversion->type) {
+        ChannelTypeDestructor(linearConversion->type);
+    }
+
     if (linearConversion->factor) {
         mcx_free(linearConversion->factor);
     }

From 52bb364f3d0ea415bc4ca9eeb55be691d835cd77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 11 Nov 2021 10:00:33 +0100
Subject: [PATCH 100/166] Adapt Dependency matrix generation wrt. array
 channels

---
 src/core/SubModel.c | 122 ++++++++++++++++++++------------------------
 1 file changed, 55 insertions(+), 67 deletions(-)

diff --git a/src/core/SubModel.c b/src/core/SubModel.c
index eeb36ce..c2315d9 100644
--- a/src/core/SubModel.c
+++ b/src/core/SubModel.c
@@ -701,6 +701,7 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
                             ConnectionInfo * info = (ConnectionInfo *) infos->At(infos, i);
                             if (!ConnectionInfoIsDecoupled(info)) {
                                 allDecoupled = FALSE;
+                                break;
                             }
                         }
 
@@ -714,81 +715,68 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
             if (DEP_INDEPENDENT != dependency) {
                 ObjectContainer * infos = GetInConnectionInfos(targetComp, targetInChannelID);
                 ObjectContainer * conns = GetInConnections(targetComp, targetInChannelID);
-                size_t numInfos = infos->Size(infos);
-                size_t numConns = conns->Size(conns);
                 size_t i = 0;
 
-                int isDecoupled = TRUE;
-                size_t decoupleType = (size_t) -1;
-                int isActiveDependency = FALSE;
-
-                for (i = 0; i < numInfos; i++) {
-                    ConnectionInfo * info = (ConnectionInfo *) infos->At(infos, i);
-                    if (!ConnectionInfoIsDecoupled(info)) {
-                        isDecoupled = FALSE;
-                    }
-
-                    decoupleType &= info->decoupleType & (DECOUPLE_NEVER | DECOUPLE_IFNEEDED);
-                }
-
-                for (i = 0; i < numConns; i++) {
-                    Connection * conn = (Connection *) conns->At(conns, i);
-                    if (conn->IsActiveDependency(conn)) {
-                        isActiveDependency = TRUE;
-                        break;
-                    }
-                }
-
-                if (numInfos > 0 && decoupleType && !isDecoupled && numConns > 0 && isActiveDependency) {
-                    ConnectionInfo * info = (ConnectionInfo *) infos->At(infos, 0);
-
-                    Component * sourceComp = info->sourceComponent;
-                    size_t sourceOutGroup, sourceNode;
-                    Databus * db = targetComp->GetDatabus(targetComp);
-                    DatabusInfo * dbInfo = DatabusGetOutInfo(db);
-                    size_t numOutChannels = DatabusInfoGetChannelNum(dbInfo);
-
-                    if (INITIAL_DEPENDENCIES == depType) {
-                        sourceOutGroup = sourceComp->GetInitialOutGroup(sourceComp, info->sourceChannel);
-                    } else {
-                        sourceOutGroup = sourceComp->GetOutGroup(sourceComp, info->sourceChannel);
-                    }
+                for (i = 0; i < infos->Size(infos); i++) {
+                    ConnectionInfo * info = infos->At(infos, i);
+                    Connection * conn = conns->At(conns, i);
+
+                    if (info && (info->decoupleType & (DECOUPLE_NEVER | DECOUPLE_IFNEEDED)) && (!ConnectionInfoIsDecoupled(info)) &&
+                        conn && conn->IsActiveDependency(conn))
+                    {
+                        Component * sourceComp = info->sourceComponent;
+                        size_t sourceOutGroup, sourceNode;
+                        Databus * db = targetComp->GetDatabus(targetComp);
+                        DatabusInfo * dbInfo = DatabusGetOutInfo(db);
+                        size_t numOutChannels = DatabusInfoGetChannelNum(dbInfo);
+
+                        if (INITIAL_DEPENDENCIES == depType) {
+                            sourceOutGroup = sourceComp->GetInitialOutGroup(sourceComp, info->sourceChannel);
+                        } else {
+                            sourceOutGroup = sourceComp->GetOutGroup(sourceComp, info->sourceChannel);
+                        }
 
-                    sourceNode = SubModelGeneratorGetNodeID(subModelGenerator, sourceComp, sourceOutGroup);
+                        sourceNode = SubModelGeneratorGetNodeID(subModelGenerator, sourceComp, sourceOutGroup);
 
-                    if (SIZE_T_ERROR == sourceNode) {
-                        // source is not part of this submodel
-                        //   -> no dependency -> do nothing
-                        continue;
-                    }
+                        if (SIZE_T_ERROR == sourceNode) {
+                            // source is not part of this submodel
+                            //   -> no dependency -> do nothing
+                            continue;
+                        }
 
-                    if (INITIAL_DEPENDENCIES == depType) {
-                        // check if the target output has an exact initial value
-                        ChannelInfo * info = NULL;
-                        // check if target outputs even exits
-                        if (0 < numOutChannels) {
-                            info = DatabusGetOutChannelInfo(db, targetGroup);
-                            // initial outputs are exact only if specified
-                            if (info->initialValueIsExact && info->initialValue) {
-                                continue;
+                        if (INITIAL_DEPENDENCIES == depType) {
+                            // check if the target output has an exact initial value
+                            ChannelInfo * info = NULL;
+                            // check if target outputs even exits
+                            if (0 < numOutChannels) {
+                                info = DatabusGetOutChannelInfo(db, targetGroup);
+                                // initial outputs are exact only if specified
+                                if (info->initialValueIsExact && info->initialValue) {
+                                    continue;
+                                }
                             }
                         }
-                    }
-                    retVal = SetDependency(A, sourceNode, targetNode, DEP_DEPENDENT);
-                    if (RETURN_ERROR == retVal) {
-                        mcx_log(LOG_ERROR, "SetDependency failed in SubModelGeneratorCreateDependencyMatrix");
-                        mcx_free(A);
-                        return NULL;
-                    }
+                        retVal = SetDependency(A, sourceNode, targetNode, DEP_DEPENDENT);
+                        if (RETURN_ERROR == retVal) {
+                            mcx_log(LOG_ERROR, "SetDependency failed in SubModelGeneratorCreateDependencyMatrix");
+                            mcx_free(A);
+                            return NULL;
+                        }
 
-                    if (0 == numOutChannels && (INITIAL_DEPENDENCIES == depType) ) {
-                        mcx_log(LOG_DEBUG, "(%s,%d) -> (%s,-)",
-                            sourceComp->GetName(sourceComp), sourceOutGroup,
-                            targetComp->GetName(targetComp) );
-                    } else {
-                        mcx_log(LOG_DEBUG, "(%s,%d) -> (%s,%d)",
-                            sourceComp->GetName(sourceComp), sourceOutGroup,
-                            targetComp->GetName(targetComp), targetGroup);
+                        if (0 == numOutChannels && (INITIAL_DEPENDENCIES == depType)) {
+                            mcx_log(LOG_DEBUG,
+                                    "(%s,%d) -> (%s,-)",
+                                    sourceComp->GetName(sourceComp),
+                                    sourceOutGroup,
+                                    targetComp->GetName(targetComp));
+                        } else {
+                            mcx_log(LOG_DEBUG,
+                                    "(%s,%d) -> (%s,%d)",
+                                    sourceComp->GetName(sourceComp),
+                                    sourceOutGroup,
+                                    targetComp->GetName(targetComp),
+                                    targetGroup);
+                        }
                     }
                 }
             }

From a7d81f41ec62aca64dc0bd15d63de5171decd394 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 11 Nov 2021 10:07:06 +0100
Subject: [PATCH 101/166] Adapt UnitConversion to arrays

---
 src/core/Conversion.c                     | 58 +++++++++++++++++------
 src/core/Conversion.h                     |  9 ++--
 src/core/channels/Channel.c               | 57 +++++++++++++---------
 src/core/channels/ChannelDimension.c      | 34 +++++++++++++
 src/core/channels/ChannelDimension.h      |  1 +
 src/core/channels/ChannelValue.c          | 12 +++++
 src/core/channels/ChannelValue.h          |  2 +
 src/core/channels/ChannelValueReference.c | 48 +++++++++++++++++++
 src/core/channels/ChannelValueReference.h |  3 ++
 src/core/channels/Channel_impl.h          |  2 +-
 10 files changed, 184 insertions(+), 42 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 5762663..3d43ac8 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -265,6 +265,12 @@ OBJECT_CLASS(RangeConversion, Conversion);
 
 // ----------------------------------------------------------------------
 // Unit Conversion
+static double UnitConversionConvertValue(UnitConversion * conversion, double value) {
+    value = (value + conversion->source.offset) * conversion->source.factor;
+    value = (value / conversion->target.factor) - conversion->target.offset;
+
+    return value;
+}
 
 McxStatus ConvertUnit(const char * fromUnit, const char * toUnit, ChannelValue * value) {
     UnitConversion * unitConv = NULL;
@@ -306,12 +312,7 @@ static void UnitConversionConvertVector(UnitConversion * unitConversion, double
     size_t i;
     if (!unitConversion->IsEmpty(unitConversion)) {
         for (i = 0; i < vectorLength; i++) {
-            double val = vector[i];
-
-            val = (val + unitConversion->source.offset) * unitConversion->source.factor;
-            val = (val / unitConversion->target.factor) - unitConversion->target.offset;
-
-            vector[i] = val;
+            vector[i] = UnitConversionConvertValue(unitConversion, vector[i]);
         }
     }
 }
@@ -319,25 +320,53 @@ static void UnitConversionConvertVector(UnitConversion * unitConversion, double
 static McxStatus UnitConversionConvert(Conversion * conversion, ChannelValue * value) {
     UnitConversion * unitConversion = (UnitConversion *) conversion;
 
-    double val = 0.0;
-
-    if (!ChannelTypeEq(ChannelValueType(value), &ChannelTypeDouble)) {
+    if (!ChannelTypeEq(ChannelTypeBaseType(ChannelValueType(value)), &ChannelTypeDouble)) {
         mcx_log(LOG_ERROR, "Unit conversion: Value has wrong type %s, expected: %s", ChannelTypeToString(ChannelValueType(value)), ChannelTypeToString(&ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
-    val = * (double *) ChannelValueReference(value);
+    if (ChannelTypeIsArray(value->type)) {
+        size_t i = 0;
 
-    val = (val + unitConversion->source.offset) * unitConversion->source.factor;
-    val = (val / unitConversion->target.factor) - unitConversion->target.offset;
+        for (i = 0; i < mcx_array_num_elements(&value->value.a); i++) {
+            double * elem = (double *)mcx_array_get_elem_reference(&value->value.a, i);
+            if (!elem) {
+                return RETURN_ERROR;
+            }
 
-    if (RETURN_OK != ChannelValueSetFromReference(value, &val)) {
-        return RETURN_ERROR;
+            *elem = UnitConversionConvertValue(conversion, *elem);
+        }
+    } else {
+        double val = UnitConversionConvertValue(unitConversion, *(double *) ChannelValueReference(value));
+        if (RETURN_OK != ChannelValueSetFromReference(value, &val)) {
+            return RETURN_ERROR;
+        }
     }
 
     return RETURN_OK;
 }
 
+McxStatus UnitConversionValueRefConversion(void * element, ChannelType * type, void * ctx) {
+    double * elem = (double *) element;
+    UnitConversion * conversion = (UnitConversion *) ctx;
+
+    *elem = UnitConversionConvertValue(conversion, *elem);
+
+    return RETURN_OK;
+}
+
+static McxStatus UnitConversionConvertValueRef(UnitConversion * conversion, ChannelValueRef * ref) {
+    if (!ChannelTypeEq(ChannelTypeBaseType(ChannelValueRefGetType(ref)), &ChannelTypeDouble)) {
+        mcx_log(LOG_ERROR,
+                "Unit conversion: Value has wrong type %s, expected: %s",
+                ChannelTypeToString(ChannelTypeBaseType(ChannelValueRefGetType(ref))),
+                ChannelTypeToString(&ChannelTypeDouble));
+        return RETURN_ERROR;
+    }
+
+    return ChannelValueRefElemMap(ref, UnitConversionValueRefConversion, conversion);
+}
+
 static McxStatus UnitConversionSetup(UnitConversion * conversion,
                                      const char * fromUnit,
                                      const char * toUnit) {
@@ -385,6 +414,7 @@ static UnitConversion * UnitConversionCreate(UnitConversion * unitConversion) {
 
     conversion->convert = UnitConversionConvert;
     unitConversion->convertVector = UnitConversionConvertVector;
+    unitConversion->ConvertValueReference = UnitConversionConvertValueRef;
 
     unitConversion->Setup   = UnitConversionSetup;
     unitConversion->IsEmpty = UnitConversionIsEmpty;
diff --git a/src/core/Conversion.h b/src/core/Conversion.h
index dbef44d..7aa9b78 100644
--- a/src/core/Conversion.h
+++ b/src/core/Conversion.h
@@ -18,6 +18,9 @@
 extern "C" {
 #endif /* __cplusplus */
 
+
+typedef struct ChannelValueRef ChannelValueRef;
+
 typedef struct Conversion Conversion;
 
 typedef McxStatus (* fConversion)(Conversion * conversion, ChannelValue * value);
@@ -66,6 +69,7 @@ typedef void(*fUnitConversionVector)(UnitConversion * conversion, double * value
 
 typedef McxStatus (* fUnitConversionSetup)(UnitConversion * conversion, const char * fromUnit, const char * toUnit);
 typedef int (* fUnitConversionIsEmpty)(UnitConversion * conversion);
+typedef McxStatus (*fUnitConversionConvertValueRef)(UnitConversion * conversion, ChannelValueRef * ref);
 
 extern const struct ObjectClass _UnitConversion;
 
@@ -74,6 +78,7 @@ struct UnitConversion {
 
     fUnitConversionSetup Setup;
     fUnitConversionIsEmpty IsEmpty;
+    fUnitConversionConvertValueRef ConvertValueReference;
 
     si_def source;
     si_def target;
@@ -112,10 +117,6 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 
 // ----------------------------------------------------------------------
 // Type Conversion
-
-typedef struct ChannelValueRef ChannelValueRef;
-
-
 typedef struct TypeConversion TypeConversion;
 
 typedef McxStatus (*fTypeConversionSetup)(TypeConversion * conversion, const ChannelType * fromType, const ChannelType * toType);
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 4d4ce08..72361a4 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -172,8 +172,10 @@ static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
     if (!data->typeConversions) {
         return NULL;
     }
-
-    data->unitConversion = NULL;
+    data->unitConversions = (ObjectContainer *) object_create(ObjectContainer);
+    if (!data->unitConversions) {
+        return NULL;
+    }
     data->linearConversion = NULL;
     data->rangeConversion = NULL;
 
@@ -182,14 +184,16 @@ static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
     return data;
 }
 
+// TODO fix Create and Destructor to properly free memory in case of failure
+
 static void ChannelInDataDestructor(ChannelInData * data) {
     // clean up conversion objects
     data->typeConversions->DestroyObjects(data->typeConversions);
     object_destroy(data->typeConversions);
 
-    if (data->unitConversion) {
-        object_destroy(data->unitConversion);
-    }
+    data->unitConversions->DestroyObjects(data->unitConversions);
+    object_destroy(data->unitConversions);
+
     if (data->linearConversion) {
         object_destroy(data->linearConversion);
     }
@@ -273,6 +277,7 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         Connection * conn = (Connection *) in->data->connections->At(in->data->connections, i);
         ConnectionInfo * connInfo = &conn->info;
         TypeConversion * typeConv = (TypeConversion *) in->data->typeConversions->At(in->data->typeConversions, i);
+        UnitConversion * unitConv = (UnitConversion *) in->data->unitConversions->At(in->data->unitConversions, i);
         ChannelValueRef * valueRef = (ChannelValueRef *) in->data->valueReferences->At(in->data->valueReferences, i);
 
         /* Update the connection for the current time */
@@ -284,6 +289,14 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), typeConv)) {
             return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "ChannelValueRefSetFromReference failed");
         }
+
+        // unit conversion
+        if (unitConv) {
+            retVal = unitConv->ConvertValueReference(unitConv, valueRef);
+            if (RETURN_OK != retVal) {
+                return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "Unit conversion failed");
+            }
+        }
     }
 
 
@@ -292,17 +305,6 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         ChannelValue * val =  &channel->value;
 
 
-        // unit
-        if (in->data->unitConversion) {
-            Conversion * conversion = (Conversion *) in->data->unitConversion;
-            retVal = conversion->convert(conversion, val);
-            if (RETURN_OK != retVal) {
-                mcx_log(LOG_ERROR, "Port %s: Update inport: Could not execute unit conversion", ChannelInfoGetLogName(info));
-                return RETURN_ERROR;
-            }
-        }
-
-
         // linear
         if (in->data->linearConversion) {
             Conversion * conversion = (Conversion *) in->data->linearConversion;
@@ -439,17 +441,26 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
     retVal = in->data->valueReferences->PushBack(in->data->valueReferences, (Object *) valRef);
     // TODO check retVal
 
-    if (ChannelTypeEq(inInfo->type, &ChannelTypeDouble)) {
-        in->data->unitConversion = (UnitConversion *) object_create(UnitConversion);
-        retVal = in->data->unitConversion->Setup(in->data->unitConversion,
-                                                 unit,
-                                                 inInfo->unitString);
+    if (ChannelTypeEq(ChannelTypeBaseType(inInfo->type), &ChannelTypeDouble)) {
+        UnitConversion * conversion = (UnitConversion *) object_create(UnitConversion);
+
+        retVal = conversion->Setup(conversion, unit, inInfo->unitString);
         if (RETURN_ERROR == retVal) {
             return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not set up unit conversion");
         }
 
-        if (in->data->unitConversion->IsEmpty(in->data->unitConversion)) {
-            object_destroy(in->data->unitConversion);
+        if (conversion->IsEmpty(conversion)) {
+            object_destroy(conversion);
+        }
+
+        retVal = in->data->unitConversions->PushBack(in->data->unitConversions, (Object *) conversion);
+        if (RETURN_ERROR == retVal) {
+            return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not add unit conversion");
+        }
+    } else {
+        retVal = in->data->unitConversions->PushBack(in->data->unitConversions, NULL);
+        if (RETURN_ERROR == retVal) {
+            return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not add empty unit conversion");
         }
     }
 
diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index 1b42ef4..b408d94 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -161,6 +161,40 @@ int ChannelDimensionIncludedIn(const ChannelDimension* first, const ChannelDimen
     return TRUE;
 }
 
+size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, size_t * sizes) {
+    switch (dimension->num) {
+        case 1:
+            {
+                size_t idx = dimension->startIdxs[0] + elem_idx;
+                if (idx > dimension->endIdxs[0]) {
+                    mcx_log(LOG_ERROR, "ChannelDimensionGetIndex: Index out of range");
+                    break;
+                }
+
+                return idx;
+            }
+        case 2:
+            {
+                size_t dim_1_slice_size = dimension->endIdxs[1] - dimension->startIdxs[1] + 1;
+
+                size_t slice_idx_0 = elem_idx / dim_1_slice_size + dimension->startIdxs[0];
+                size_t slice_idx_1 = elem_idx % dim_1_slice_size + dimension->startIdxs[1];
+
+                if (slice_idx_0 > dimension->endIdxs[0] || slice_idx_1 > dimension->endIdxs[1]) {
+                    mcx_log(LOG_ERROR, "ChannelDimensionGetIndex: Index out of range");
+                    break;
+                }
+
+                return slice_idx_0 * sizes[1] + slice_idx_1;
+            }
+        default:
+            mcx_log(LOG_ERROR, "ChannelDimensionGetIndex: Number of dimensions not supported (%d)", dimension->num);
+            break;
+    }
+
+    return (size_t) -1;
+}
+
 char * ChannelDimensionString(const ChannelDimension * dimension) {
     char * str = NULL;
     size_t length = 0;
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 555bb6a..0a245b5 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -35,6 +35,7 @@ size_t ChannelDimensionNumElements(ChannelDimension * dimension);
 ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second);
 int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second);
+size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, size_t * sizes);
 char * ChannelDimensionString(const ChannelDimension * dimension);
 McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension * base);
 ChannelType * ChannelDimensionToChannelType(ChannelDimension * dimension, ChannelType * sourceType);
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 4e23412..02072f3 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -398,6 +398,18 @@ McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * eleme
     return RETURN_OK;
 }
 
+void * mcx_array_get_elem_reference(mcx_array * a, size_t idx) {
+    size_t num_elems = mcx_array_num_elements(a);
+    char * data = (char *) a->data;
+
+    if (idx >= num_elems) {
+        mcx_log(LOG_ERROR, "mcx_array_get_elem_reference: Array index out of range (idx: %d, num_elems: %d)", idx, num_elems);
+        return RETURN_ERROR;
+    }
+
+    return data + idx * ChannelValueTypeSize(a->type);
+}
+
 void ChannelValueInit(ChannelValue * value, ChannelType * type) {
     value->type = type;
     ChannelValueDataInit(&value->value, type);
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 53fe10b..784f93e 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -113,6 +113,8 @@ McxStatus mcx_array_map(mcx_array * a, mcx_array_map_f_ptr fn, void * ctx);
 McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 
+void * mcx_array_get_elem_reference(mcx_array * a, size_t idx);
+
 typedef int (*mcx_array_predicate_f_ptr)(void * element, ChannelType * type);
 int mcx_array_all(mcx_array * a, mcx_array_predicate_f_ptr predicate);
 int mcx_array_leq(const mcx_array * left, const mcx_array * right);
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 9aa1165..9b9d5a9 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -52,6 +52,54 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
     return RETURN_OK;
 }
 
+McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapFunc fn, void * ctx) {
+    switch (ref->type) {
+        case CHANNEL_VALUE_REF_VALUE:
+            if (ChannelTypeIsArray(ref->ref.value->type)) {
+                size_t i = 0;
+
+                for (i = 0; i < mcx_array_num_elements(&ref->ref.value->value.a); i++) {
+                    void * elem = mcx_array_get_elem_reference(&ref->ref.value->value.a, i);
+                    if (!elem) {
+                        return RETURN_ERROR;
+                    }
+
+                    if (RETURN_ERROR == fn(elem, ChannelValueType(ref->ref.value), ctx)) {
+                        return RETURN_ERROR;
+                    }
+                }
+
+                return RETURN_OK;
+            } else {
+                return fn(ChannelValueReference(ref->ref.value), ChannelValueType(ref->ref.value), ctx);
+            }
+        case CHANNEL_VALUE_REF_SLICE:
+            if (ChannelTypeIsArray(ref->ref.slice->ref->type)) {
+                size_t i = 0;
+
+                for (i = 0; i < ChannelDimensionNumElements(ref->ref.slice->dimension); i++) {
+                    size_t idx = ChannelDimensionGetIndex(ref->ref.slice->dimension, i, ref->ref.slice->ref->value.a.dims);
+
+                    void * elem = mcx_array_get_elem_reference(&ref->ref.slice->ref->value.a, idx);
+                    if (!elem) {
+                        return RETURN_ERROR;
+                    }
+
+                    if (RETURN_ERROR == fn(elem, ChannelValueType(ref->ref.slice->ref), ctx)) {
+                        return RETURN_ERROR;
+                    }
+                }
+
+                return RETURN_OK;
+            } else {
+                return fn(ChannelValueReference(ref->ref.slice->ref), ChannelValueType(ref->ref.slice->ref), ctx);
+            }
+        default:
+            mcx_log(LOG_ERROR, "ChannelValueRefElemMap: Invalid internal channel value reference type (%d)", ref->type);
+            return RETURN_ERROR;
+    }
+}
+
 ChannelType * ChannelValueRefGetType(ChannelValueRef * ref) {
     switch (ref->type) {
         case CHANNEL_VALUE_REF_VALUE:
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index fc9d164..d48e30e 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -48,6 +48,9 @@ typedef struct ChannelValueRef {
 McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, TypeConversion * typeConv);
 ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
 
+typedef McxStatus (*fChannelValueRefElemMapFunc)(void * element, ChannelType * type, void * ctx);
+McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapFunc fn, void * ctx);
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/channels/Channel_impl.h b/src/core/channels/Channel_impl.h
index f0aca73..e594a78 100644
--- a/src/core/channels/Channel_impl.h
+++ b/src/core/channels/Channel_impl.h
@@ -36,7 +36,7 @@ typedef struct ChannelInData {
     // Conversions
 
     ObjectContainer * typeConversions;  // conversion objects (or NULL) for each connection in `connections`
-    struct UnitConversion * unitConversion;
+    ObjectContainer * unitConversions;  // conversion objects (or NULL) for each connection in `connections`
     struct LinearConversion * linearConversion;
     struct RangeConversion * rangeConversion;
 

From 588461c6e3a3b61632a39133c9966bbffb618fa0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 11 Nov 2021 12:26:55 +0100
Subject: [PATCH 102/166] Fix log message

---
 src/core/Conversion.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 3d43ac8..5abbaa4 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -665,7 +665,7 @@ static McxStatus CheckTypesValidForConversion(ChannelType * destType,
     if (!ChannelTypeEq(destType, expectedDestType)) {
         mcx_log(LOG_ERROR,
                 "Type conversion: Destination value has wrong type %s, expected: %s",
-                ChannelTypeToString(ChannelValueType(destType)),
+                ChannelTypeToString(destType),
                 ChannelTypeToString(expectedDestType));
         return RETURN_ERROR;
     }

From 9b8f42e2c51b275bdee670daac04e478fcd779f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 11 Nov 2021 14:58:18 +0100
Subject: [PATCH 103/166] Implement ChannelValueRefSetFromReference

---
 src/core/channels/ChannelValueReference.c | 116 ++++++++++++++++++++--
 src/core/channels/ChannelValueReference.h |   3 +-
 2 files changed, 107 insertions(+), 12 deletions(-)

diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 9b9d5a9..875c09a 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -30,23 +30,117 @@ ChannelValueRef * ChannelValueRefCreate(ChannelValueRef * ref) {
 OBJECT_CLASS(ChannelValueRef, Object);
 
 
-McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, TypeConversion * conv) {
+McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, ChannelDimension * srcDimension, TypeConversion * conv) {
+    if (conv) {
+        return conv->Convert(conv, ref, reference);
+    }
+
     if (ref->type == CHANNEL_VALUE_REF_VALUE) {
-        if (conv) {
-            return conv->Convert(conv, ref, reference);
-        }
+        if (ChannelTypeIsArray(ref->ref.value->type)) {
+            mcx_array * destArray = &ref->ref.value->value.a;
+            mcx_array * srcArray = (mcx_array *) reference;
 
-        return ChannelValueDataSetFromReference(&ref->ref.value->value, ref->ref.value->type, reference);
-    } else {
-        // slice
+            if (srcArray->data == NULL || destArray->data == NULL) {
+                mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Empty array data given");
+                return RETURN_ERROR;
+            }
 
-        // TODO
+            if (srcArray->numDims == 1) {
+                // if there is only one dimension, values are sequentially stored in memory so we can use memcpy
+                // we could also check if for numDims > 1, values are sequentially stored or not, but there is no
+                // need for that now
+                size_t numBytes = ChannelValueTypeSize(destArray->type) * mcx_array_num_elements(destArray);
+                size_t srcOffset = srcDimension != 0 ? srcDimension->startIdxs[0] * ChannelValueTypeSize(srcArray->type) : 0;
+                void * sourceData = (char *) srcArray->data + srcOffset;
 
-        if (conv) {
-            return conv->Convert(conv, ref, reference);
+                memcpy(destArray->data, sourceData, numBytes);
+            } else {
+                // copy element by element
+                size_t i = 0;
+                size_t numElems = srcDimension ? ChannelDimensionNumElements(srcDimension) : mcx_array_num_elements(destArray);
+
+                for (i = 0; i < numElems; i++) {
+                    size_t srcIdx = srcDimension ? ChannelDimensionGetIndex(srcDimension, i, srcArray->dims) : i;
+                    void * srcElem = mcx_array_get_elem_reference(srcArray, srcIdx);
+                    void * destElem = mcx_array_get_elem_reference(destArray, i);
+                    memcpy(destElem, srcElem, ChannelValueTypeSize(destArray->type));
+                }
+            }
+
+            return RETURN_OK;
+        } else {
+            if (srcDimension) {
+                mcx_array * src = (mcx_array *) (reference);
+
+                if (ChannelDimensionNumElements(srcDimension) != 1) {
+                    mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Setting scalar value from an array");
+                    return RETURN_ERROR;
+                }
+
+                return ChannelValueDataSetFromReference(
+                    &ref->ref.value->value,
+                    ref->ref.value->type,
+                    mcx_array_get_elem_reference(src, ChannelDimensionGetIndex(srcDimension, 0, src->dims)));
+            } else {
+                return ChannelValueDataSetFromReference(&ref->ref.value->value, ref->ref.value->type, reference);
+            }
         }
+    } else {
+        if (ChannelTypeIsArray(ref->ref.slice->ref->type)) {
+            mcx_array * destArray = &ref->ref.slice->ref->value.a;
+            mcx_array * srcArray = (mcx_array *) reference;
 
-        return ChannelValueDataSetFromReference(&ref->ref.slice->ref, ref->ref.value->type, reference);
+            ChannelDimension * destDimension = ref->ref.slice->dimension;
+
+            if (srcArray->data == NULL || destArray->data == NULL) {
+                mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Empty array data given");
+                return RETURN_ERROR;
+            }
+
+            if (srcArray->numDims == 1) {
+                // if there is only one dimension, values are sequentially stored in memory so we can use memcpy
+                // we could also check if for numDims > 1, values are sequentially stored or not, but there is no
+                // need for that now
+                size_t numBytes = ChannelValueTypeSize(destArray->type) * (destDimension->endIdxs[0] - destDimension->startIdxs[0] + 1);
+                size_t destOffset = destDimension->startIdxs[0] * ChannelValueTypeSize(destArray->type);
+                void * destData = (char *) destArray->data + destOffset;
+                size_t srcOffset = srcDimension != 0 ? srcDimension->startIdxs[0] * ChannelValueTypeSize(srcArray->type) : 0;
+                void * sourceData = (char *) srcArray->data + srcOffset;
+
+                memcpy(destData, sourceData, numBytes);
+            } else {
+                // copy element by element
+                size_t i = 0;
+                size_t numElems = srcDimension ? ChannelDimensionNumElements(srcDimension) : mcx_array_num_elements(destArray);
+
+                for (i = 0; i < numElems; i++) {
+                    size_t srcIdx = srcDimension ? ChannelDimensionGetIndex(srcDimension, i, srcArray->dims) : i;
+                    size_t destIdx = ChannelDimensionGetIndex(destDimension, i, destArray->dims);
+
+                    void * srcElem = mcx_array_get_elem_reference(srcArray, srcIdx);
+                    void * destElem = mcx_array_get_elem_reference(destArray, destIdx);
+                    memcpy(destElem, srcElem, ChannelValueTypeSize(destArray->type));
+                }
+            }
+
+            return RETURN_OK;
+        } else {
+            if (srcDimension) {
+                mcx_array * src = (mcx_array *) (reference);
+
+                if (ChannelDimensionNumElements(srcDimension) != 1) {
+                    mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Setting scalar value from an array");
+                    return RETURN_ERROR;
+                }
+
+                return ChannelValueDataSetFromReference(
+                    &ref->ref.slice->ref->value,
+                    ref->ref.slice->ref->type,
+                    mcx_array_get_elem_reference(src, ChannelDimensionGetIndex(srcDimension, 0, src->dims)));
+            } else {
+                return ChannelValueDataSetFromReference(&ref->ref.slice->ref->value, ref->ref.slice->ref->type, reference);
+            }
+        }
     }
 
     return RETURN_OK;
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index d48e30e..a9b2a2f 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -45,7 +45,8 @@ typedef struct ChannelValueRef {
     } ref;
 } ChannelValueRef;
 
-McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, TypeConversion * typeConv);
+McxStatus
+ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, ChannelDimension * srcDimension, TypeConversion * typeConv);
 ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
 
 typedef McxStatus (*fChannelValueRefElemMapFunc)(void * element, ChannelType * type, void * ctx);

From 8e9946e468d45ed14f50b23a838f2dcc84bb9b45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 11 Nov 2021 14:58:54 +0100
Subject: [PATCH 104/166] Add a function to check whether dimensions are
 conformable (same sizes)

---
 src/core/channels/ChannelDimension.c | 22 ++++++++++++++++++++++
 src/core/channels/ChannelDimension.h |  1 +
 2 files changed, 23 insertions(+)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index b408d94..c3443bf 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -135,6 +135,28 @@ int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second) {
     return TRUE;
 }
 
+int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * second) {
+    size_t i = 0;
+
+    if (!first && !second) {
+        return TRUE;
+    } else if (!first || !second) {
+        return FALSE;
+    }
+
+    if (first->num != second->num) {
+        return FALSE;
+    }
+
+    for (i = 0; i < first->num; i++) {
+        if (first->endIdxs[i] - first->startIdxs[i] != second->endIdxs[i] - second->startIdxs[i]) {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
 int ChannelDimensionIncludedIn(const ChannelDimension* first, const ChannelDimension* second) {
     size_t i = 0;
 
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 0a245b5..3bf5f69 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -34,6 +34,7 @@ ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 size_t ChannelDimensionNumElements(ChannelDimension * dimension);
 ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second);
+int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * second);
 int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second);
 size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, size_t * sizes);
 char * ChannelDimensionString(const ChannelDimension * dimension);

From c177617ee45e1203450c14d9524b2f8b5cfb22bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:25:57 +0100
Subject: [PATCH 105/166] Add ChannelDimensionsConform

---
 src/core/channels/ChannelDimension.c | 15 +++++++++++++++
 src/core/channels/ChannelDimension.h |  1 +
 2 files changed, 16 insertions(+)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index c3443bf..cfb31a0 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -157,6 +157,21 @@ int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * sec
     return TRUE;
 }
 
+int ChannelDimensionsConform(ChannelDimension * dimension, size_t * dims, size_t numDims) {
+    size_t i = 0;
+    if (dimension->num != numDims) {
+        return 0;
+    }
+
+    for (i = 0; i < numDims; i++) {
+        if (dims[i] != (dimension->endIdxs[i] - dimension->startIdxs[i] + 1)) {
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
 int ChannelDimensionIncludedIn(const ChannelDimension* first, const ChannelDimension* second) {
     size_t i = 0;
 
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 3bf5f69..ae5681d 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -35,6 +35,7 @@ size_t ChannelDimensionNumElements(ChannelDimension * dimension);
 ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
 int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second);
 int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * second);
+int ChannelDimensionsConform(ChannelDimension * dimension, size_t * dims, size_t numDims);
 int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second);
 size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, size_t * sizes);
 char * ChannelDimensionString(const ChannelDimension * dimension);

From 4417a44abde2fafd7db91b9299f4219495a80f98 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:26:19 +0100
Subject: [PATCH 106/166] Add ChannelDimensionGetSliceIndex

---
 src/core/channels/ChannelDimension.c | 32 ++++++++++++++++++++++++++++
 src/core/channels/ChannelDimension.h |  1 +
 2 files changed, 33 insertions(+)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index cfb31a0..8064fd2 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -232,6 +232,38 @@ size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, s
     return (size_t) -1;
 }
 
+size_t ChannelDimensionGetSliceIndex(ChannelDimension * dimension, size_t slice_idx, size_t * dims) {
+    switch (dimension->num) {
+        case 1:
+            {
+                size_t idx = slice_idx - dimension->startIdxs[0];
+                if (idx > dimension->endIdxs[0]) {
+                    mcx_log(LOG_ERROR, "ChannelDimensionGetSliceIndex: Index out of range");
+                    break;
+                }
+
+                return idx;
+            }
+        case 2:
+            {
+                size_t idx_0 = slice_idx / dims[1];
+                size_t idx_1 = slice_idx - idx_0 * dims[1];
+
+                size_t slice_idx_0 = idx_0 - dimension->startIdxs[0];
+                size_t slice_idx_1 = idx_1 - dimension->startIdxs[1];
+
+                size_t dim_1_slice_size = dimension->endIdxs[1] - dimension->startIdxs[1] + 1;
+
+                return slice_idx_0 * dim_1_slice_size * slice_idx_1;
+            }
+        default:
+            mcx_log(LOG_ERROR, "ChannelDimensionGetSliceIndex: Number of dimensions not supported (%d)", dimension->num);
+            break;
+    }
+
+    return (size_t) -1;
+}
+
 char * ChannelDimensionString(const ChannelDimension * dimension) {
     char * str = NULL;
     size_t length = 0;
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index ae5681d..9f9da44 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -38,6 +38,7 @@ int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * sec
 int ChannelDimensionsConform(ChannelDimension * dimension, size_t * dims, size_t numDims);
 int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second);
 size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, size_t * sizes);
+size_t ChannelDimensionGetSliceIndex(ChannelDimension * dimension, size_t slice_idx, size_t * dims);
 char * ChannelDimensionString(const ChannelDimension * dimension);
 McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension * base);
 ChannelType * ChannelDimensionToChannelType(ChannelDimension * dimension, ChannelType * sourceType);

From ead2a514bece738c3f4b56bfb69e597761255938 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:27:11 +0100
Subject: [PATCH 107/166] Add Type and Dimension getters for Connection value
 reference

---
 src/core/Conversion.c                     |  2 +-
 src/core/channels/Channel.c               |  2 +-
 src/core/connections/Connection.c         | 15 +++++++++++++++
 src/core/connections/Connection.h         |  6 ++++++
 src/core/connections/FilteredConnection.c |  6 ++++++
 5 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 5abbaa4..d5e1d78 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -815,7 +815,7 @@ static McxStatus TypeConversionConvertBoolToArrayDouble(Conversion * conversion,
 }
 
 static McxStatus TypeConversionConvertId(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    return ChannelValueRefSetFromReference(dest, src, NULL);
+    return ChannelValueRefSetFromReference(dest, src, NULL, NULL);
 }
 
 static McxStatus TypeConversionSetup(TypeConversion * conversion,
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 72361a4..d2fb896 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -286,7 +286,7 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         }
 
         // TODO: ideally make conn->GetValueReference return ChannelValueRef
-        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), typeConv)) {
+        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), conn->GetValueDimension(conn), typeConv)) {
             return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "ChannelValueRefSetFromReference failed");
         }
 
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 8923fc1..e0f9d48 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1081,6 +1081,19 @@ static void ConnectionSetValueReference(Connection * connection, void * referenc
     connection->value_ = reference;
 }
 
+static ChannelDimension * ConnectionGetValueDimension(Connection * connection) {
+    return NULL;
+}
+
+static ChannelType * ConnectionGetValueType(Connection * connection) {
+    ChannelOut * out = connection->out_;
+    Channel * channel = (Channel *) out;
+    ChannelInfo * channelInfo = &channel->info;
+
+    return channelInfo->type;
+}
+
+
 static void ConnectionDestructor(Connection * connection) {
     ChannelValueDestructor(&connection->store_);
 }
@@ -1366,6 +1379,8 @@ static Connection * ConnectionCreate(Connection * connection) {
 
     connection->GetValueReference = ConnectionGetValueReference;
     connection->SetValueReference = ConnectionSetValueReference;
+    connection->GetValueDimension = ConnectionGetValueDimension;
+    connection->GetValueType = ConnectionGetValueType;
 
     connection->GetInfo   = ConnectionGetInfo;
 
diff --git a/src/core/connections/Connection.h b/src/core/connections/Connection.h
index 94d720f..ed2222b 100644
--- a/src/core/connections/Connection.h
+++ b/src/core/connections/Connection.h
@@ -51,6 +51,8 @@ typedef struct ChannelIn  * (* fConnectionGetTarget)(Connection * connection);
 
 typedef void * (* fConnectionGetValueReference)(Connection * connection);
 typedef void (* fConnectionSetValueReference)(Connection * connection, void * reference);
+typedef ChannelDimension * (*fConnectionGetValueDimension)(Connection * connection);
+typedef ChannelType * (*fConnectionGetValueType)(Connection * connection);
 
 typedef ConnectionInfo * (* fConnectionGetInfo)(Connection * connection);
 
@@ -132,6 +134,10 @@ struct Connection {
      */
     fConnectionGetValueReference GetValueReference;
 
+    fConnectionGetValueDimension GetValueDimension;
+
+    fConnectionGetValueType GetValueType;
+
     /**
      * Set the reference to the value of the connection. This value will be
      * updated on each call to UpdateToOutput().
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 5901d6f..46aa490 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -372,6 +372,11 @@ static McxStatus AddFilter(Connection * connection) {
     return RETURN_OK;
 }
 
+static ChannelType * FilteredConnectionGetValueType(Connection * connection) {
+    FilteredConnection * filteredConnection = (FilteredConnection *) connection;
+    return filteredConnection->data->store.type;
+}
+
 static void FilteredConnectionDestructor(FilteredConnection * filteredConnection) {
     object_destroy(filteredConnection->data);
 }
@@ -387,6 +392,7 @@ static FilteredConnection * FilteredConnectionCreate(FilteredConnection * filter
     connection->EnterCouplingStepMode     = FilteredConnectionEnterCouplingStepMode;
 
     connection->AddFilter = AddFilter;
+    connection->GetValueType = FilteredConnectionGetValueType;
 
     filteredConnection->GetReadFilter  = FilteredConnectionGetFilter;
     filteredConnection->GetWriteFilter = FilteredConnectionGetFilter;

From b5bea2a12072b4a8898ea485fbcaffb3b3c3a0d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:28:45 +0100
Subject: [PATCH 108/166] Extend arguments of fChannelValueRefElemMapFunc

---
 src/core/Conversion.c                     | 2 +-
 src/core/channels/ChannelValueReference.c | 8 ++++----
 src/core/channels/ChannelValueReference.h | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index d5e1d78..5754fd5 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -346,7 +346,7 @@ static McxStatus UnitConversionConvert(Conversion * conversion, ChannelValue * v
     return RETURN_OK;
 }
 
-McxStatus UnitConversionValueRefConversion(void * element, ChannelType * type, void * ctx) {
+McxStatus UnitConversionValueRefConversion(void * element, size_t idx, ChannelType * type, void * ctx) {
     double * elem = (double *) element;
     UnitConversion * conversion = (UnitConversion *) ctx;
 
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 875c09a..ac0a5d3 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -158,14 +158,14 @@ McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapF
                         return RETURN_ERROR;
                     }
 
-                    if (RETURN_ERROR == fn(elem, ChannelValueType(ref->ref.value), ctx)) {
+                    if (RETURN_ERROR == fn(elem, i, ChannelValueType(ref->ref.value), ctx)) {
                         return RETURN_ERROR;
                     }
                 }
 
                 return RETURN_OK;
             } else {
-                return fn(ChannelValueReference(ref->ref.value), ChannelValueType(ref->ref.value), ctx);
+                return fn(ChannelValueReference(ref->ref.value), 0, ChannelValueType(ref->ref.value), ctx);
             }
         case CHANNEL_VALUE_REF_SLICE:
             if (ChannelTypeIsArray(ref->ref.slice->ref->type)) {
@@ -179,14 +179,14 @@ McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapF
                         return RETURN_ERROR;
                     }
 
-                    if (RETURN_ERROR == fn(elem, ChannelValueType(ref->ref.slice->ref), ctx)) {
+                    if (RETURN_ERROR == fn(elem, idx, ChannelValueType(ref->ref.slice->ref), ctx)) {
                         return RETURN_ERROR;
                     }
                 }
 
                 return RETURN_OK;
             } else {
-                return fn(ChannelValueReference(ref->ref.slice->ref), ChannelValueType(ref->ref.slice->ref), ctx);
+                return fn(ChannelValueReference(ref->ref.slice->ref), 0, ChannelValueType(ref->ref.slice->ref), ctx);
             }
         default:
             mcx_log(LOG_ERROR, "ChannelValueRefElemMap: Invalid internal channel value reference type (%d)", ref->type);
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index a9b2a2f..87e5ba4 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -49,7 +49,7 @@ McxStatus
 ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, ChannelDimension * srcDimension, TypeConversion * typeConv);
 ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
 
-typedef McxStatus (*fChannelValueRefElemMapFunc)(void * element, ChannelType * type, void * ctx);
+typedef McxStatus (*fChannelValueRefElemMapFunc)(void * element, size_t idx, ChannelType * type, void * ctx);
 McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapFunc fn, void * ctx);
 
 

From c0baed100518b61788c185a18a1e09227410c12b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:30:31 +0100
Subject: [PATCH 109/166] Implement ChannelValueRefGetType

---
 src/core/channels/ChannelValueReference.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index ac0a5d3..9984d9f 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -199,8 +199,8 @@ ChannelType * ChannelValueRefGetType(ChannelValueRef * ref) {
         case CHANNEL_VALUE_REF_VALUE:
             return ChannelValueType(ref->ref.value);
         case CHANNEL_VALUE_REF_SLICE:
-            mcx_log(LOG_ERROR, "TODO - change the dimension in ArraySlice to a type and return that to avoid memory allocation");
-            return NULL;
+            // TODO (do we need to adapt the indices wrt. dimension) ?
+            return ChannelValueType(ref->ref.slice->ref);
         default:
             mcx_log(LOG_ERROR, "Invalid internal channel value reference type (%d)", ref->type);
             return NULL;

From 64fbbb3c4cae428a14c5a2caa245f111d266a497 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:31:33 +0100
Subject: [PATCH 110/166] Compare inner types in ChannelTypeEq as well

---
 src/core/channels/ChannelValue.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 02072f3..3f1bfce 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -174,6 +174,7 @@ int ChannelTypeEq(ChannelType * a, ChannelType * b) {
                 return 0;
             }
         }
+        return a->ty.a.inner == b->ty.a.inner;
         return 1;
     } else {
         return a->con == b->con;

From caa252b798df6e35728720b72178c562684795b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:31:59 +0100
Subject: [PATCH 111/166] Fix return value of mcx_array_get_elem_reference

---
 src/core/channels/ChannelValue.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 3f1bfce..4b1a23b 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -405,7 +405,7 @@ void * mcx_array_get_elem_reference(mcx_array * a, size_t idx) {
 
     if (idx >= num_elems) {
         mcx_log(LOG_ERROR, "mcx_array_get_elem_reference: Array index out of range (idx: %d, num_elems: %d)", idx, num_elems);
-        return RETURN_ERROR;
+        return NULL;
     }
 
     return data + idx * ChannelValueTypeSize(a->type);

From 36241d200cdbe3520f156ddffe0c58bbc3c8aea3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:32:21 +0100
Subject: [PATCH 112/166] Define ChannelTypeConformable

---
 src/core/channels/ChannelValue.c | 21 +++++++++++++++++++++
 src/core/channels/ChannelValue.h |  4 ++++
 2 files changed, 25 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 4b1a23b..f3d87d1 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -9,6 +9,7 @@
  ********************************************************************************/
 
 #include "core/channels/ChannelValue.h"
+#include "core/channels/ChannelDimension.h"
 #include "util/stdlib.h"
 
 #ifdef __cplusplus
@@ -163,6 +164,26 @@ size_t ChannelTypeNumElements(const ChannelType * type) {
     }
 }
 
+int ChannelTypeConformable(ChannelType * a, ChannelDimension * sliceA, ChannelType * b, ChannelDimension * sliceB) {
+    if (a->con == CHANNEL_ARRAY && b->con == CHANNEL_ARRAY) {
+        if (sliceA && sliceB) {
+            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionConformable(sliceA, sliceB);
+        } else if (sliceA && !sliceB) {
+            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionsConform(sliceA, b->ty.a.dims, b->ty.a.numDims);
+        } else if (!sliceA && sliceB) {
+            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionsConform(sliceB, a->ty.a.dims, a->ty.a.numDims);
+        } else {
+            return ChannelTypeEq(a, b);
+        }
+    } else {
+        if (sliceA || sliceB) {
+            return 0;
+        }
+
+        return a->con == b->con;
+    }
+}
+
 int ChannelTypeEq(ChannelType * a, ChannelType * b) {
     if (a->con == CHANNEL_ARRAY && b->con == CHANNEL_ARRAY) {
         size_t i = 0;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 784f93e..05e9529 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -18,6 +18,9 @@
 extern "C" {
 #endif /* __cplusplus */
 
+
+typedef struct ChannelDimension ChannelDimension;
+
 char * CreateIndexedName(const char * name, unsigned i);
 
 // possible types of values that can be put on channels
@@ -70,6 +73,7 @@ size_t ChannelTypeNumElements(const ChannelType * type);
 ChannelType * ChannelTypeBaseType(ChannelType * a);
 
 int ChannelTypeEq(ChannelType * a, ChannelType * b);
+int ChannelTypeConformable(ChannelType * a, ChannelDimension * sliceA, ChannelType * b, ChannelDimension * sliceB);
 
 typedef struct MapStringChannelType {
     const char * key;

From 267895becaf8f62252437b65b4feb68bb3bdd9b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 12 Nov 2021 14:33:05 +0100
Subject: [PATCH 113/166] Adapt TypeConversion to arrays

---
 src/core/Conversion.c             | 495 +++++++++++++++++++++++++++++-
 src/core/Conversion.h             |   9 +-
 src/core/channels/Channel.c       |  18 +-
 src/core/connections/Connection.c |   2 +-
 4 files changed, 502 insertions(+), 22 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 5754fd5..be83f8a 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -641,7 +641,7 @@ McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue
 
     conv = (Conversion *) typeConv;
 
-    retVal = typeConv->Setup(typeConv, fromType, toType);
+    retVal = typeConv->Setup(typeConv, fromType, NULL, toType, NULL);
     if (retVal == RETURN_ERROR) {
         mcx_log(LOG_ERROR, "ConvertType: Conversion setup failed");
         goto cleanup;
@@ -699,6 +699,37 @@ static McxStatus CheckArrayReferencingOnlyOneElement(ChannelValueRef * dest, Cha
     return RETURN_OK;
 }
 
+static McxStatus ArraysValidForConversion(ChannelValueRef * dest,
+                                          ChannelType * expectedDestType,
+                                          mcx_array * src,
+                                          ChannelDimension * srcDimension) {
+    if (!ChannelTypeIsArray(ChannelValueRefGetType(dest))) {
+        mcx_log(LOG_ERROR, "Type conversion: Destination value is not an array");
+        return RETURN_ERROR;
+    }
+
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelTypeBaseType(ChannelValueRefGetType(dest)), expectedDestType)) {
+        return RETURN_ERROR;
+    }
+
+    // check dimensions match
+    if (srcDimension) {
+        if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+            return ChannelDimensionsConform(srcDimension, dest->ref.value->type->ty.a.dims, dest->ref.value->type->ty.a.numDims) ? RETURN_OK : RETURN_ERROR;
+        } else {
+            return ChannelDimensionConformable(dest->ref.slice->dimension, srcDimension) ? RETURN_OK : RETURN_ERROR;
+        }
+    } else {
+        if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+            return mcx_array_dims_match(&dest->ref.value->value.a, src) ? RETURN_OK : RETURN_ERROR;
+        } else {
+            return ChannelDimensionsConform(dest->ref.slice->dimension, src->dims, src->numDims) ? RETURN_OK : RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
 static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
     if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
@@ -759,12 +790,128 @@ static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, Chann
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertSingletonDoubleToDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertArrayDoubleToDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
     if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
-    dest->ref.value->value.d = *(double *) ((mcx_array*)src)->data;
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.d = *((double *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]);
+    } else {
+        dest->ref.value->value.d = *(double *) ((mcx_array *) src)->data;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayIntegerToDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.d = (double) *((int *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]);
+    } else {
+        dest->ref.value->value.d = (double)  *(int *) ((mcx_array *) src)->data;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayBoolToDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.d = *((int *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]) != 0 ? 1. : 0.;
+    } else {
+        dest->ref.value->value.d = *(int *) ((mcx_array *) src)->data != 0 ? 1. : 0.;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayDoubleToInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.i = (int) floor(*((double *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]) + 0.5);
+    } else {
+        dest->ref.value->value.i = (int) floor(*(double *) ((mcx_array *) src)->data + 0.5);
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayIntegerToInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.i = *((int *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]);
+    } else {
+        dest->ref.value->value.i = *(int *) ((mcx_array *) src)->data;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayBoolToInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.i = *((int *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]) != 0 ? 1 : 0;
+    } else {
+        dest->ref.value->value.i = *(int *) ((mcx_array *) src)->data != 0 ? 1 : 0;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayDoubleToBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.i = *((double *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]) > 0 ? 1 : 0;
+    } else {
+        dest->ref.value->value.i = *(double *) ((mcx_array *) src)->data > 0 ? 1 : 0;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayIntegerToBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.i = *((int *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]) != 0 ? 1 : 0;
+    } else {
+        dest->ref.value->value.i = *(int *) ((mcx_array *) src)->data != 0 ? 1 : 0;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayBoolToBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+        return RETURN_ERROR;
+    }
+
+    if (conversion->sourceSlice) {
+        dest->ref.value->value.i = *((int *) ((mcx_array *) src)->data + conversion->sourceSlice->startIdxs[0]);
+    } else {
+        dest->ref.value->value.i = *(int *) ((mcx_array *) src)->data;
+    }
 
     return RETURN_OK;
 }
@@ -814,15 +961,296 @@ static McxStatus TypeConversionConvertBoolToArrayDouble(Conversion * conversion,
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertId(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    return ChannelValueRefSetFromReference(dest, src, NULL, NULL);
+static McxStatus TypeConversionConvertDoubleToArrayInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeInteger)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(int *) dest->ref.value->value.a.data = (int) floor(*((double *) src) + 0.5);
+    } else {
+        int * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = (int) floor(*((double *) src) + 0.5);
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertIntegerToArrayInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeInteger)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(int *) dest->ref.value->value.a.data = *(int *) src;
+    } else {
+        int * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = *(int *) src;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertBoolToArrayInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeInteger)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(int *) dest->ref.value->value.a.data = *((int *) src) != 0 ? 1 : 0;
+    } else {
+        int * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((int *) src) != 0 ? 1 : 0;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertDoubleToArrayBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeBool)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(int *) dest->ref.value->value.a.data = *((double *) src) > 0 ? 1 : 0;
+    } else {
+        int * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((double *) src) > 0 ? 1 : 0;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertIntegerToArrayBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeBool)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(int *) dest->ref.value->value.a.data = *((int *) src) != 0 ? 1 : 0;
+    } else {
+        int * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((int *) src) != 0 ? 1 : 0;
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertBoolToArrayBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeBool)) {
+        return RETURN_ERROR;
+    }
+
+    if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+        *(int *) dest->ref.value->value.a.data = *(int *) src;
+    } else {
+        int * data = dest->ref.slice->ref->value.a.data;
+        *(data + dest->ref.slice->dimension->startIdxs[0]) = *(int *) src;
+    }
+
+    return RETURN_OK;
+}
+
+static size_t IndexOfElemInSrcArray(size_t dest_idx, mcx_array * src_array, ChannelDimension * src_dim, ChannelValueRef * dest) {
+    if (src_dim) {
+        if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+            return ChannelDimensionGetIndex(src_dim, dest_idx, src_array->dims);
+        } else {
+            size_t idx = ChannelDimensionGetSliceIndex(dest->ref.slice->dimension, dest_idx, dest->ref.slice->ref->type->ty.a.dims);
+            return ChannelDimensionGetIndex(src_dim, idx, src_array->dims);
+        }
+    } else {
+        if (dest->type == CHANNEL_VALUE_REF_VALUE) {
+            return dest_idx;
+        } else {
+            return ChannelDimensionGetSliceIndex(dest->ref.slice->dimension, dest_idx, dest->ref.slice->ref->type->ty.a.dims);
+        }
+    }
+}
+
+typedef struct Array2ArrayCtx {
+    mcx_array * src_array;
+    ChannelDimension * src_dim;
+    ChannelValueRef * dest;
+} Array2ArrayCtx;
+
+static McxStatus IntegerArrayToDouble(void * element, size_t idx, ChannelType * type, void * ctx) {
+    Array2ArrayCtx * context = (Array2ArrayCtx *) ctx;
+    size_t i = IndexOfElemInSrcArray(idx, context->src_array, context->src_dim, context->dest);
+    void * src_elem = mcx_array_get_elem_reference(context->src_array, i);
+
+    if (!src_elem) {
+        return RETURN_ERROR;
+    }
+
+    *(double *) element = (double) *((int *) src_elem);
+
+    return RETURN_OK;
+}
+
+static McxStatus BoolArrayToDouble(void * element, size_t idx, ChannelType * type, void * ctx) {
+    Array2ArrayCtx * context = (Array2ArrayCtx *) ctx;
+    size_t i = IndexOfElemInSrcArray(idx, context->src_array, context->src_dim, context->dest);
+    void * src_elem = mcx_array_get_elem_reference(context->src_array, i);
+
+    if (!src_elem) {
+        return RETURN_ERROR;
+    }
+
+    *(double *) element = *((int *) src_elem) != 0 ? 1. : 0.;
+
+    return RETURN_OK;
+}
+
+static McxStatus BoolArrayToInteger(void * element, size_t idx, ChannelType * type, void * ctx) {
+    Array2ArrayCtx * context = (Array2ArrayCtx *) ctx;
+    size_t i = IndexOfElemInSrcArray(idx, context->src_array, context->src_dim, context->dest);
+    void * src_elem = mcx_array_get_elem_reference(context->src_array, i);
+
+    if (!src_elem) {
+        return RETURN_ERROR;
+    }
+
+    *(int *) element = *((int *) src_elem) != 0 ? 1 : 0;
+
+    return RETURN_OK;
+}
+
+static McxStatus DoubleArrayToInteger(void * element, size_t idx, ChannelType * type, void * ctx) {
+    Array2ArrayCtx * context = (Array2ArrayCtx *) ctx;
+    size_t i = IndexOfElemInSrcArray(idx, context->src_array, context->src_dim, context->dest);
+    void * src_elem = mcx_array_get_elem_reference(context->src_array, i);
+
+    if (!src_elem) {
+        return RETURN_ERROR;
+    }
+
+    *(int *) element = (int) floor(*((double *) src_elem) + 0.5);
+
+    return RETURN_OK;
+}
+
+static McxStatus DoubleArrayToBool(void * element, size_t idx, ChannelType * type, void * ctx) {
+    Array2ArrayCtx * context = (Array2ArrayCtx *) ctx;
+    size_t i = IndexOfElemInSrcArray(idx, context->src_array, context->src_dim, context->dest);
+    void * src_elem = mcx_array_get_elem_reference(context->src_array, i);
+
+    if (!src_elem) {
+        return RETURN_ERROR;
+    }
+
+    *(int *) element = *((double *) src_elem) > 0 ? 1 : 0;
+
+    return RETURN_OK;
+}
+
+static McxStatus IntegerArrayToBool(void * element, size_t idx, ChannelType * type, void * ctx) {
+    Array2ArrayCtx * context = (Array2ArrayCtx *) ctx;
+    size_t i = IndexOfElemInSrcArray(idx, context->src_array, context->src_dim, context->dest);
+    void * src_elem = mcx_array_get_elem_reference(context->src_array, i);
+
+    if (!src_elem) {
+        return RETURN_ERROR;
+    }
+
+    *(int *) element = *((int *) src_elem) != 0 ? 1 : 0;
+
+    return RETURN_OK;
+}
+
+static McxStatus TypeConversionConvertArrayIntegerToArrayDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeDouble, (mcx_array *) src, conversion->sourceSlice)) {
+        return RETURN_ERROR;
+    }
+
+    Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
+    return ChannelValueRefElemMap(dest, IntegerArrayToDouble, &ctx);
+}
+
+static McxStatus TypeConversionConvertArrayBoolToArrayDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeDouble, (mcx_array *) src, conversion->sourceSlice)) {
+        return RETURN_ERROR;
+    }
+
+    Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
+    return ChannelValueRefElemMap(dest, BoolArrayToDouble, &ctx);
+}
+
+static McxStatus TypeConversionConvertArrayDoubleToArrayInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeInteger, (mcx_array *) src, conversion->sourceSlice)) {
+        return RETURN_ERROR;
+    }
+
+    Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
+    return ChannelValueRefElemMap(dest, DoubleArrayToInteger, &ctx);
+}
+
+static McxStatus TypeConversionConvertArrayBoolToArrayInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeInteger, (mcx_array *) src, conversion->sourceSlice)) {
+        return RETURN_ERROR;
+    }
+
+    Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
+    return ChannelValueRefElemMap(dest, BoolArrayToInteger, &ctx);
+}
+
+static McxStatus TypeConversionConvertArrayDoubleToArrayBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeBool, (mcx_array *) src, conversion->sourceSlice)) {
+        return RETURN_ERROR;
+    }
+
+    Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
+    return ChannelValueRefElemMap(dest, DoubleArrayToBool, &ctx);
+}
+
+static McxStatus TypeConversionConvertArrayIntegerToArrayBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeBool, (mcx_array *) src, conversion->sourceSlice)) {
+        return RETURN_ERROR;
+    }
+
+    Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
+    return ChannelValueRefElemMap(dest, IntegerArrayToBool, &ctx);
+}
+
+static McxStatus TypeConversionConvertId(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+    return ChannelValueRefSetFromReference(dest, src, conversion->sourceSlice, NULL);
+}
+
+static int DimensionsMatch(ChannelType * fromType, ChannelDimension * fromDimension, ChannelType * toType, ChannelDimension * toDimension) {
+    if (fromDimension) {
+        if (!toDimension) {
+            return ChannelDimensionsConform(fromDimension, toType->ty.a.dims, toType->ty.a.numDims);
+        } else {
+            return ChannelDimensionConformable(toDimension, fromDimension);
+        }
+    } else {
+        if (!toDimension) {
+            size_t i = 0;
+            if (fromType->ty.a.numDims != toType->ty.a.numDims) {
+                return 0;
+            }
+
+            for (i = 0; i < fromType->ty.a.numDims; i++) {
+                if (fromType->ty.a.dims[i] != toType->ty.a.dims[i]) {
+                    return 0;
+                }
+            }
+
+            return 1;
+        } else {
+            return ChannelDimensionsConform(toDimension, fromType->ty.a.dims, fromType->ty.a.numDims);
+        }
+    }
 }
 
 static McxStatus TypeConversionSetup(TypeConversion * conversion,
                                      ChannelType * fromType,
-                                     ChannelType * toType) {
+                                     ChannelDimension * fromDimension,
+                                     ChannelType * toType,
+                                     ChannelDimension * toDimension) {
+    conversion->sourceSlice = fromDimension;
 
-    if (ChannelTypeEq(fromType, toType)) {
+    if (ChannelTypeConformable(fromType, fromDimension, toType, toDimension)) {
         conversion->Convert = TypeConversionConvertId;
     /* scalar <-> scalar */
     } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
@@ -839,13 +1267,64 @@ static McxStatus TypeConversionSetup(TypeConversion * conversion,
         conversion->Convert = TypeConversionConvertIntegerBool;
     /* scalar <-> array */
     } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
-        conversion->Convert = TypeConversionConvertSingletonDoubleToDouble;
+        conversion->Convert = TypeConversionConvertArrayDoubleToDouble;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
+        conversion->Convert = TypeConversionConvertArrayIntegerToDouble;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeBool) && ChannelTypeEq(toType, &ChannelTypeDouble)) {
+        conversion->Convert = TypeConversionConvertArrayBoolToDouble;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeBool)) {
+        conversion->Convert = TypeConversionConvertArrayDoubleToBool;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeBool)) {
+        conversion->Convert = TypeConversionConvertArrayIntegerToBool;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeBool) && ChannelTypeEq(toType, &ChannelTypeBool)) {
+        conversion->Convert = TypeConversionConvertArrayBoolToBool;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeDouble) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
+        conversion->Convert = TypeConversionConvertArrayDoubleToInteger;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeInteger) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
+        conversion->Convert = TypeConversionConvertArrayIntegerToInteger;
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeEq(fromType->ty.a.inner, &ChannelTypeBool) && ChannelTypeEq(toType, &ChannelTypeInteger)) {
+        conversion->Convert = TypeConversionConvertArrayBoolToInteger;
     } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeDouble)) {
         conversion->Convert = TypeConversionConvertDoubleToArrayDouble;
     } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeDouble)) {
         conversion->Convert = TypeConversionConvertIntegerToArrayDouble;
     } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeDouble)) {
         conversion->Convert = TypeConversionConvertBoolToArrayDouble;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeInteger)) {
+        conversion->Convert = TypeConversionConvertDoubleToArrayInteger;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeInteger)) {
+        conversion->Convert = TypeConversionConvertIntegerToArrayInteger;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeInteger)) {
+        conversion->Convert = TypeConversionConvertBoolToArrayInteger;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeDouble) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeBool)) {
+        conversion->Convert = TypeConversionConvertDoubleToArrayBool;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeInteger) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeBool)) {
+        conversion->Convert = TypeConversionConvertIntegerToArrayBool;
+    } else if (ChannelTypeEq(fromType, &ChannelTypeBool) && ChannelTypeIsArray(toType) && ChannelTypeEq(toType->ty.a.inner, &ChannelTypeBool)) {
+        conversion->Convert = TypeConversionConvertBoolToArrayBool;
+    /* array <-> array */
+    } else if (ChannelTypeIsArray(fromType) && ChannelTypeIsArray(toType)) {
+        if (!DimensionsMatch(fromType, fromDimension, toType, toDimension)) {
+            mcx_log(LOG_ERROR, "Setup type conversion: Array dimensions do not match");
+            return RETURN_ERROR;
+        }
+
+        if (ChannelTypeEq(ChannelTypeBaseType(fromType), &ChannelTypeInteger) && ChannelTypeEq(ChannelTypeBaseType(toType), &ChannelTypeDouble)) {
+            conversion->Convert = TypeConversionConvertArrayIntegerToArrayDouble;
+        } else if (ChannelTypeEq(ChannelTypeBaseType(fromType), &ChannelTypeBool) && ChannelTypeEq(ChannelTypeBaseType(toType), &ChannelTypeDouble)) {
+            conversion->Convert = TypeConversionConvertArrayBoolToArrayDouble;
+        } else if (ChannelTypeEq(ChannelTypeBaseType(fromType), &ChannelTypeDouble) && ChannelTypeEq(ChannelTypeBaseType(toType), &ChannelTypeInteger)) {
+            conversion->Convert = TypeConversionConvertArrayDoubleToArrayInteger;
+        } else if (ChannelTypeEq(ChannelTypeBaseType(fromType), &ChannelTypeBool) && ChannelTypeEq(ChannelTypeBaseType(toType), &ChannelTypeInteger)) {
+            conversion->Convert = TypeConversionConvertArrayBoolToArrayInteger;
+        } else if (ChannelTypeEq(ChannelTypeBaseType(fromType), &ChannelTypeDouble) && ChannelTypeEq(ChannelTypeBaseType(toType), &ChannelTypeBool)) {
+            conversion->Convert = TypeConversionConvertArrayDoubleToArrayBool;
+        } else if (ChannelTypeEq(ChannelTypeBaseType(fromType), &ChannelTypeInteger) && ChannelTypeEq(ChannelTypeBaseType(toType), &ChannelTypeBool)) {
+            conversion->Convert = TypeConversionConvertArrayIntegerToArrayBool;
+        } else {
+            mcx_log(LOG_ERROR, "Setup type conversion: Illegal conversion between array types selected");
+            return RETURN_ERROR;
+        }
     } else {
         mcx_log(LOG_ERROR, "Setup type conversion: Illegal conversion selected");
         return RETURN_ERROR;
diff --git a/src/core/Conversion.h b/src/core/Conversion.h
index 7aa9b78..7ac4c34 100644
--- a/src/core/Conversion.h
+++ b/src/core/Conversion.h
@@ -12,6 +12,7 @@
 #define MCX_CORE_CONVERSION_H
 
 #include "units/Units.h"
+#include "core/channels/ChannelDimension.h"
 
 
 #ifdef __cplusplus
@@ -119,7 +120,11 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 // Type Conversion
 typedef struct TypeConversion TypeConversion;
 
-typedef McxStatus (*fTypeConversionSetup)(TypeConversion * conversion, const ChannelType * fromType, const ChannelType * toType);
+typedef McxStatus (*fTypeConversionSetup)(TypeConversion * conversion,
+                                          const ChannelType * fromType,
+                                          ChannelDimension * fromDimension,
+                                          const ChannelType * toType,
+                                          ChannelDimension * toDimension);
 
 // TODO: Ideally the `src` argument would also be ChannelValueRef, but that requires quite of lot of changes
 //       in the API of databus definition (i.e. DatabusSetIn(Out)Reference)
@@ -132,6 +137,8 @@ struct TypeConversion {
 
     fTypeConversionSetup Setup;
     fTypeConversionConvert Convert;
+
+    ChannelDimension * sourceSlice;
 };
 
 McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue * value);
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index d2fb896..53b7d05 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -464,22 +464,18 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         }
     }
 
-    // TODO - array
     // setup type conversion
-
-    ChannelType * connType = ChannelDimensionToChannelType(connInfo->sourceDimension, type);
-    if (!connType) {
-        return RETURN_ERROR;
-    }
-
-    if (!ChannelTypeEq(inInfo->type, type)) {
+    if (!ChannelTypeConformable(inInfo->type, inInfo->dimension, connection->GetValueType(connection), connection->GetValueDimension(connection))) {
         TypeConversion * typeConv = (TypeConversion *) object_create(TypeConversion);
-        retVal = typeConv->Setup(typeConv, connType, inInfo->type);
+        retVal = typeConv->Setup(typeConv,
+                                 connection->GetValueType(connection),
+                                 connection->GetValueDimension(connection),
+                                 inInfo->type,
+                                 connInfo->targetDimension);
         if (RETURN_ERROR == retVal) {
             return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not set up type conversion");
         }
 
-
         retVal = in->data->typeConversions->PushBack(in->data->typeConversions, (Object *) typeConv);
         if (RETURN_ERROR == retVal) {
             return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not add type conversion");
@@ -491,8 +487,6 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         }
     }
 
-    ChannelTypeDestructor(connType);
-
     return retVal;
 }
 
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index e0f9d48..53c0186 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1177,7 +1177,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
         if (!ChannelTypeEq(inValue->type, store->type)) {
             TypeConversion * typeConv = (TypeConversion *) object_create(TypeConversion);
             Conversion * conv = (Conversion *) typeConv;
-            retVal = typeConv->Setup(typeConv, inValue->type, store->type);
+            retVal = typeConv->Setup(typeConv, inValue->type, NULL, store->type, NULL);
             if (RETURN_ERROR == retVal) {
                 mcx_log(LOG_ERROR, "Could not set up initial type conversion");
                 object_destroy(typeConv);

From 7f93f351f08b65fc683fbf5cb8bf75f1c6133e17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 15 Nov 2021 15:28:51 +0100
Subject: [PATCH 114/166] Take into account arrays in dependency matrix
 creation

---
 src/components/comp_fmu.c | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index 6ffe7c7..fae5e06 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -1241,13 +1241,30 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
         if (processed_out_channels->Get(processed_out_channels, i) == NULL) {
             Fmu2Value *val = (Fmu2Value *)out_vars->At(out_vars, i);
 
-            if (fmi2_import_get_initial(val->data->data.scalar) != fmi2_initial_enu_exact) {
-                for (k = 0; k < num_in_channels; ++k) {
-                    SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, k);
-                    if (elem) {
-                        ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
-                        if (RETURN_OK != ret_val) {
-                            goto cleanup;
+            if (val->data->type == FMU2_VALUE_ARRAY) {
+                size_t elem_idx = 0;
+                for (elem_idx = 0; elem_idx < val->data->data.array.numDims; elem_idx++) {
+                    if (fmi2_import_get_initial(val->data->data.array.values[elem_idx]) != fmi2_initial_enu_exact) {
+                        for (k = 0; k < num_in_channels; ++k) {
+                            SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, k);
+                            if (elem) {
+                                ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
+                                if (RETURN_OK != ret_val) {
+                                    goto cleanup;
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                if (fmi2_import_get_initial(val->data->data.scalar) != fmi2_initial_enu_exact) {
+                    for (k = 0; k < num_in_channels; ++k) {
+                        SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, k);
+                        if (elem) {
+                            ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
+                            if (RETURN_OK != ret_val) {
+                                goto cleanup;
+                            }
                         }
                     }
                 }

From ec18455a8e387e367b004781845e86413315a050 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 15 Nov 2021 15:36:31 +0100
Subject: [PATCH 115/166] Change connection->data->store to the size of the
 input slice

---
 src/core/channels/ChannelValue.c          |  25 +++++
 src/core/channels/ChannelValue.h          |   2 +
 src/core/connections/Connection.c         | 118 ++++++++++++++++------
 src/core/connections/FilteredConnection.c |  28 +----
 4 files changed, 116 insertions(+), 57 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index f3d87d1..218059a 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -432,6 +432,31 @@ void * mcx_array_get_elem_reference(mcx_array * a, size_t idx) {
     return data + idx * ChannelValueTypeSize(a->type);
 }
 
+ChannelType * ChannelTypeFromDimension(ChannelType * base_type, ChannelDimension * dimension) {
+    if (dimension) {
+        // source data is an array
+        size_t i = 0;
+        ChannelType * type = NULL;
+        size_t * dims = (size_t *) mcx_calloc(sizeof(size_t), dimension->num);
+
+        if (!dims) {
+            mcx_log(LOG_ERROR, "DetermineSliceType: Not enough memory for dimension calculation");
+            return NULL;
+        }
+
+        for (i = 0; i < dimension->num; i++) {
+            dims[i] = dimension->endIdxs[i] - dimension->startIdxs[i] + 1;    // indices are inclusive
+        }
+
+        type = ChannelTypeArray(ChannelTypeClone(ChannelTypeBaseType(base_type)), dimension->num, dims);
+        mcx_free(dims);
+        return type;
+    } else {
+        // source data is a scalar
+        return ChannelTypeClone(base_type);
+    }
+}
+
 void ChannelValueInit(ChannelValue * value, ChannelType * type) {
     value->type = type;
     ChannelValueDataInit(&value->value, type);
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 05e9529..ff908e2 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -70,6 +70,8 @@ int ChannelTypeIsBinary(const ChannelType * a);
 
 size_t ChannelTypeNumElements(const ChannelType * type);
 
+ChannelType * ChannelTypeFromDimension(ChannelType * base_type, ChannelDimension * dimension);
+
 ChannelType * ChannelTypeBaseType(ChannelType * a);
 
 int ChannelTypeEq(ChannelType * a, ChannelType * b);
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 53c0186..ec6f4e9 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -12,6 +12,7 @@
 #include "core/connections/Connection.h"
 #include "core/channels/Channel.h"
 #include "core/channels/ChannelInfo.h"
+#include "core/channels/ChannelValueReference.h"
 #include "core/connections/ConnectionInfo.h"
 #include "core/Conversion.h"
 
@@ -1145,6 +1146,10 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
     ChannelInfo * inInfo = &in->info;
     ChannelInfo * outInfo = &out->info;
 
+    ChannelValueRef * storeRef = NULL;
+
+    McxStatus retVal = RETURN_OK;
+
     if (connection->state_ != InInitializationMode) {
         char * buffer = ConnectionInfoConnectionString(info);
         mcx_log(LOG_ERROR, "Connection %s: Update initial value: Cannot update initial value outside of initialization mode", buffer);
@@ -1159,52 +1164,76 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
         return RETURN_ERROR;
     }
 
+    storeRef = (ChannelValueRef *) object_create(ChannelValueRef);
+    if (!storeRef) {
+        mcx_log(LOG_ERROR, "Could not create store reference for initial connection");
+        return RETURN_ERROR;
+    }
+    storeRef->type = CHANNEL_VALUE_REF_VALUE;
+    storeRef->ref.value = &connection->store_;
+
     if (inInfo->initialValue) {
-        McxStatus retVal = RETURN_OK;
-        ChannelValue * store = &connection->store_;
+        TypeConversion * typeConv = NULL;
         ChannelValue * inChannelValue = inInfo->initialValue;
-        ChannelValue * inValue = ChannelValueClone(inChannelValue);
+        ChannelDimension * srcDim = NULL;
 
-        if (NULL == inValue) {
-            mcx_log(LOG_ERROR, "Could not clone initial value for initial connection");
-            return RETURN_ERROR;
+        srcDim = ChannelDimensionClone(info->targetDimension);
+        if (srcDim) {
+            mcx_log(LOG_ERROR, "Could not clone source dimension");
+            retVal = RETURN_ERROR;
+            goto cleanup_1;
+        }
+        retVal = ChannelDimensionNormalize(srcDim, inInfo->dimension);
+        if (retVal == RETURN_ERROR) {
+            mcx_log(LOG_ERROR, "Dimension normalization failed");
+            goto cleanup_1;
         }
 
         // The type of the stored value of a connection is the type of the out channel.
         // If the value is taken from the in channel, the value must be converted.
         // TODO: It might be a better idea to use the type of the in channel as type of the connection.
         // Such a change might be more complex to implement.
-        if (!ChannelTypeEq(inValue->type, store->type)) {
-            TypeConversion * typeConv = (TypeConversion *) object_create(TypeConversion);
-            Conversion * conv = (Conversion *) typeConv;
-            retVal = typeConv->Setup(typeConv, inValue->type, NULL, store->type, NULL);
+        if (!ChannelTypeConformable(storeRef->ref.value->type, NULL, inChannelValue->type, srcDim)) {
+            typeConv = (TypeConversion *) object_create(TypeConversion);
+            retVal = typeConv->Setup(typeConv, inChannelValue->type, info->targetDimension, storeRef->ref.value->type, NULL);
             if (RETURN_ERROR == retVal) {
                 mcx_log(LOG_ERROR, "Could not set up initial type conversion");
-                object_destroy(typeConv);
-                mcx_free(inValue);
-                return RETURN_ERROR;
-            }
-            retVal = conv->convert(conv, inValue);
-            object_destroy(typeConv);
-
-            if (RETURN_ERROR == retVal) {
-                mcx_log(LOG_ERROR, "Could not convert type of initial value");
-                mcx_free(inValue);
-                return RETURN_ERROR;
+                retVal = RETURN_ERROR;
+                goto cleanup_1;
             }
         }
 
-        retVal = ChannelValueSet(store, inValue);
+        retVal = ChannelValueRefSetFromReference(storeRef, ChannelValueReference(inChannelValue), srcDim, typeConv);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "Could not set up initial value in connection");
-            mcx_free(inValue);
-            return RETURN_ERROR;
+            goto cleanup_1;
         }
-        mcx_free(inValue);
 
         connection->useInitialValue_ = TRUE;
+
+cleanup_1:
+        object_destroy(typeConv);
+        object_destroy(srcDim);
+
+        if (retVal == RETURN_ERROR) {
+            goto cleanup;
+        }
     } else if (outInfo->initialValue) {
-        ChannelValueSet(&connection->store_, outInfo->initialValue);
+        ChannelDimension * targetDim = ChannelDimensionClone(info->sourceDimension);
+        if (targetDim) {
+            mcx_log(LOG_ERROR, "Could not clone target dimension");
+            retVal = RETURN_ERROR;
+            goto cleanup;
+        }
+
+        retVal = ChannelDimensionNormalize(targetDim, outInfo->dimension);
+        if (retVal == RETURN_ERROR) {
+            mcx_log(LOG_ERROR, "Dimension normalization failed");
+            object_destroy(targetDim);
+            goto cleanup;
+        }
+
+        ChannelValueRefSetFromReference(storeRef, outInfo->initialValue, targetDim, NULL);
         connection->useInitialValue_ = TRUE;
     } else {
         {
@@ -1212,10 +1241,21 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             mcx_log(LOG_WARNING, "Connection %s: No initial values are specified for the ports of the connection", buffer);
             mcx_free(buffer);
         }
-        ChannelValueInit(&connection->store_, ChannelTypeClone(ConnectionInfoGetType(info)));
+
+        ChannelType * storeType = ChannelTypeFromDimension(info->connType_, info->sourceDimension);
+        if (!storeType) {
+            mcx_log(LOG_ERROR, "Creating type from the dimension failed");
+            retVal = RETURN_ERROR;
+            goto cleanup;
+        }
+
+        ChannelValueInit(&connection->store_, storeType);
     }
 
-    return RETURN_OK;
+cleanup:
+    object_destroy(storeRef);
+
+    return retVal;
 }
 
 static void ConnectionInitUpdateFrom(Connection * connection, TimeInterval * time) {
@@ -1231,6 +1271,7 @@ static void ConnectionInitUpdateFrom(Connection * connection, TimeInterval * tim
 
 static McxStatus ConnectionInitUpdateTo(Connection * connection, TimeInterval * time) {
     Channel * channel = (Channel *) connection->out_;
+    ChannelInfo * info = &channel->info;
 
 #ifdef MCX_DEBUG
     if (time->startTime < MCX_DEBUG_LOG_TIME) {
@@ -1240,7 +1281,18 @@ static McxStatus ConnectionInitUpdateTo(Connection * connection, TimeInterval *
 #endif
 
     if (!connection->useInitialValue_) {
-        if (RETURN_OK != ChannelValueSetFromReference(&connection->store_, channel->GetValueReference(channel))) {
+        ChannelValueRef * storeRef = (ChannelValueRef *) object_create(ChannelValueRef);
+        if (!storeRef) {
+            mcx_log(LOG_ERROR, "Could not create store reference for initial connection");
+            return RETURN_ERROR;
+        }
+        storeRef->type = CHANNEL_VALUE_REF_VALUE;
+        storeRef->ref.value = &connection->store_;
+
+        ConnectionInfo * connInfo = connection->GetInfo(connection);
+        ChannelDimension * clone = ChannelDimensionClone(connInfo->sourceDimension);
+        ChannelDimensionNormalize(clone, info->dimension);
+        if (RETURN_OK != ChannelValueRefSetFromReference(storeRef, channel->GetValueReference(channel), clone, NULL)) {
             return RETURN_ERROR;
         }
         if (channel->IsDefinedDuringInit(channel)) {
@@ -1337,6 +1389,7 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
 
     Channel * chOut = (Channel *) out;
     ChannelInfo * outInfo = &chOut->info;
+    ChannelType * storeType = NULL;
 
     connection->out_  = out;
     connection->in_   = in;
@@ -1347,7 +1400,12 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
 
     connection->info = *info;
 
-    ChannelValueInit(&connection->store_, ChannelTypeClone(outInfo->type));
+    storeType = ChannelTypeFromDimension(outInfo->type, info->sourceDimension);
+    if (!storeType) {
+        return RETURN_ERROR;
+    }
+
+    ChannelValueInit(&connection->store_, storeType);
 
     // Add connection to channel out
     retVal = out->RegisterConnection(out, connection);
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 46aa490..9693dd5 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -46,32 +46,6 @@ static void FilteredConnectionDataDestructor(FilteredConnectionData * data) {
 OBJECT_CLASS(FilteredConnectionData, Object);
 
 
-static ChannelType * SliceDimensionToType(ChannelType * sourceType, ChannelDimension * dimension) {
-    if (dimension) {
-        // source data is an array
-        size_t i = 0;
-        ChannelType * type = NULL;
-        size_t * dims = (size_t *) mcx_calloc(sizeof(size_t), dimension->num);
-
-        if (!dims) {
-            mcx_log(LOG_ERROR, "DetermineSliceType: Not enough memory for dimension calculation");
-            return NULL;
-        }
-
-        for (i = 0; i < dimension->num; i++) {
-            dims[i] = dimension->endIdxs[i] - dimension->startIdxs[i] + 1;    // indices are inclusive
-        }
-
-        type = ChannelTypeArray(ChannelTypeClone(ChannelTypeBaseType(sourceType)), dimension->num, dims);
-        mcx_free(dims);
-        return type;
-    } else {
-        // source data is a scalar
-        return ChannelTypeClone(sourceType);
-    }
-}
-
-
 static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * out,
                                          ChannelIn * in, ConnectionInfo * info) {
     FilteredConnection * filteredConnection = (FilteredConnection *) connection;
@@ -92,7 +66,7 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     filteredConnection->data->filters = NULL;
     filteredConnection->data->numFilters = 0;
 
-    storeType = SliceDimensionToType(sourceInfo->type, info->sourceDimension);
+    storeType = ChannelTypeFromDimension(sourceInfo->type, info->sourceDimension);
     if (!storeType) {
         return RETURN_ERROR;
     }

From edcc8d4c64c393fe299e817bb408de8d30a165f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 19 Nov 2021 13:15:04 +0100
Subject: [PATCH 116/166] Support array channels in FMU 1

---
 src/components/comp_fmu.c |  50 +++-----
 src/fmu/Fmu1Value.c       | 261 +++++++++++++++++++++++++++++++++++---
 src/fmu/Fmu1Value.h       |  52 +++++++-
 src/fmu/common_fmu1.c     |  92 ++++++++++----
 4 files changed, 379 insertions(+), 76 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index fae5e06..a0495d0 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -51,6 +51,8 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
     vals = fmu1->in;
     for (i = 0; i < numChannels; i++) {
         ChannelInfo * info = DatabusInfoGetChannel(dbInfo, i);
+        ChannelDimension * dimension = info->dimension;
+        ChannelType * type = info->type;
 
         if (DatabusChannelInIsValid(db, i)) {
             Fmu1Value * val = NULL;
@@ -63,33 +65,24 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
                 channelName = ChannelInfoGetName(info);
             }
 
-            var = fmi1_import_get_variable_by_name(fmu1->fmiImport, channelName);
-            if (!var) {
-                ComponentLog(comp, LOG_ERROR, "Could not get variable %s", channelName);
-                return RETURN_ERROR;
-            }
-
-            if (!ChannelTypeEq(info->type, Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var)))) {
-                ComponentLog(comp, LOG_ERROR, "Variable types of %s do not match", channelName);
-                ComponentLog(comp, LOG_ERROR, "Expected: %s, Imported from FMU: %s",
-                    ChannelTypeToString(info->type), ChannelTypeToString(Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))));
-                return RETURN_ERROR;
+            if (dimension) {  // arrays
+                val = Fmu1ValueReadArray(comp->GetName(comp), type, info->channel, channelName, dimension, fmu1->fmiImport);
+            } else {  // scalars
+                val = Fmu1ValueReadScalar(comp->GetName(comp), type, info->channel, channelName, fmu1->fmiImport);
             }
 
-            val = Fmu1ValueMake(channelName, var, info->channel);
             if (!val) {
-                ComponentLog(comp, LOG_ERROR, "Could not set value for channel %s", channelName);
+                ComponentLog(comp, LOG_ERROR, "Could not create value for channel %s", channelName);
                 return RETURN_ERROR;
             }
 
-            retVal = vals->PushBackNamed(vals, (Object *)val, channelName);
+            retVal = vals->PushBackNamed(vals, (Object *) val, channelName);
             if (RETURN_OK != retVal) {
                 ComponentLog(comp, LOG_ERROR, "Could not store value for %s", channelName);
                 return RETURN_ERROR;
             }
 
-            retVal = DatabusSetInReference(comp->GetDatabus(comp), i, ChannelValueReference(&val->val),
-                ChannelValueType(&val->val));
+            retVal = DatabusSetInReference(db, i, ChannelValueReference(&val->val), ChannelValueType(&val->val));
             if (RETURN_OK != retVal) {
                 ComponentLog(comp, LOG_ERROR, "Could not set reference for channel %s", channelName);
                 return RETURN_ERROR;
@@ -102,6 +95,8 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
     vals = fmu1->out;
     for (i = 0; i < numChannels; i++) {
         ChannelInfo * info = DatabusInfoGetChannel(dbInfo, i);
+        ChannelDimension * dimension = info->dimension;
+        ChannelType * type = info->type;
 
         Fmu1Value * val = NULL;
         fmi1_import_variable_t * var = NULL;
@@ -112,33 +107,24 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
             channelName = ChannelInfoGetName(info);
         }
 
-        var = fmi1_import_get_variable_by_name(fmu1->fmiImport, channelName);
-        if (!var) {
-            ComponentLog(comp, LOG_ERROR, "Could not get variable %s", channelName);
-            return RETURN_ERROR;
-        }
-
-        if (!ChannelTypeEq(info->type, Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var)))) {
-            ComponentLog(comp, LOG_ERROR, "Variable types of %s do not match", channelName);
-            ComponentLog(comp, LOG_ERROR, "Expected: %s, Imported from FMU: %s",
-                ChannelTypeToString(info->type), ChannelTypeToString(Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))));
-            return RETURN_ERROR;
+        if (dimension) {    // arrays
+            val = Fmu1ValueReadArray(comp->GetName(comp), type, info->channel, channelName, dimension, fmu1->fmiImport);
+        } else {    // scalars
+            val = Fmu1ValueReadScalar(comp->GetName(comp), type, info->channel, channelName, fmu1->fmiImport);
         }
 
-        val = Fmu1ValueMake(channelName, var, NULL);
         if (!val) {
-            ComponentLog(comp, LOG_ERROR, "Could not set value for channel %s", channelName);
+            ComponentLog(comp, LOG_ERROR, "Could not create value for channel %s", channelName);
             return RETURN_ERROR;
         }
 
-        retVal = vals->PushBack(vals, (Object *)val);
+        retVal = vals->PushBackNamed(vals, (Object *) val, channelName);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not store value for %s", channelName);
             return RETURN_ERROR;
         }
 
-        retVal = DatabusSetOutReference(comp->GetDatabus(comp), i, ChannelValueReference(&val->val),
-            ChannelValueType(&val->val));
+        retVal = DatabusSetOutReference(db, i, ChannelValueReference(&val->val), ChannelValueType(&val->val));
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not set reference for channel %s", channelName);
             return RETURN_ERROR;
diff --git a/src/fmu/Fmu1Value.c b/src/fmu/Fmu1Value.c
index 6800ce0..7f2818a 100644
--- a/src/fmu/Fmu1Value.c
+++ b/src/fmu/Fmu1Value.c
@@ -13,29 +13,178 @@
 #include "fmu/common_fmu1.h"
 
 #include "util/string.h"
+#include "util/stdlib.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+
+static void Fmu1ValueDataDestructor(Fmu1ValueData * data) {
+    if (data->type == FMU1_VALUE_ARRAY) {
+        if (data->var.array.dims) {
+            mcx_free(data->var.array.dims);
+        }
+        if (data->var.array.values) {
+            mcx_free(data->var.array.values);
+        }
+        data->var.array.numDims = 0;
+
+        if (data->vr.array.values) {
+            mcx_free(data->vr.array.values);
+        }
+    }
+
+    data->type = FMU1_VALUE_INVALID;
+}
+
+static Fmu1ValueData * Fmu1ValueDataCreate(Fmu1ValueData * data) {
+    memset(data, 0, sizeof(Fmu1ValueData));
+
+    data->type = FMU1_VALUE_INVALID;
+
+    return data;
+}
+
+OBJECT_CLASS(Fmu1ValueData, Object);
+
+
+size_t Fmu1ValueDataArrayNumElems(const Fmu1ValueData * data) {
+    size_t i = 0;
+    size_t num = 1;
+
+    if (data->type != FMU1_VALUE_ARRAY) {
+        return 0;
+    }
+
+    for (i = 0; i < data->var.array.numDims; i++) {
+        num *= data->var.array.dims[i];
+    }
+
+    return num;
+}
+
+
+static Fmu1ValueData * Fmu1ValueDataScalarMake(fmi1_import_variable_t * scalar) {
+    Fmu1ValueData * data = NULL;
+
+    if (!scalar) {
+        return NULL;
+    }
+
+    data = (Fmu1ValueData *) object_create(Fmu1ValueData);
+    if (data) {
+        data->type = FMU1_VALUE_SCALAR;
+        data->var.scalar = scalar;
+        data->vr.scalar = fmi1_import_get_variable_vr(scalar);
+    }
+
+    return data;
+}
+
+static Fmu1ValueData * Fmu1ValueDataArrayMake(size_t numDims, size_t dims[], fmi1_import_variable_t ** values) {
+    Fmu1ValueData * data = NULL;
+
+    if (numDims == 0) {
+        return NULL;
+    }
+
+    data = (Fmu1ValueData *) object_create(Fmu1ValueData);
+    if (data) {
+        size_t i = 0;
+        size_t num = 1;
+
+        for (i = 0; i < numDims; i++) {
+            num *= dims[i];
+        }
+
+        data->type = FMU1_VALUE_ARRAY;
+
+        data->var.array.numDims = numDims;
+        data->var.array.dims = mcx_copy(dims, sizeof(size_t) * numDims);
+        if (!data->var.array.dims) {
+            goto cleanup;
+        }
+
+        data->var.array.values = mcx_copy(values, sizeof(fmi1_import_variable_t *) * num);
+        if (!data->var.array.values) {
+            goto cleanup;
+        }
+
+        data->vr.array.values = mcx_calloc(num, sizeof(fmi1_value_reference_t));
+        if (!data->vr.array.values) {
+            goto cleanup;
+        }
+
+        for (i = 0; i < num; i++) {
+            data->vr.array.values[i] = fmi2_import_get_variable_vr(data->var.array.values[i]);
+        }
+    }
+    return data;
+
+cleanup:
+    object_destroy(data);
+    return NULL;
+}
+
+
 static McxStatus Fmu1ValueSetFromChannelValue(Fmu1Value * v, ChannelValue * val) {
     return ChannelValueSet(&v->val, val);
 }
 
+static McxStatus Fmu1ValueSetup(Fmu1Value * value, const char * name, Fmu1ValueData * data, Channel * channel) {
+    if (!name || !data) {
+        mcx_log(LOG_ERROR, "Fmu1Value: Setup failed: Name or data missing");
+        return RETURN_ERROR;
+    }
+
+    value->name = mcx_string_copy(name);
+    value->data = data;
+    value->channel = channel;
+
+    if (!value->name) {
+        mcx_log(LOG_ERROR, "Fmu1Value: Setup failed: Can not copy name");
+        return RETURN_ERROR;
+    }
+
+    switch (data->type) {
+        case FMU1_VALUE_SCALAR:
+            {
+                fmi1_base_type_enu_t t = fmi1_import_get_variable_base_type(data->var.scalar);
+                ChannelValueInit(&value->val, ChannelTypeClone(Fmi1TypeToChannelType(t)));
+                break;
+            }
+        case FMU1_VALUE_ARRAY:
+            {
+                fmi1_base_type_enu_t t = fmi1_import_get_variable_base_type(data->var.array.values[0]);
+                ChannelValueInit(&value->val, ChannelTypeArray(Fmi1TypeToChannelType(t), data->var.array.numDims, data->var.array.dims));
+                break;
+            }
+        default:
+            mcx_log(LOG_ERROR, "Fmu1Value: Setup failed: Invalid data type");
+            return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
 void Fmu1ValueDestructor(Fmu1Value * v) {
     if (v->name) {
         mcx_free(v->name);
         v->name = NULL;
     }
 
+    object_destroy(v->data);
+
     ChannelValueDestructor(&v->val);
 }
 
 Fmu1Value * Fmu1ValueCreate(Fmu1Value * v) {
     v->SetFromChannelValue = Fmu1ValueSetFromChannelValue;
+    v->Setup = Fmu1ValueSetup;
 
     v->name = NULL;
-    v->var = NULL;
+    v->data = NULL;
     v->channel = NULL;
     ChannelValueInit(&v->val, ChannelTypeClone(&ChannelTypeUnknown));
 
@@ -44,38 +193,114 @@ Fmu1Value * Fmu1ValueCreate(Fmu1Value * v) {
 
 OBJECT_CLASS(Fmu1Value, Object);
 
-Fmu1Value * Fmu1ValueMake(const char * name, fmi1_import_variable_t * var, Channel * channel) {
+
+static Fmu1Value * Fmu1ValueMake(const char * name, Fmu1ValueData * data, Channel * channel) {
     Fmu1Value * value = (Fmu1Value *)object_create(Fmu1Value);
 
     if (value) {
-        McxStatus retVal = RETURN_OK;
-        fmi1_base_type_enu_t t;
-
-        if (!name || !var) {
-            mcx_log(LOG_ERROR, "Fmu1Value: Setup failed: Name or data missing");
-            mcx_free(value);
+        if (RETURN_OK != value->Setup(value, name, data, channel)) {
+            object_destroy(value);
             return NULL;
         }
+    }
 
-        value->channel = channel;
+    return value;
+}
 
-        t = fmi1_import_get_variable_base_type(var);
+Fmu1Value * Fmu1ValueScalarMake(const char * name, fmi1_import_variable_t * var, Channel * channel) {
+    Fmu1ValueData * data = Fmu1ValueDataScalarMake(var);
+    return Fmu1ValueMake(name, data, channel);
+}
 
-        value->name = mcx_string_copy(name);
-        value->vr = fmi1_import_get_variable_vr(var);
-        value->var = var;
-        ChannelValueInit(&value->val, ChannelTypeClone(Fmi1TypeToChannelType(t)));
+Fmu1Value * Fmu1ValueArrayMake(const char * name, size_t numDims, size_t * dims, fmi1_import_variable_t ** vars, Channel * channel) {
+    Fmu1ValueData * data = Fmu1ValueDataArrayMake(numDims, dims, vars);
+    return Fmu1ValueMake(name, data, channel);
+}
 
-        if (!value->name) {
-            mcx_log(LOG_ERROR, "Fmu1Value: Setup failed: Cannot copy name");
-            mcx_free(value);
-            return NULL;
+Fmu1Value * Fmu1ValueReadScalar(const char * logPrefix, ChannelType * type, Channel * channel, const char * channelName, fmi1_import_t * fmiImport) {
+    Fmu1Value * value = NULL;
+    fmi1_import_variable_t * var = NULL;
+
+    var = fmi1_import_get_variable_by_name(fmiImport, channelName);
+    if (!var) {
+        mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, channelName);
+        return NULL;
+    }
+
+    if (!ChannelTypeEq(type, Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var)))) {
+        mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, channelName);
+        mcx_log(LOG_ERROR,
+                "%s: Expected: %s, Imported from FMU: %s",
+                logPrefix,
+                ChannelTypeToString(type),
+                ChannelTypeToString(Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))));
+        return NULL;
+    }
+
+    value = Fmu1ValueScalarMake(channelName, var, channel);
+    if (!value) {
+        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
+        return RETURN_ERROR;
+    }
+
+    return value;
+}
+
+Fmu1Value * Fmu1ValueReadArray(const char * logPrefix, ChannelType * type, Channel * channel, const char * channelName, ChannelDimension * dimension, fmi1_import_t * fmiImport) {
+    Fmu1Value * value = NULL;
+    fmi1_import_variable_t * var = NULL;
+
+    if (dimension->num > 1) {
+        mcx_log(LOG_ERROR, "%s: Port %s: Invalid dimension", logPrefix, channelName);
+        goto cleanup;
+    }
+
+    size_t i = 0;
+    size_t startIdx = dimension->startIdxs[0];
+    size_t endIdx = dimension->endIdxs[0];
+
+    fmi1_import_variable_t ** vars = mcx_calloc(endIdx - startIdx + 1, sizeof(fmi1_import_variable_t *));
+    if (!vars) {
+        goto cleanup;
+    }
+
+    for (i = startIdx; i <= endIdx; i++) {
+        char * indexedChannelName = CreateIndexedName(channelName, i);
+        fmi1_import_variable_t * var = fmi1_import_get_variable_by_name(fmiImport, indexedChannelName);
+        if (!var) {
+            mcx_log(LOG_ERROR, "%s: Could not get variable %s", logPrefix, indexedChannelName);
+            goto cleanup;
+        }
+        if (!ChannelTypeEq(ChannelTypeArrayInner(type), Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var)))) {
+            mcx_log(LOG_ERROR, "%s: Variable types of %s do not match", logPrefix, indexedChannelName);
+            mcx_log(LOG_ERROR,
+                    "%s: Expected: %s, Imported from FMU: %s",
+                    logPrefix,
+                    ChannelTypeToString(ChannelTypeArrayInner(type)),
+                    ChannelTypeToString(Fmi1TypeToChannelType(fmi1_import_get_variable_base_type(var))));
+            goto cleanup;
         }
+        vars[i - startIdx] = var;
+
+        mcx_free(indexedChannelName);
+    }
+
+    size_t dims[] = {endIdx - startIdx + 1};
+    value = Fmu1ValueArrayMake(channelName, 1 /* numDims */, dims, vars, channel);
+    if (!value) {
+        mcx_log(LOG_ERROR, "%s: Could not set value for channel %s", logPrefix, channelName);
+        goto cleanup;
+    }
+
+cleanup:
+    if (vars) {
+        mcx_free(vars);
     }
 
     return value;
 }
 
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/fmu/Fmu1Value.h b/src/fmu/Fmu1Value.h
index 4fe99dd..3844657 100644
--- a/src/fmu/Fmu1Value.h
+++ b/src/fmu/Fmu1Value.h
@@ -19,11 +19,43 @@
 extern "C" {
 #endif /* __cplusplus */
 
+
+typedef enum Fmu1ValueType {
+    FMU1_VALUE_SCALAR,
+    FMU1_VALUE_ARRAY,
+    FMU1_VALUE_INVALID
+} Fmu1ValueType;
+
+extern const struct ObjectClass _Fmu1ValueData;
+
+typedef struct Fmu1ValueData {
+    Object _;
+
+    Fmu1ValueType type;
+    union {
+        fmi1_import_variable_t * scalar;
+        struct {
+            size_t numDims;
+            size_t * dims;
+            fmi1_import_variable_t ** values;
+        } array;
+    } var;
+    union {
+        fmi1_value_reference_t scalar;
+        struct {
+            fmi1_value_reference_t * values;
+        } array;
+    } vr;
+} Fmu1ValueData;
+
+size_t Fmu1ValueDataArrayNumElems(const Fmu1ValueData * data);
+
 struct Fmu1Value;
 
 typedef struct Fmu1Value Fmu1Value;
 
 typedef McxStatus(*fFmu1ValueSetFromChannelValue)(Fmu1Value * v, ChannelValue * val);
+typedef McxStatus (*fFmu1ValueSetup)(Fmu1Value * value, const char * name, Fmu1ValueData * data, Channel * channel);
 
 extern const struct ObjectClass _Fmu1Value;
 
@@ -31,16 +63,30 @@ struct Fmu1Value {
     Object _; /* base class */
 
     fFmu1ValueSetFromChannelValue SetFromChannelValue;
+    fFmu1ValueSetup Setup;
 
     char * name;
 
     Channel * channel;
-    fmi1_value_reference_t vr;
-    fmi1_import_variable_t * var;
+    Fmu1ValueData * data;
     ChannelValue val;
 };
 
-Fmu1Value * Fmu1ValueMake(const char * name, fmi1_import_variable_t * var, Channel * channel);
+Fmu1Value * Fmu1ValueScalarMake(const char * name, fmi1_import_variable_t * var, Channel * channel);
+Fmu1Value * Fmu1ValueArrayMake(const char * name, size_t numDims, size_t * dims, fmi1_import_variable_t ** vars, Channel * channel);
+
+Fmu1Value * Fmu1ValueReadScalar(const char * logPrefix,
+                                ChannelType * type,
+                                Channel * channel,
+                                const char * channelName,
+                                fmi1_import_t * fmiImport);
+Fmu1Value * Fmu1ValueReadArray(const char * logPrefix,
+                               ChannelType * type,
+                               Channel * channel,
+                               const char * channelName,
+                               ChannelDimension * dimension,
+                               fmi1_import_t * fmiImport);
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/fmu/common_fmu1.c b/src/fmu/common_fmu1.c
index ecdc12b..41582bd 100644
--- a/src/fmu/common_fmu1.c
+++ b/src/fmu/common_fmu1.c
@@ -292,7 +292,7 @@ Fmu1Value * Fmu1ReadParamValue(ScalarParameterInput * input, fmi1_import_t * imp
         return NULL;
     }
 
-    val = Fmu1ValueMake(input->name, var, NULL);
+    val = Fmu1ValueScalarMake(input->name, var, NULL);
     if (!val) {
         return NULL;
     }
@@ -375,7 +375,7 @@ static ObjectContainer * Fmu1ReadArrayParamValues(const char * name,
                 goto cleanup_1;
             }
 
-            val = Fmu1ValueMake(varName, var, NULL);
+            val = Fmu1ValueScalarMake(varName, var, NULL);
             if (!val) {
                 retVal = RETURN_ERROR;
                 goto cleanup_1;
@@ -538,9 +538,6 @@ ObjectContainer * Fmu1ReadParams(ParametersInput * input, fmi1_import_t * import
 McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     fmi1_status_t status = fmi1_status_ok;
 
-    fmi1_import_variable_t * var = fmuVal->var;
-    fmi1_value_reference_t vr[] = { fmuVal->vr };
-
     Channel * channel = fmuVal->channel;
     if (channel && FALSE == channel->IsDefinedDuringInit(channel)) {
         MCX_DEBUG_LOG("Fmu1SetVariable: %s not set: no defined value during initialization", fmuVal->name);
@@ -553,8 +550,9 @@ McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     switch (type->con) {
     case CHANNEL_DOUBLE:
     {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
         double value = chVal->value.d;
-        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
+        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             value *= -1.;
         }
         status = fmi1_import_set_real(fmu->fmiImport, vr, 1, &value);
@@ -562,8 +560,9 @@ McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     break;
     case CHANNEL_INTEGER:
     {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
         int value = chVal->value.i;
-        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
+            if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             value *= -1;
         }
         status = fmi1_import_set_integer(fmu->fmiImport, vr, 1, &value);
@@ -571,16 +570,38 @@ McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     break;
     case CHANNEL_BOOL:
     {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
         fmi1_boolean_t value = chVal->value.i;
-        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
+        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             value = !value;
         }
         status = fmi1_import_set_boolean(fmu->fmiImport, vr, 1, &value);
     }
     break;
     case CHANNEL_STRING:
+    {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
         status = fmi1_import_set_string(fmu->fmiImport, vr, 1, (fmi1_string_t *) &chVal->value.s);
         break;
+    }
+    case CHANNEL_ARRAY:
+    {
+        fmi1_value_reference_t * vrs = fmuVal->data->vr.array.values;
+        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
+
+        size_t num = mcx_array_num_elements(a);
+        void * vals = a->data;
+
+        if (ChannelTypeEq(a->type, &ChannelTypeDouble)) {
+            status = fmi1_import_set_real(fmu->fmiImport, vrs, num, vals);
+        } else if (ChannelTypeEq(a->type, &ChannelTypeInteger)) {
+            status = fmi1_import_set_integer(fmu->fmiImport, vrs, num, vals);
+        } else {
+            mcx_log(LOG_ERROR, "FMU: Unsupported array variable type: %s", ChannelTypeToString(a->type));
+            return RETURN_ERROR;
+        }
+        break;
+    }
     default:
         mcx_log(LOG_WARNING, "FMU: Unknown variable type");
         break;
@@ -589,13 +610,13 @@ McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     if (fmi1_status_ok != status) {
         if (fmi1_status_error == status || fmi1_status_fatal == status) {
             fmu->runOk = fmi1_false;
-            mcx_log(LOG_ERROR, "FMU: Setting of variable %s (%d) failed", fmi1_import_get_variable_name(var), vr[0]);
+            mcx_log(LOG_ERROR, "FMU: Setting of variable %s failed", fmuVal->name);
             return RETURN_ERROR;
         } else {
             if (fmi1_status_warning == status) {
-                mcx_log(LOG_WARNING, "FMU: Setting of variable %s (%d) returned with a warning", fmi1_import_get_variable_name(var), vr[0]);
+                mcx_log(LOG_WARNING, "FMU: Setting of variable %s returned with a warning", fmuVal->name);
             } else if (fmi1_status_discard == status) {
-                mcx_log(LOG_WARNING, "FMU: Setting of variable %s (%d) discarded", fmi1_import_get_variable_name(var), vr[0]);
+                mcx_log(LOG_WARNING, "FMU: Setting of variable %s discarded", fmuVal->name);
             }
         }
     } else {
@@ -628,33 +649,40 @@ McxStatus Fmu1SetVariableArray(Fmu1CommonStruct * fmu, ObjectContainer * vals) {
 McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     fmi1_status_t status = fmi1_status_ok;
 
-    fmi1_import_variable_t * var = fmuVal->var;
-    fmi1_value_reference_t vr[] = { fmuVal->vr };
-
     ChannelValue * const chVal = &fmuVal->val;
     ChannelType * type = ChannelValueType(chVal);
 
     switch (type->con) {
     case CHANNEL_DOUBLE:
-        status = fmi1_import_get_real(fmu->fmiImport, vr, 1, (fmi1_real_t *)ChannelValueReference(chVal));
-        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
+    {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
+        status = fmi1_import_get_real(fmu->fmiImport, vr, 1, (fmi1_real_t *) ChannelValueReference(chVal));
+        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             fmuVal->val.value.d *= -1.;
         }
         break;
+    }
     case CHANNEL_INTEGER:
-        status = fmi1_import_get_integer(fmu->fmiImport, vr, 1, (fmi1_integer_t *)ChannelValueReference(chVal));
-        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
+    {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
+        status = fmi1_import_get_integer(fmu->fmiImport, vr, 1, (fmi1_integer_t *) ChannelValueReference(chVal));
+        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             fmuVal->val.value.i *= -1;
         }
         break;
+    }
     case CHANNEL_BOOL:
-        status = fmi1_import_get_boolean(fmu->fmiImport, vr, 1, (fmi1_boolean_t *)ChannelValueReference(chVal));
-        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(var)) {
+    {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
+        status = fmi1_import_get_boolean(fmu->fmiImport, vr, 1, (fmi1_boolean_t *) ChannelValueReference(chVal));
+        if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             fmuVal->val.value.i = !fmuVal->val.value.i;
         }
         break;
+    }
     case CHANNEL_STRING:
     {
+        fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
         char * buffer = NULL;
 
         status = fmi1_import_get_string(fmu->fmiImport, vr, 1, (fmi1_string_t *)&buffer);
@@ -663,6 +691,24 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
         }
         break;
     }
+    case CHANNEL_ARRAY:
+    {
+        fmi1_value_reference_t * vrs = fmuVal->data->vr.array.values;
+        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
+
+        size_t num = mcx_array_num_elements(a);
+        void * vals = a->data;
+
+        if (ChannelTypeEq(a->type, &ChannelTypeDouble)) {
+            status = fmi1_import_get_real(fmu->fmiImport, vrs, num, vals);
+        } else if (ChannelTypeEq(a->type, &ChannelTypeInteger)) {
+            status = fmi1_import_get_integer(fmu->fmiImport, vrs, num, vals);
+        } else {
+            mcx_log(LOG_ERROR, "FMU: Unsupported array variable type: %s", ChannelTypeToString(a->type));
+            return RETURN_ERROR;
+        }
+        break;
+    }
     default:
         mcx_log(LOG_WARNING, "FMU: Unknown variable type");
         break;
@@ -671,7 +717,7 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     if (fmi1_status_ok != status) {
         if (fmi1_status_error == status || fmi1_status_fatal == status) {
             fmu->runOk = fmi1_false;
-            mcx_log(LOG_ERROR, "FMU: Getting of variable %s (%d) failed", fmi1_import_get_variable_name(var), vr[0]);
+            mcx_log(LOG_ERROR, "FMU: Getting of variable %s failed", fmuVal->name);
             return RETURN_ERROR;
         } else {
             // TODO: handle warning
@@ -723,7 +769,7 @@ McxStatus fmi1CreateValuesOutOfVariables(ObjectContainer * vals, fmi1_import_var
         Fmu1Value * val = NULL;
         const char * name = fmi1_import_get_variable_name(actualVar);
 
-        val = Fmu1ValueMake(name, actualVar, NULL);
+        val = Fmu1ValueScalarMake(name, actualVar, NULL);
 
         retVal = vals->PushBack(vals, (Object *)val);
         if (RETURN_ERROR == retVal) {
@@ -745,7 +791,7 @@ McxStatus fmi1AddLocalChannelsFromLocalValues(ObjectContainer * vals, const char
 
     for (i = 0; i < sizeList; i++) {
         Fmu1Value * val = (Fmu1Value *) vals->At(vals, i);
-        fmi1_import_variable_t * actualVar = val->var;
+        fmi1_import_variable_t * actualVar = val->data->var.scalar;  // TODO array
 
         const char * name = NULL;
         fmi1_base_type_enu_t type;

From f44dd6d0c2ad8342f78bd479f9f70305495fc681 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 24 May 2022 07:32:52 +0200
Subject: [PATCH 117/166] Extend conversions to slices

---
 src/core/Conversion.c                     | 513 +++++++++++++++-------
 src/core/Conversion.h                     |   8 +-
 src/core/Model.c                          |  51 ++-
 src/core/channels/Channel.c               |   4 +-
 src/core/channels/ChannelValueReference.c |  20 +
 src/core/channels/ChannelValueReference.h |   2 +
 6 files changed, 419 insertions(+), 179 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index be83f8a..f601665 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -36,15 +36,158 @@ OBJECT_CLASS(Conversion, Object);
 
 // ----------------------------------------------------------------------
 // Range Conversion
+static int RangeConversionElemwiseLeq(void * first, void * second, ChannelType * type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) first <= *(double *) second;
+        case CHANNEL_INTEGER:
+            return *(int *) first <= *(int *) second;
+        default:
+            return 0;
+    }
+}
+
+static int RangeConversionElemwiseGeq(void * first, void * second, ChannelType * type) {
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+            return *(double *) first >= *(double *) second;
+        case CHANNEL_INTEGER:
+            return *(int *) first >= *(int *) second;
+        default:
+            return 0;
+    }
+}
+
+static McxStatus RangeConversionConvert(Conversion * conversion, ChannelValue * value) {
+    RangeConversion * rangeConversion = (RangeConversion *) conversion;
+    McxStatus retVal = RETURN_OK;
 
-McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * value) {
+    if (!ChannelTypeEq(ChannelValueType(value), rangeConversion->type)) {
+        mcx_log(LOG_ERROR,
+                "Range conversion: Value has wrong type %s, expected: %s",
+                ChannelTypeToString(ChannelValueType(value)),
+                ChannelTypeToString(rangeConversion->type));
+        return RETURN_ERROR;
+    }
+
+    if (rangeConversion->min) {
+        retVal = ChannelValueDataSetFromReferenceIfElemwisePred(&value->value,
+                                                                value->type,
+                                                                &rangeConversion->min->value,
+                                                                RangeConversionElemwiseLeq);
+        if (RETURN_OK != retVal) {
+            mcx_log(LOG_ERROR, "Range conversion: Set value to min failed");
+            return RETURN_ERROR;
+        }
+    }
+
+    if (rangeConversion->max) {
+        retVal = ChannelValueDataSetFromReferenceIfElemwisePred(&value->value,
+                                                                value->type,
+                                                                &rangeConversion->max->value,
+                                                                RangeConversionElemwiseGeq);
+        if (RETURN_OK != retVal) {
+            mcx_log(LOG_ERROR, "Range conversion: Set value to max failed");
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
+McxStatus RangeConversionMinValueRefConversion(void * element, size_t idx, ChannelType * type, void * ctx) {
+    ChannelValue * min = (ChannelValue *) ctx;
+    void * minElem = mcx_array_get_elem_reference(&min->value.a, idx);
+    if (RangeConversionElemwiseLeq(element, minElem, type)) {
+        switch (type->con)
+        {
+            case CHANNEL_DOUBLE:
+            {
+                double * elem = (double *) element;
+                *elem = *((double *)minElem);
+                break;
+            }
+        case CHANNEL_INTEGER:
+            {
+                int * elem = (int *) element;
+                *elem = *((int *)minElem);
+                break;
+            }
+        default:
+            mcx_log(LOG_ERROR, "RangeConversion: Unsupported type");
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
+McxStatus RangeConversionMaxValueRefConversion(void * element, size_t idx, ChannelType * type, void * ctx) {
+    ChannelValue * max = (ChannelValue *) ctx;
+    void * maxElem = mcx_array_get_elem_reference(&max->value.a, idx);
+    if (RangeConversionElemwiseGeq(element, maxElem, type)) {
+        switch (type->con)
+        {
+            case CHANNEL_DOUBLE:
+            {
+                double * elem = (double *) element;
+                *elem = *((double *)maxElem);
+                break;
+            }
+        case CHANNEL_INTEGER:
+            {
+                int * elem = (int *) element;
+                *elem = *((int *)maxElem);
+                break;
+            }
+        default:
+            mcx_log(LOG_ERROR, "RangeConversion: Unsupported type");
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
+static McxStatus RangeConversionConvertValueRef(RangeConversion * conversion, ChannelValueRef * ref) {
+    RangeConversion * rangeConversion = (RangeConversion *) conversion;
+    McxStatus retVal = RETURN_OK;
+
+    if (!ChannelTypeEq(ChannelValueRefGetType(ref), rangeConversion->type)) {
+        mcx_log(LOG_ERROR,
+                "Range conversion: Value has wrong type %s, expected: %s",
+                ChannelTypeToString(ChannelValueRefGetType(ref)),
+                ChannelTypeToString(rangeConversion->type));
+        return RETURN_ERROR;
+    }
+
+    if (rangeConversion->min) {
+        retVal = ChannelValueRefElemMap(ref, RangeConversionMinValueRefConversion, rangeConversion->min);
+        if (RETURN_OK != retVal) {
+            mcx_log(LOG_ERROR, "Range conversion: Set value to min failed");
+            return RETURN_ERROR;
+        }
+    }
+
+    if (rangeConversion->max) {
+        retVal = ChannelValueRefElemMap(ref, RangeConversionMaxValueRefConversion, rangeConversion->max);
+        if (RETURN_OK != retVal) {
+            mcx_log(LOG_ERROR, "Range conversion: Set value to max failed");
+            return RETURN_ERROR;
+        }
+    }
+
+    return RETURN_OK;
+}
+
+McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * value, ChannelDimension * slice) {
     RangeConversion * rangeConv = NULL;
     ChannelValue * minToUse = NULL;
     ChannelValue * maxToUse = NULL;
 
     McxStatus retVal = RETURN_OK;
 
-    if (!ChannelTypeEq(value->type, &ChannelTypeDouble) && !ChannelTypeEq(value->type, &ChannelTypeInteger)) {
+    if (!ChannelTypeEq(ChannelTypeBaseType(value->type), &ChannelTypeDouble) && !ChannelTypeEq(ChannelTypeBaseType(value->type), &ChannelTypeInteger)) {
         return RETURN_OK;
     }
 
@@ -82,9 +225,15 @@ McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * va
     }
 
     if (rangeConv) {
-        Conversion * conversion = (Conversion *) rangeConv;
-        retVal = conversion->convert(conversion, value);
-        if (RETURN_OK != retVal) {
+        if (slice) {
+            ChannelValueRef * ref = MakeChannelValueRef(value, slice);
+            retVal = RangeConversionConvertValueRef(rangeConv, ref);
+            object_destroy(ref);
+        } else {
+            retVal = RangeConversionConvert(rangeConv, value);
+        }
+
+        if (retVal == RETURN_ERROR) {
             mcx_log(LOG_ERROR, "ConvertRange: Conversion failed");
             goto cleanup;
         }
@@ -104,65 +253,6 @@ McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * va
     return retVal;
 }
 
-static int RangeConversionElemwiseLeq(void * first, void * second, ChannelType * type) {
-    switch (type->con) {
-        case CHANNEL_DOUBLE:
-            return *(double *) first <= *(double *) second;
-        case CHANNEL_INTEGER:
-            return *(int *) first <= *(int *) second;
-        default:
-            return 0;
-    }
-}
-
-static int RangeConversionElemwiseGeq(void * first, void * second, ChannelType * type) {
-    switch (type->con) {
-        case CHANNEL_DOUBLE:
-            return *(double *) first >= *(double *) second;
-        case CHANNEL_INTEGER:
-            return *(int *) first >= *(int *) second;
-        default:
-            return 0;
-    }
-}
-
-static McxStatus RangeConversionConvert(Conversion * conversion, ChannelValue * value) {
-    RangeConversion * rangeConversion = (RangeConversion *) conversion;
-    McxStatus retVal = RETURN_OK;
-
-    if (!ChannelTypeEq(ChannelValueType(value), rangeConversion->type)) {
-        mcx_log(LOG_ERROR,
-                "Range conversion: Value has wrong type %s, expected: %s",
-                ChannelTypeToString(ChannelValueType(value)),
-                ChannelTypeToString(rangeConversion->type));
-        return RETURN_ERROR;
-    }
-
-    if (rangeConversion->min) {
-        retVal = ChannelValueDataSetFromReferenceIfElemwisePred(&value->value,
-                                                                value->type,
-                                                                &rangeConversion->min->value,
-                                                                RangeConversionElemwiseLeq);
-        if (RETURN_OK != retVal) {
-            mcx_log(LOG_ERROR, "Range conversion: Set value to min failed");
-            return RETURN_ERROR;
-        }
-    }
-
-    if (rangeConversion->max) {
-        retVal = ChannelValueDataSetFromReferenceIfElemwisePred(&value->value,
-                                                                value->type,
-                                                                &rangeConversion->max->value,
-                                                                RangeConversionElemwiseGeq);
-        if (RETURN_OK != retVal) {
-            mcx_log(LOG_ERROR, "Range conversion: Set value to max failed");
-            return RETURN_ERROR;
-        }
-    }
-
-    return RETURN_OK;
-}
-
 static McxStatus RangeConversionSetup(RangeConversion * conversion, ChannelValue * min, ChannelValue * max) {
     if (!min && !max) {
         return RETURN_OK;
@@ -272,42 +362,6 @@ static double UnitConversionConvertValue(UnitConversion * conversion, double val
     return value;
 }
 
-McxStatus ConvertUnit(const char * fromUnit, const char * toUnit, ChannelValue * value) {
-    UnitConversion * unitConv = NULL;
-
-    McxStatus retVal = RETURN_OK;
-
-    unitConv = (UnitConversion *) object_create(UnitConversion);
-    if (!unitConv) {
-        mcx_log(LOG_ERROR, "ConvertUnit: Not enough memory");
-        return RETURN_ERROR;
-    }
-
-    retVal = unitConv->Setup(unitConv, fromUnit, toUnit);
-    if (RETURN_ERROR == retVal) {
-        mcx_log(LOG_ERROR, "ConvertUnit: Conversion setup failed");
-        goto cleanup;
-    }
-
-    if (unitConv->IsEmpty(unitConv)) {
-        object_destroy(unitConv);
-    }
-
-    if (unitConv) {
-        Conversion * conv = (Conversion *) unitConv;
-        retVal = conv->convert(conv, value);
-        if (retVal == RETURN_ERROR) {
-            mcx_log(LOG_ERROR, "ConvertUnit: Conversion failed");
-            goto cleanup;
-        }
-    }
-
-cleanup:
-    object_destroy(unitConv);
-
-    return retVal;
-}
-
 static void UnitConversionConvertVector(UnitConversion * unitConversion, double * vector, size_t vectorLength) {
     size_t i;
     if (!unitConversion->IsEmpty(unitConversion)) {
@@ -405,6 +459,48 @@ static int UnitConversionIsEmpty(UnitConversion * conversion) {
         || (conversion->target.factor == 0.0 && conversion->target.offset == 0.0);
 }
 
+McxStatus ConvertUnit(const char * fromUnit, const char * toUnit, ChannelValue * value, ChannelDimension * slice) {
+    UnitConversion * unitConv = NULL;
+
+    McxStatus retVal = RETURN_OK;
+
+    unitConv = (UnitConversion *) object_create(UnitConversion);
+    if (!unitConv) {
+        mcx_log(LOG_ERROR, "ConvertUnit: Not enough memory");
+        return RETURN_ERROR;
+    }
+
+    retVal = unitConv->Setup(unitConv, fromUnit, toUnit);
+    if (RETURN_ERROR == retVal) {
+        mcx_log(LOG_ERROR, "ConvertUnit: Conversion setup failed");
+        goto cleanup;
+    }
+
+    if (unitConv->IsEmpty(unitConv)) {
+        object_destroy(unitConv);
+    }
+
+    if (unitConv) {
+        if (slice) {
+            ChannelValueRef * ref = MakeChannelValueRef(value, slice);
+            retVal = UnitConversionConvertValueRef(unitConv, ref);
+            object_destroy(ref);
+        } else {
+            retVal = UnitConversionConvert(unitConv, value);
+        }
+
+        if (retVal == RETURN_ERROR) {
+            mcx_log(LOG_ERROR, "ConvertUnit: Conversion failed");
+            goto cleanup;
+        }
+    }
+
+cleanup:
+    object_destroy(unitConv);
+
+    return retVal;
+}
+
 static void UnitConversionDestructor(UnitConversion * conversion) {
 
 }
@@ -433,81 +529,97 @@ OBJECT_CLASS(UnitConversion, Conversion);
 
 // ----------------------------------------------------------------------
 // Linear Conversion
-
-McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelValue * value) {
-    LinearConversion * linearConv = NULL;
-    ChannelValue * factorToUse = NULL;
-    ChannelValue * offsetToUse = NULL;
+static McxStatus LinearConversionConvert(Conversion * conversion, ChannelValue * value) {
+    LinearConversion * linearConversion = (LinearConversion *) conversion;
 
     McxStatus retVal = RETURN_OK;
 
-    if (!ChannelTypeEq(value->type, &ChannelTypeDouble) && !ChannelTypeEq(value->type, &ChannelTypeInteger)) {
-        return RETURN_OK;
-    }
-
-    linearConv = (LinearConversion *) object_create(LinearConversion);
-    if (!linearConv) {
-        mcx_log(LOG_ERROR, "ConvertLinear: Not enough memory");
-        return RETURN_ERROR;
-    }
-
-    factorToUse = factor ? ChannelValueClone(factor) : NULL;
-    if (factor && !factorToUse) {
-        mcx_log(LOG_ERROR, "ConvertLinear: Not enough memory for factor");
-        retVal = RETURN_ERROR;
-        goto cleanup;
+    if (linearConversion->factor) {
+        retVal = ChannelValueScale(value, linearConversion->factor);
+        if (RETURN_OK != retVal) {
+            mcx_log(LOG_ERROR, "Linear conversion: Port value scaling failed");
+            return RETURN_ERROR;
+        }
     }
 
-    offsetToUse = offset ? ChannelValueClone(offset) : NULL;
-    if (offset && !offsetToUse) {
-        mcx_log(LOG_ERROR, "ConvertLinear: Not enough memory for offset");
-        retVal = RETURN_ERROR;
-        goto cleanup;
+    if (linearConversion->offset) {
+        retVal = ChannelValueAddOffset(value, linearConversion->offset);
+        if (RETURN_OK != retVal) {
+            mcx_log(LOG_ERROR, "Linear conversion: Adding offset failed");
+            return RETURN_ERROR;
+        }
     }
 
-    retVal = linearConv->Setup(linearConv, factorToUse, offsetToUse);
-    if (retVal == RETURN_ERROR) {
-        mcx_log(LOG_ERROR, "ConvertLinear: Conversion setup failed");
-        goto cleanup;
-    }
+    return RETURN_OK;
+}
 
-    factorToUse = NULL;
-    offsetToUse = NULL;
+McxStatus LinearConversionScaleValueRefConversion(void * element, size_t idx, ChannelType * type, void * ctx) {
+    ChannelValue * factor = (ChannelValue *) ctx;
+    void * factorElem = mcx_array_get_elem_reference(&factor->value.a, idx);
 
-    if (linearConv->IsEmpty(linearConv)) {
-        object_destroy(linearConv);
+    if (!ChannelTypeEq(type, factor->type)) {
+        mcx_log(LOG_ERROR, "Port: Scale: Mismatching types. Value type: %s, factor type: %s",
+                ChannelTypeToString(type), ChannelTypeToString(ChannelValueType(factor)));
+        return RETURN_ERROR;
     }
 
-    if (linearConv) {
-        Conversion * conversion = (Conversion *) linearConv;
-        retVal = conversion->convert(conversion, value);
-        if (RETURN_OK != retVal) {
-            mcx_log(LOG_ERROR, "ConvertLinear: Conversion failed");
-            goto cleanup;
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+        {
+            double * elem = (double *) element;
+            *elem = *elem * *((double *)factorElem);
+            break;
+        }
+        case CHANNEL_INTEGER:
+        {
+            int * elem = (int *) element;
+            *elem = *elem * *((int *)factorElem);
+            break;
         }
+        default:
+            mcx_log(LOG_ERROR, "Linear conversion: Unsupported type");
+            return RETURN_ERROR;
     }
 
-cleanup:
-    if (factorToUse) {
-        mcx_free(factorToUse);
-    }
+    return RETURN_OK;
+}
 
-    if (offsetToUse) {
-        mcx_free(offsetToUse);
+McxStatus LinearConversionOffsetValueRefConversion(void * element, size_t idx, ChannelType * type, void * ctx) {
+    ChannelValue * offset = (ChannelValue *) ctx;
+    void * offsetElem = mcx_array_get_elem_reference(&offset->value.a, idx);
+
+    if (!ChannelTypeEq(type, offset->type)) {
+        mcx_log(LOG_ERROR, "Port: Scale: Mismatching types. Value type: %s, factor type: %s",
+                ChannelTypeToString(type), ChannelTypeToString(ChannelValueType(offset)));
+        return RETURN_ERROR;
     }
 
-    object_destroy(linearConv);
+    switch (type->con) {
+        case CHANNEL_DOUBLE:
+        {
+            double * elem = (double *) element;
+            *elem = *elem + *((double *)offsetElem);
+            break;
+        }
+        case CHANNEL_INTEGER:
+        {
+            int * elem = (int *) element;
+            *elem = *elem + *((int *)offsetElem);
+            break;
+        }
+        default:
+            mcx_log(LOG_ERROR, "Linear conversion: Unsupported type");
+            return RETURN_ERROR;
+    }
 
-    return retVal;
+    return RETURN_OK;
 }
 
-static McxStatus LinearConversionConvert(Conversion * conversion, ChannelValue * value) {
-    LinearConversion * linearConversion = (LinearConversion *) conversion;
-
+static McxStatus LinearConversionConvertValueRef(LinearConversion * linearConversion, ChannelValueRef * ref) {
     McxStatus retVal = RETURN_OK;
 
     if (linearConversion->factor) {
-        retVal = ChannelValueScale(value, linearConversion->factor);
+        retVal = ChannelValueRefElemMap(ref, LinearConversionScaleValueRefConversion, linearConversion->factor);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Linear conversion: Port value scaling failed");
             return RETURN_ERROR;
@@ -515,7 +627,7 @@ static McxStatus LinearConversionConvert(Conversion * conversion, ChannelValue *
     }
 
     if (linearConversion->offset) {
-        retVal = ChannelValueAddOffset(value, linearConversion->offset);
+        retVal = ChannelValueRefElemMap(ref, LinearConversionOffsetValueRefConversion, linearConversion->offset);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Linear conversion: Adding offset failed");
             return RETURN_ERROR;
@@ -593,6 +705,79 @@ static int LinearConversionIsEmpty(LinearConversion * conversion) {
     }
 }
 
+McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelValue * value, ChannelDimension * slice) {
+    LinearConversion * linearConv = NULL;
+    ChannelValue * factorToUse = NULL;
+    ChannelValue * offsetToUse = NULL;
+
+    McxStatus retVal = RETURN_OK;
+
+    if (!ChannelTypeEq(ChannelTypeBaseType(value->type), &ChannelTypeDouble) && !ChannelTypeEq(ChannelTypeBaseType(value->type), &ChannelTypeInteger)) {
+        return RETURN_OK;
+    }
+
+    linearConv = (LinearConversion *) object_create(LinearConversion);
+    if (!linearConv) {
+        mcx_log(LOG_ERROR, "ConvertLinear: Not enough memory");
+        return RETURN_ERROR;
+    }
+
+    factorToUse = factor ? ChannelValueClone(factor) : NULL;
+    if (factor && !factorToUse) {
+        mcx_log(LOG_ERROR, "ConvertLinear: Not enough memory for factor");
+        retVal = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    offsetToUse = offset ? ChannelValueClone(offset) : NULL;
+    if (offset && !offsetToUse) {
+        mcx_log(LOG_ERROR, "ConvertLinear: Not enough memory for offset");
+        retVal = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    retVal = linearConv->Setup(linearConv, factorToUse, offsetToUse);
+    if (retVal == RETURN_ERROR) {
+        mcx_log(LOG_ERROR, "ConvertLinear: Conversion setup failed");
+        goto cleanup;
+    }
+
+    factorToUse = NULL;
+    offsetToUse = NULL;
+
+    if (linearConv->IsEmpty(linearConv)) {
+        object_destroy(linearConv);
+    }
+
+    if (linearConv) {
+        if (slice) {
+            ChannelValueRef * ref = MakeChannelValueRef(value, slice);
+            retVal = LinearConversionConvertValueRef(linearConv, ref);
+            object_destroy(ref);
+        } else {
+            retVal = LinearConversionConvert(linearConv, value);
+        }
+
+        if (RETURN_OK != retVal) {
+            mcx_log(LOG_ERROR, "ConvertLinear: Conversion failed");
+            goto cleanup;
+        }
+    }
+
+cleanup:
+    if (factorToUse) {
+        mcx_free(factorToUse);
+    }
+
+    if (offsetToUse) {
+        mcx_free(offsetToUse);
+    }
+
+    object_destroy(linearConv);
+
+    return retVal;
+}
+
 static void LinearConversionDestructor(LinearConversion * linearConversion) {
     if (linearConversion->type) {
         ChannelTypeDestructor(linearConversion->type);
@@ -626,35 +811,35 @@ OBJECT_CLASS(LinearConversion, Conversion);
 
 // ----------------------------------------------------------------------
 // Type Conversion
-
-McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue * value) {
+McxStatus ConvertType(ChannelValue * dest, ChannelDimension * destSlice, ChannelValue * src, ChannelDimension * srcSlice) {
     TypeConversion * typeConv = NULL;
-    Conversion * conv = NULL;
+    ChannelValueRef * ref = NULL;
 
     McxStatus retVal = RETURN_OK;
 
     typeConv = (TypeConversion *) object_create(TypeConversion);
     if (!typeConv) {
-        mcx_log(LOG_ERROR, "ConvertType: Not enough memory");
+        mcx_log(LOG_ERROR, "ConvertType: Converter allocation failed");
         return RETURN_ERROR;
     }
 
-    conv = (Conversion *) typeConv;
-
-    retVal = typeConv->Setup(typeConv, fromType, NULL, toType, NULL);
+    retVal = typeConv->Setup(typeConv, src->type, srcSlice, dest->type, destSlice);
     if (retVal == RETURN_ERROR) {
-        mcx_log(LOG_ERROR, "ConvertType: Conversion setup failed");
+        mcx_log(LOG_ERROR, "ConvertType: Setup failed");
         goto cleanup;
     }
 
-    retVal = conv->convert(conv, value);
-    if (retVal == RETURN_ERROR) {
-        mcx_log(LOG_ERROR, "Type conversion failed");
+    ref = MakeChannelValueRef(dest, destSlice);
+    if (!ref) {
+        mcx_log(LOG_ERROR, "ConvertType: Value reference allocation failed");
         goto cleanup;
     }
 
+    ChannelValueRefSetFromReference(ref, ChannelValueReference(src), srcSlice, typeConv);
+
 cleanup:
     object_destroy(typeConv);
+    object_destroy(ref);
 
     return retVal;
 }
diff --git a/src/core/Conversion.h b/src/core/Conversion.h
index 7ac4c34..fe98f8b 100644
--- a/src/core/Conversion.h
+++ b/src/core/Conversion.h
@@ -59,7 +59,7 @@ typedef struct RangeConversion {
 
 } RangeConversion;
 
-McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * value);
+McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * value, ChannelDimension * slice);
 
 
 // ----------------------------------------------------------------------
@@ -87,7 +87,7 @@ struct UnitConversion {
     fUnitConversionVector convertVector;
 };
 
-McxStatus ConvertUnit(const char * fromUnit, const char * toUnit, ChannelValue * value);
+McxStatus ConvertUnit(const char * fromUnit, const char * toUnit, ChannelValue * value, ChannelDimension * slice);
 
 
 // ----------------------------------------------------------------------
@@ -113,7 +113,7 @@ typedef struct LinearConversion {
 
 } LinearConversion;
 
-McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelValue * value);
+McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelValue * value, ChannelDimension * slice);
 
 
 // ----------------------------------------------------------------------
@@ -141,7 +141,7 @@ struct TypeConversion {
     ChannelDimension * sourceSlice;
 };
 
-McxStatus ConvertType(ChannelType * fromType, ChannelType * toType, ChannelValue * value);
+McxStatus ConvertType(ChannelValue * dest, ChannelDimension * destSlice, ChannelValue * src, ChannelDimension * srcSlice);
 
 
 #ifdef __cplusplus
diff --git a/src/core/Model.c b/src/core/Model.c
index f828ec0..4d9b1b2 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -24,6 +24,7 @@
 
 #include "core/Databus.h"
 #include "core/channels/Channel.h"
+#include "core/channels/ChannelValueReference.h"
 #include "core/channels/ChannelInfo.h"
 #include "core/connections/Connection.h"
 #include "core/connections/FilteredConnection.h"
@@ -177,10 +178,12 @@ static McxStatus ModelPreprocessConstConnections(Model * model) {
         CompConstant * srcCompConst = NULL;
         Databus * srcDb = srcComp->GetDatabus(srcComp);
         ChannelInfo * srcChannelInfo = DatabusGetOutChannelInfo(srcDb, info->sourceChannel);
+        ChannelDimension * srcDim = NULL;
 
         Component * trgComp = info->targetComponent;
         Databus * trgDb = trgComp->GetDatabus(trgComp);
         ChannelInfo * trgChannelInfo = DatabusGetInChannelInfo(trgDb, info->targetChannel);
+        ChannelDimension * trgDim = NULL;
 
         // if not a const conn, add to the filtered conns
         if (0 != strcmp(compConstantTypeString, srcComp->GetType(srcComp))) {
@@ -203,34 +206,61 @@ static McxStatus ModelPreprocessConstConnections(Model * model) {
             goto cleanup_1;
         }
 
+        if (!trgChannelInfo->defaultValue) {
+            trgChannelInfo->defaultValue = (ChannelValue *) mcx_calloc(1, sizeof(ChannelValue));
+            ChannelValueInit(trgChannelInfo->defaultValue, ChannelTypeClone(trgChannelInfo->type));
+        }
+
+        // prepare slice dimensions
+        srcDim = ChannelDimensionClone(info->sourceDimension);
+        if (info->sourceDimension && !srcDim) {
+            mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Source dimension slice allocation failed");
+            goto cleanup_1;
+        }
+
+        retVal = ChannelDimensionNormalize(srcDim, srcChannelInfo->dimension);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Source dimension normalization failed");
+            goto cleanup_1;
+        }
+
+        trgDim = ChannelDimensionClone(info->targetDimension);
+        if (info->targetDimension && !trgDim) {
+            mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Target dimension slice allocation failed");
+            goto cleanup_1;
+        }
+
+        retVal = ChannelDimensionNormalize(trgDim, trgChannelInfo->dimension);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Target dimension normalization failed");
+            goto cleanup_1;
+        }
+
         // out channel range and linear conversions
-        retVal = ConvertRange(srcChannelInfo->min, srcChannelInfo->max, src);
+        retVal = ConvertRange(srcChannelInfo->min, srcChannelInfo->max, src, srcDim);
         if (retVal == RETURN_ERROR) {
             goto cleanup_1;
         }
 
-        retVal = ConvertLinear(srcChannelInfo->scale, srcChannelInfo->offset, src);
+        retVal = ConvertLinear(srcChannelInfo->scale, srcChannelInfo->offset, src, srcDim);
         if (retVal == RETURN_ERROR) {
             goto cleanup_1;
         }
 
         // type conversion
-        retVal = ConvertType(srcChannelInfo->type, trgChannelInfo->type, src);
+        retVal = ConvertType(trgChannelInfo->defaultValue, trgDim, src, srcDim);
         if (retVal == RETURN_ERROR) {
             goto cleanup_1;
         }
 
         // unit conversion
-        retVal = ConvertUnit(srcChannelInfo->unitString, trgChannelInfo->unitString, src);
+        retVal = ConvertUnit(srcChannelInfo->unitString, trgChannelInfo->unitString, trgChannelInfo->defaultValue, trgDim);
         if (retVal == RETURN_ERROR) {
             goto cleanup_1;
         }
 
-        // set the default value
-        if (trgChannelInfo->defaultValue) {
-            ChannelValueDestructor(trgChannelInfo->defaultValue);
-        }
-        trgChannelInfo->defaultValue = src;
+        object_destroy(srcDim);
+        object_destroy(trgDim);
 
         continue;
 
@@ -240,6 +270,9 @@ static McxStatus ModelPreprocessConstConnections(Model * model) {
             mcx_free(src);
         }
 
+        object_destroy(srcDim);
+        object_destroy(trgDim);
+
         retVal = RETURN_ERROR;
         goto cleanup;
     }
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 53b7d05..bc673d1 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -508,12 +508,12 @@ static McxStatus ChannelInSetup(ChannelIn * in, ChannelInfo * info) {
         ChannelValueSet(&channel->value, info->defaultValue);
 
         // apply range and linear conversions immediately
-        retVal = ConvertRange(info->min, info->max, &channel->value);
+        retVal = ConvertRange(info->min, info->max, &channel->value, NULL);
         if (retVal == RETURN_ERROR) {
             return RETURN_ERROR;
         }
 
-        retVal = ConvertLinear(info->scale, info->offset, &channel->value);
+        retVal = ConvertLinear(info->scale, info->offset, &channel->value, NULL);
         if (retVal == RETURN_ERROR) {
             return RETURN_ERROR;
         }
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 9984d9f..083de27 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -208,6 +208,26 @@ ChannelType * ChannelValueRefGetType(ChannelValueRef * ref) {
 }
 
 
+ChannelValueRef * MakeChannelValueRef(ChannelValue * val, ChannelDimension * slice) {
+    ChannelValueRef * ref = (ChannelValueRef *)object_create(ChannelValueRef);
+    if (!ref) {
+        return NULL;
+    }
+
+    if (slice) {
+        ref->type = CHANNEL_VALUE_REF_SLICE;
+        ref->ref.slice = (ArraySlice *) mcx_calloc(1, sizeof(ArraySlice));
+        ref->ref.slice->dimension = slice;
+        ref->ref.slice->ref = val;
+    } else {
+        ref->type = CHANNEL_VALUE_REF_VALUE;
+        ref->ref.value = val;
+    }
+
+    return ref;
+}
+
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index 87e5ba4..bf18bdc 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -52,6 +52,8 @@ ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
 typedef McxStatus (*fChannelValueRefElemMapFunc)(void * element, size_t idx, ChannelType * type, void * ctx);
 McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapFunc fn, void * ctx);
 
+ChannelValueRef * MakeChannelValueRef(ChannelValue * val, ChannelDimension * slice);
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */

From 1060769281c91963e5870984296efcaf47c47b16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 24 May 2022 07:33:54 +0200
Subject: [PATCH 118/166] Check for duplicate ports and read specific data

---
 src/core/Databus.c | 42 +++++++++++++++++++++++++++++++++++++++---
 1 file changed, 39 insertions(+), 3 deletions(-)

diff --git a/src/core/Databus.c b/src/core/Databus.c
index 85da1a2..1a8b152 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -303,6 +303,13 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
 
     Vector * dbInfos = dbInfo->data->infos;
     size_t requiredSize = 0;
+    StringContainer * portNames = StringContainerCreate(numChildren);
+
+    if (!portNames) {
+        mcx_log(LOG_ERROR, "Ports: Port name container allocation failed");
+        retVal = RETURN_ERROR;
+        goto cleanup;
+    }
 
     for (i = 0; i < numChildren; i++) {
         PortInput * portInput = (PortInput *) input->ports->At(input->ports, i);
@@ -315,7 +322,8 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
         ChannelInfo * info = DatabusReadPortInput(portInput);
         if (!info) {
             mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read info of port %d", i);
-            return RETURN_ERROR;
+            retVal = RETURN_ERROR;
+            goto cleanup;
         }
 
         info->mode = mode;
@@ -327,13 +335,41 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
             mcx_log(LOG_DEBUG, "    Port: \"%s\"", name);
         }
 
+        {
+            // check for duplicates
+            int n = StringContainerGetIndex(portNames, name);
+            if (n >= 0) {  // key already exists
+                mcx_log(LOG_ERROR, "Ports: Duplicate port %s", name);
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            }
+        }
+
+        if (SpecificRead) {
+            retVal = SpecificRead(comp, info, portInput, i);
+            if (RETURN_ERROR == retVal) {
+                mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read element specific data of port %d", i);
+                goto cleanup;
+            }
+        }
+
         if (RETURN_OK != dbInfos->PushBack(dbInfos, info)) {
             mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %d", i);
-            return RETURN_ERROR;
+            retVal = RETURN_ERROR;
+            goto cleanup;
+        }
+
+        retVal = StringContainerAddString(portNames, name);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "Ports: Storing port name failed");
+            goto cleanup;
         }
     }
 
-    return RETURN_OK;
+cleanup:
+    StringContainerDestroy(portNames);
+
+    return retVal;
 }
 
 static int IsWriteResults(void * elem, void * ignore) {

From 0d13275997651be80e14b6c6a97b76aa1afbc136 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 24 May 2022 07:34:12 +0200
Subject: [PATCH 119/166] Apply conversions only if necessary

---
 src/core/channels/Channel.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index bc673d1..3eba157 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -301,10 +301,9 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
 
 
     // Conversions
-    {
+    if (numConns > 0) {
         ChannelValue * val =  &channel->value;
 
-
         // linear
         if (in->data->linearConversion) {
             Conversion * conversion = (Conversion *) in->data->linearConversion;

From 9f262cb5db9b94ed45a7549ad495bb99f84ff611 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 24 May 2022 07:34:36 +0200
Subject: [PATCH 120/166] Use the correct reference

---
 src/core/connections/Connection.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index ec6f4e9..c41a6e7 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1233,7 +1233,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             goto cleanup;
         }
 
-        ChannelValueRefSetFromReference(storeRef, outInfo->initialValue, targetDim, NULL);
+        ChannelValueRefSetFromReference(storeRef, ChannelValueReference(outInfo->initialValue), targetDim, NULL);
         connection->useInitialValue_ = TRUE;
     } else {
         {

From bf420c94e89d614d49a9b93e9e3e02fb369357ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 24 May 2022 07:35:19 +0200
Subject: [PATCH 121/166] Use function instead of member function

---
 src/core/connections/Connection.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index c41a6e7..602036f 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1242,7 +1242,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             mcx_free(buffer);
         }
 
-        ChannelType * storeType = ChannelTypeFromDimension(info->connType_, info->sourceDimension);
+        ChannelType * storeType = ChannelTypeFromDimension(ConnectionInfoGetType(info), info->sourceDimension);
         if (!storeType) {
             mcx_log(LOG_ERROR, "Creating type from the dimension failed");
             retVal = RETURN_ERROR;

From f484a2eaf84eaa24948bd0013299d51b2b3b79b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 24 May 2022 07:36:14 +0200
Subject: [PATCH 122/166] Fix target/source channel reading during
 ConnectionInfo construction

---
 src/core/connections/ConnectionInfoFactory.c | 60 ++++++++++----------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index 32079b9..1fea098 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -138,6 +138,23 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             info->sourceDimension = sourceDimension;
         }
 
+        info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
+        if (info->sourceChannel < 0) {
+            // the connection might be inverted, see SSP 1.0 specification (section 5.3.2.1, page 47)
+
+            databusInfo = DatabusGetInInfo(databus);
+            info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
+
+            if (info->sourceChannel < 0) {
+                mcx_log(LOG_ERROR, "Connection: Source port %s of element %s does not exist",
+                    strFromChannel, info->sourceComponent->GetName(info->sourceComponent));
+                retVal = RETURN_ERROR;
+                goto cleanup;
+            } else {
+                connectionInverted = 1;
+            }
+        }
+
         // check that the source endpoint "fits" into the channel
         sourceInfo = DatabusInfoGetChannel(databusInfo, info->sourceChannel);
         if (!ChannelDimensionIncludedIn(info->sourceDimension, sourceInfo->dimension)) {
@@ -160,23 +177,6 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
 
             goto cleanup;
         }
-
-        info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
-        if (info->sourceChannel < 0) {
-            // the connection might be inverted, see SSP 1.0 specification (section 5.3.2.1, page 47)
-
-            databusInfo = DatabusGetInInfo(databus);
-            info->sourceChannel = DatabusInfoGetChannelID(databusInfo, strFromChannel);
-
-            if (info->sourceChannel < 0) {
-                mcx_log(LOG_ERROR, "Connection: Source port %s of element %s does not exist",
-                    strFromChannel, info->sourceComponent->GetName(info->sourceComponent));
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            } else {
-                connectionInverted = 1;
-            }
-        }
     }
 
     // target channel
@@ -226,6 +226,19 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             info->targetDimension = targetDimension;
         }
 
+        info->targetChannel = DatabusInfoGetChannelID(databusInfo, strToChannel);
+        if (info->targetChannel < 0) {
+            if (0 == connectionInverted) {
+                mcx_log(LOG_ERROR, "Connection: Target port %s of element %s does not exist",
+                    strToChannel, info->targetComponent->GetName(info->targetComponent));
+            } else {
+                mcx_log(LOG_ERROR, "Connection: Source port %s of element %s does not exist",
+                    strToChannel, info->targetComponent->GetName(info->targetComponent));
+            }
+            retVal = RETURN_ERROR;
+            goto cleanup;
+        }
+
         // check that the target endpoint "fits" into the channel
         targetInfo = DatabusInfoGetChannel(databusInfo, info->targetChannel);
         if (!ChannelDimensionIncludedIn(info->targetDimension, targetInfo->dimension)) {
@@ -248,19 +261,6 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
 
             goto cleanup;
         }
-
-        info->targetChannel = DatabusInfoGetChannelID(databusInfo, strToChannel);
-        if (info->targetChannel < 0) {
-            if (0 == connectionInverted) {
-                mcx_log(LOG_ERROR, "Connection: Target port %s of element %s does not exist",
-                    strToChannel, info->targetComponent->GetName(info->targetComponent));
-            } else {
-                mcx_log(LOG_ERROR, "Connection: Source port %s of element %s does not exist",
-                    strToChannel, info->targetComponent->GetName(info->targetComponent));
-            }
-            retVal = RETURN_ERROR;
-            goto cleanup;
-        }
     }
 
     // swap endpoints if connection is inverted

From a89fc6a0a939a2728f6c37f3f545b774cae82106 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 23 May 2022 17:00:20 +0200
Subject: [PATCH 123/166] Expose the whole source value (not just a slice) in
 direct connections

---
 src/core/connections/Connection.c | 37 +++++++++++++++++++++----------
 src/core/connections/Connection.h |  3 +++
 2 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 602036f..fa57c79 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1269,6 +1269,28 @@ static void ConnectionInitUpdateFrom(Connection * connection, TimeInterval * tim
     // Do nothing
 }
 
+static McxStatus ConnectionInitSetToStore(Connection * connection) {
+    Channel* channel = (Channel*)connection->out_;
+    ChannelInfo* info = &channel->info;
+    ChannelValueRef * storeRef = (ChannelValueRef *) object_create(ChannelValueRef);
+
+    if (!storeRef) {
+        mcx_log(LOG_ERROR, "Could not create store reference for initial connection");
+        return RETURN_ERROR;
+    }
+    storeRef->type = CHANNEL_VALUE_REF_VALUE;
+    storeRef->ref.value = &connection->store_;
+
+    ConnectionInfo * connInfo = connection->GetInfo(connection);
+    ChannelDimension * clone = ChannelDimensionClone(connInfo->sourceDimension);
+    ChannelDimensionNormalize(clone, info->dimension);
+    if (RETURN_OK != ChannelValueRefSetFromReference(storeRef, channel->GetValueReference(channel), clone, NULL)) {
+        return RETURN_ERROR;
+    }
+
+    return RETURN_OK;
+}
+
 static McxStatus ConnectionInitUpdateTo(Connection * connection, TimeInterval * time) {
     Channel * channel = (Channel *) connection->out_;
     ChannelInfo * info = &channel->info;
@@ -1281,18 +1303,7 @@ static McxStatus ConnectionInitUpdateTo(Connection * connection, TimeInterval *
 #endif
 
     if (!connection->useInitialValue_) {
-        ChannelValueRef * storeRef = (ChannelValueRef *) object_create(ChannelValueRef);
-        if (!storeRef) {
-            mcx_log(LOG_ERROR, "Could not create store reference for initial connection");
-            return RETURN_ERROR;
-        }
-        storeRef->type = CHANNEL_VALUE_REF_VALUE;
-        storeRef->ref.value = &connection->store_;
-
-        ConnectionInfo * connInfo = connection->GetInfo(connection);
-        ChannelDimension * clone = ChannelDimensionClone(connInfo->sourceDimension);
-        ChannelDimensionNormalize(clone, info->dimension);
-        if (RETURN_OK != ChannelValueRefSetFromReference(storeRef, channel->GetValueReference(channel), clone, NULL)) {
+        if (RETURN_OK != connection->InitSetToStore(connection)) {
             return RETURN_ERROR;
         }
         if (channel->IsDefinedDuringInit(channel)) {
@@ -1482,6 +1493,8 @@ static Connection * ConnectionCreate(Connection * connection) {
     connection->NormalUpdateTo_ = NULL;
     connection->normalValue_ = NULL;
 
+    connection->InitSetToStore = ConnectionInitSetToStore;
+
     return connection;
 }
 
diff --git a/src/core/connections/Connection.h b/src/core/connections/Connection.h
index ed2222b..bd07776 100644
--- a/src/core/connections/Connection.h
+++ b/src/core/connections/Connection.h
@@ -67,6 +67,7 @@ typedef void (* fConnectionUpdateFromInput)(Connection * connection, TimeInterva
 typedef McxStatus (* fConnectionUpdateToOutput)(Connection * connection, TimeInterval * time);
 
 typedef McxStatus (* fConnectionUpdateInitialValue)(Connection * connection);
+typedef McxStatus (* fConnectionInitSetToStore)(Connection * connection);
 
 typedef McxStatus (* fConnectionEnterInitializationMode)(Connection * connection);
 typedef McxStatus (* fConnectionExitInitializationMode)(Connection * connection, double time);
@@ -138,6 +139,8 @@ struct Connection {
 
     fConnectionGetValueType GetValueType;
 
+    fConnectionInitSetToStore InitSetToStore;
+
     /**
      * Set the reference to the value of the connection. This value will be
      * updated on each call to UpdateToOutput().

From 11126616adb073693b48fe5652b30f833f92e4b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 27 May 2022 11:46:15 +0200
Subject: [PATCH 124/166] Disable support for co-sim init with vector ports

---
 src/core/Model.c | 36 ++++++++++++++++++++++++++++++++++++
 src/core/Model.h |  2 ++
 2 files changed, 38 insertions(+)

diff --git a/src/core/Model.c b/src/core/Model.c
index 4d9b1b2..b675846 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -540,6 +540,35 @@ static McxStatus ModelSignalConnectionsDone(ObjectContainer * comps) {
     return RETURN_OK;
 }
 
+int ComponentsHaveVectorChannels(ObjectContainer * components) {
+    size_t numComps = components->Size(components);
+    size_t i = 0;
+
+    for (i = 0; i < numComps; i++) {
+        Component * comp = (Component *) components->At(components, i);
+        Databus * db = comp->GetDatabus(comp);
+        size_t numIns = DatabusGetInChannelsNum(db);
+        size_t numOuts = DatabusGetOutChannelsNum(db);
+        size_t j = 0;
+
+        for (j = 0; j < numIns; j++) {
+            ChannelInfo * info = DatabusGetInChannelInfo(db, j);
+            if (ChannelTypeIsArray(info->type)) {
+                return TRUE;
+            }
+        }
+
+        for (j = 0; j < numOuts; j++) {
+            ChannelInfo* info = DatabusGetOutChannelInfo(db, j);
+            if (ChannelTypeIsArray(info->type)) {
+                return TRUE;
+            }
+        }
+    }
+
+    return FALSE;
+}
+
 static McxStatus ModelConnectionsDone(Model * model) {
     OrderedNodes * orderedNodes = NULL;
     McxStatus retVal = RETURN_OK;
@@ -564,6 +593,13 @@ static McxStatus ModelConnectionsDone(Model * model) {
 
     // determine initialization evaluation order
     if (model->config->cosimInitEnabled) {
+        // separate triggering of array elements is not supported at the moment
+        // therefore some models with array ports might not work
+        if (ComponentsHaveVectorChannels(model->components)) {
+            mcx_log(LOG_ERROR, "Co-Simulation initialization: Components with vector ports are not supported");
+            return RETURN_ERROR;
+        }
+
         retVal = ModelCreateInitSubModel(model);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "Model: InitSubModel could not be created");
diff --git a/src/core/Model.h b/src/core/Model.h
index 5465ad7..a0fefb5 100644
--- a/src/core/Model.h
+++ b/src/core/Model.h
@@ -97,6 +97,8 @@ McxStatus ModelConnectionsEnterInitMode(ObjectContainer * comps);
 McxStatus ModelConnectionsExitInitMode(ObjectContainer * comps, double time);
 McxStatus ModelDoConnectionsInitialization(ObjectContainer * comps, int onlyIfDecoupled);
 
+int ComponentsHaveVectorChannels(ObjectContainer * components);
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */

From 10b689362d076fa5ebc6a95ca6fe3e794ccf0c16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 27 May 2022 17:16:51 +0200
Subject: [PATCH 125/166] ChannelDimension cleanup

---
 src/core/Conversion.c                        | 12 ++--
 src/core/Databus.c                           |  2 +-
 src/core/Model.c                             |  8 +--
 src/core/channels/Channel.c                  |  4 +-
 src/core/channels/ChannelDimension.c         | 74 +++++++-------------
 src/core/channels/ChannelDimension.h         | 38 +++++-----
 src/core/channels/ChannelInfo.c              |  2 +-
 src/core/channels/ChannelValue.c             |  6 +-
 src/core/connections/Connection.c            | 12 ++--
 src/core/connections/ConnectionInfoFactory.c | 38 ++--------
 10 files changed, 77 insertions(+), 119 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index f601665..96de63c 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -900,15 +900,15 @@ static McxStatus ArraysValidForConversion(ChannelValueRef * dest,
     // check dimensions match
     if (srcDimension) {
         if (dest->type == CHANNEL_VALUE_REF_VALUE) {
-            return ChannelDimensionsConform(srcDimension, dest->ref.value->type->ty.a.dims, dest->ref.value->type->ty.a.numDims) ? RETURN_OK : RETURN_ERROR;
+            return ChannelDimensionConformsTo(srcDimension, dest->ref.value->type->ty.a.dims, dest->ref.value->type->ty.a.numDims) ? RETURN_OK : RETURN_ERROR;
         } else {
-            return ChannelDimensionConformable(dest->ref.slice->dimension, srcDimension) ? RETURN_OK : RETURN_ERROR;
+            return ChannelDimensionConformsToDimension(dest->ref.slice->dimension, srcDimension) ? RETURN_OK : RETURN_ERROR;
         }
     } else {
         if (dest->type == CHANNEL_VALUE_REF_VALUE) {
             return mcx_array_dims_match(&dest->ref.value->value.a, src) ? RETURN_OK : RETURN_ERROR;
         } else {
-            return ChannelDimensionsConform(dest->ref.slice->dimension, src->dims, src->numDims) ? RETURN_OK : RETURN_ERROR;
+            return ChannelDimensionConformsTo(dest->ref.slice->dimension, src->dims, src->numDims) ? RETURN_OK : RETURN_ERROR;
         }
     }
 
@@ -1404,9 +1404,9 @@ static McxStatus TypeConversionConvertId(TypeConversion * conversion, ChannelVal
 static int DimensionsMatch(ChannelType * fromType, ChannelDimension * fromDimension, ChannelType * toType, ChannelDimension * toDimension) {
     if (fromDimension) {
         if (!toDimension) {
-            return ChannelDimensionsConform(fromDimension, toType->ty.a.dims, toType->ty.a.numDims);
+            return ChannelDimensionConformsTo(fromDimension, toType->ty.a.dims, toType->ty.a.numDims);
         } else {
-            return ChannelDimensionConformable(toDimension, fromDimension);
+            return ChannelDimensionConformsToDimension(toDimension, fromDimension);
         }
     } else {
         if (!toDimension) {
@@ -1423,7 +1423,7 @@ static int DimensionsMatch(ChannelType * fromType, ChannelDimension * fromDimens
 
             return 1;
         } else {
-            return ChannelDimensionsConform(toDimension, fromType->ty.a.dims, fromType->ty.a.numDims);
+            return ChannelDimensionConformsTo(toDimension, fromType->ty.a.dims, fromType->ty.a.numDims);
         }
     }
 }
diff --git a/src/core/Databus.c b/src/core/Databus.c
index 1a8b152..e2c5e92 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -83,7 +83,7 @@ static ChannelInfo * DatabusReadPortInput(PortInput * input) {
             goto vector_cleanup_0;
         }
 
-        info->dimension = (ChannelDimension *) object_create(ChannelDimension);
+        info->dimension = MakeChannelDimension();
         if (!info->dimension) {
             retVal = RETURN_ERROR;
             goto vector_cleanup_0;
diff --git a/src/core/Model.c b/src/core/Model.c
index b675846..1969b0d 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -212,25 +212,25 @@ static McxStatus ModelPreprocessConstConnections(Model * model) {
         }
 
         // prepare slice dimensions
-        srcDim = ChannelDimensionClone(info->sourceDimension);
+        srcDim = CloneChannelDimension(info->sourceDimension);
         if (info->sourceDimension && !srcDim) {
             mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Source dimension slice allocation failed");
             goto cleanup_1;
         }
 
-        retVal = ChannelDimensionNormalize(srcDim, srcChannelInfo->dimension);
+        retVal = ChannelDimensionAlignIndicesWithZero(srcDim, srcChannelInfo->dimension);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Source dimension normalization failed");
             goto cleanup_1;
         }
 
-        trgDim = ChannelDimensionClone(info->targetDimension);
+        trgDim = CloneChannelDimension(info->targetDimension);
         if (info->targetDimension && !trgDim) {
             mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Target dimension slice allocation failed");
             goto cleanup_1;
         }
 
-        retVal = ChannelDimensionNormalize(trgDim, trgChannelInfo->dimension);
+        retVal = ChannelDimensionAlignIndicesWithZero(trgDim, trgChannelInfo->dimension);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "ModelPreprocessConstConnections: Target dimension normalization failed");
             goto cleanup_1;
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 3eba157..e720d98 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -426,8 +426,8 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         valRef->type = CHANNEL_VALUE_REF_SLICE;
         valRef->ref.slice = (ArraySlice *) mcx_calloc(1, sizeof(ArraySlice));
         valRef->ref.slice->ref = &channel->value;
-        valRef->ref.slice->dimension = ChannelDimensionClone(dimension);
-        retVal = ChannelDimensionNormalize(valRef->ref.slice->dimension, inInfo->dimension);
+        valRef->ref.slice->dimension = CloneChannelDimension(dimension);
+        retVal = ChannelDimensionAlignIndicesWithZero(valRef->ref.slice->dimension, inInfo->dimension);
         if (retVal == RETURN_ERROR) {
             ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Normalizing array slice dimension failed");
             return RETURN_ERROR;
diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index 8064fd2..f86c675 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -9,27 +9,15 @@
  ********************************************************************************/
 
 #include "core/channels/ChannelDimension.h"
+
 #include "util/stdlib.h"
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
 
-void ChannelDimensionDestructor(ChannelDimension * dimension) {
-    if (dimension->startIdxs) { mcx_free(dimension->startIdxs); }
-    if (dimension->endIdxs) { mcx_free(dimension->endIdxs); }
-}
-
-ChannelDimension * ChannelDimensionCreate(ChannelDimension * dimension) {
-    dimension->num = 0;
-    dimension->startIdxs = NULL;
-    dimension->endIdxs = NULL;
-
-    return dimension;
-}
-
-OBJECT_CLASS(ChannelDimension, Object);
 
 McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num) {
     dimension->num = num;
@@ -63,8 +51,9 @@ McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num,
     return RETURN_OK;
 }
 
-size_t ChannelDimensionNumElements(ChannelDimension * dimension) {
-    size_t i = 0, n = 1;
+size_t ChannelDimensionNumElements(const ChannelDimension * dimension) {
+    size_t i = 0;
+    size_t n = 1;
 
     if (dimension->num == 0) {
         return 0;
@@ -77,7 +66,7 @@ size_t ChannelDimensionNumElements(ChannelDimension * dimension) {
     return n;
 }
 
-ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension) {
+ChannelDimension * CloneChannelDimension(const ChannelDimension * dimension) {
     ChannelDimension * clone = NULL;
     McxStatus retVal = RETURN_OK;
     size_t i = 0;
@@ -86,22 +75,22 @@ ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension) {
         return NULL;
     }
 
-    clone = (ChannelDimension *) object_create(ChannelDimension);
+    clone = MakeChannelDimension();
     if (!clone) {
-        mcx_log(LOG_ERROR, "ChannelDimensionClone: Not enough memory");
+        mcx_log(LOG_ERROR, "CloneChannelDimension: Not enough memory");
         return NULL;
     }
 
     retVal = ChannelDimensionSetup(clone, dimension->num);
     if (RETURN_ERROR == retVal) {
-        mcx_log(LOG_ERROR, "Channel dimension setup failed");
+        mcx_log(LOG_ERROR, "CloneChannelDimension: Channel dimension setup failed");
         goto cleanup;
     }
 
     for (i = 0; i < dimension->num; i++) {
         retVal = ChannelDimensionSetDimension(clone, i, dimension->startIdxs[i], dimension->endIdxs[i]);
         if (RETURN_ERROR == retVal) {
-            mcx_log(LOG_ERROR, "Channel dimension %zu set failed", i);
+            mcx_log(LOG_ERROR, "CloneChannelDimension: Channel dimension %zu set failed", i);
             goto cleanup;
         }
     }
@@ -113,7 +102,7 @@ ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension) {
     return NULL;
 }
 
-int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second) {
+int ChannelDimensionEq(const ChannelDimension * first, const ChannelDimension * second) {
     size_t i = 0;
 
     if (!first && !second) {
@@ -135,7 +124,7 @@ int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second) {
     return TRUE;
 }
 
-int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * second) {
+int ChannelDimensionConformsToDimension(const ChannelDimension * first, const ChannelDimension * second) {
     size_t i = 0;
 
     if (!first && !second) {
@@ -157,7 +146,7 @@ int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * sec
     return TRUE;
 }
 
-int ChannelDimensionsConform(ChannelDimension * dimension, size_t * dims, size_t numDims) {
+int ChannelDimensionConformsTo(const ChannelDimension * dimension, const size_t * dims, size_t numDims) {
     size_t i = 0;
     if (dimension->num != numDims) {
         return 0;
@@ -172,7 +161,7 @@ int ChannelDimensionsConform(ChannelDimension * dimension, size_t * dims, size_t
     return 1;
 }
 
-int ChannelDimensionIncludedIn(const ChannelDimension* first, const ChannelDimension* second) {
+int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second) {
     size_t i = 0;
 
     if (!first && !second) {
@@ -198,7 +187,7 @@ int ChannelDimensionIncludedIn(const ChannelDimension* first, const ChannelDimen
     return TRUE;
 }
 
-size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, size_t * sizes) {
+size_t ChannelDimensionGetIndex(const ChannelDimension * dimension, size_t elem_idx, const size_t * sizes) {
     switch (dimension->num) {
         case 1:
             {
@@ -232,7 +221,7 @@ size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, s
     return (size_t) -1;
 }
 
-size_t ChannelDimensionGetSliceIndex(ChannelDimension * dimension, size_t slice_idx, size_t * dims) {
+size_t ChannelDimensionGetSliceIndex(const ChannelDimension * dimension, size_t slice_idx, const size_t * dims) {
     switch (dimension->num) {
         case 1:
             {
@@ -304,7 +293,7 @@ char * ChannelDimensionString(const ChannelDimension * dimension) {
     return str;
 }
 
-McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension * base) {
+McxStatus ChannelDimensionAlignIndicesWithZero(ChannelDimension * target, const ChannelDimension * base) {
     size_t i = 0;
     if (!target && !base) {
         return RETURN_OK;
@@ -324,32 +313,21 @@ McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension
     return RETURN_OK;
 }
 
-ChannelType * ChannelDimensionToChannelType(ChannelDimension * dimension, ChannelType * sourceType) {
-    if (dimension) {
-        // source data is an array
-        size_t i = 0;
-        ChannelType * type = NULL;
-        size_t * dims = (size_t *) mcx_calloc(sizeof(size_t), dimension->num);
+ChannelDimension * MakeChannelDimension() {
+    ChannelDimension * dimension = (ChannelDimension *) mcx_calloc(1, sizeof(ChannelDimension));
 
-        if (!dims) {
-            mcx_log(LOG_ERROR, "ChannelDimensionToChannelType: Not enough memory for dimension calculation");
-            return NULL;
-        }
+    return dimension;
+}
 
-        for (i = 0; i < dimension->num; i++) {
-            dims[i] = dimension->endIdxs[i] - dimension->startIdxs[i] + 1;    // indices are inclusive
-        }
+void DestroyChannelDimension(ChannelDimension ** dimension) {
+    if ((*dimension)->startIdxs) { mcx_free((*dimension)->startIdxs); }
+    if ((*dimension)->endIdxs) { mcx_free((*dimension)->endIdxs); }
 
-        type = ChannelTypeArray(ChannelTypeClone(ChannelTypeBaseType(sourceType)), dimension->num, dims);
-        mcx_free(dims);
-        return type;
-    } else {
-        // source data is a scalar
-        return ChannelTypeClone(sourceType);
-    }
+    *dimension = NULL;
 }
 
 
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 9f9da44..0fdbf0d 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -8,43 +8,49 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 
-#ifndef MCX_CORE_CHANNELS_CHANNELDIMENSION_H
-#define MCX_CORE_CHANNELS_CHANNELDIMENSION_H
+#ifndef MCX_CORE_CHANNELS_CHANNEL_DIMENSION_H
+#define MCX_CORE_CHANNELS_CHANNEL_DIMENSION_H
 
 #include "CentralParts.h"
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
-extern const struct ObjectClass _ChannelDimension;
 
-typedef struct ChannelDimension {
-    Object _; // super class first
 
+typedef struct ChannelDimension {
     size_t num;
+
     size_t * startIdxs;
     size_t * endIdxs;
 } ChannelDimension;
 
 
+ChannelDimension * MakeChannelDimension();
+ChannelDimension * CloneChannelDimension(const ChannelDimension * dimension);
+void DestroyChannelDimension(ChannelDimension ** dimension);
+
 McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num);
 McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end);
-ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
-size_t ChannelDimensionNumElements(ChannelDimension * dimension);
-ChannelDimension * ChannelDimensionClone(ChannelDimension * dimension);
-int ChannelDimensionEq(ChannelDimension * first, ChannelDimension * second);
-int ChannelDimensionConformable(ChannelDimension * first, ChannelDimension * second);
-int ChannelDimensionsConform(ChannelDimension * dimension, size_t * dims, size_t numDims);
+
+int ChannelDimensionEq(const ChannelDimension * first, const ChannelDimension * second);
+int ChannelDimensionConformsToDimension(const ChannelDimension * first, const ChannelDimension * second);
+int ChannelDimensionConformsTo(const ChannelDimension * dimension, const size_t * dims, size_t numDims);
 int ChannelDimensionIncludedIn(const ChannelDimension * first, const ChannelDimension * second);
-size_t ChannelDimensionGetIndex(ChannelDimension * dimension, size_t elem_idx, size_t * sizes);
-size_t ChannelDimensionGetSliceIndex(ChannelDimension * dimension, size_t slice_idx, size_t * dims);
+
+size_t ChannelDimensionNumElements(const ChannelDimension* dimension);
 char * ChannelDimensionString(const ChannelDimension * dimension);
-McxStatus ChannelDimensionNormalize(ChannelDimension * target, ChannelDimension * base);
-ChannelType * ChannelDimensionToChannelType(ChannelDimension * dimension, ChannelType * sourceType);
+size_t ChannelDimensionGetIndex(const ChannelDimension * dimension, size_t elem_idx, const size_t * sizes);
+size_t ChannelDimensionGetSliceIndex(const ChannelDimension * dimension, size_t slice_idx, const size_t * dims);
+
+McxStatus ChannelDimensionAlignIndicesWithZero(ChannelDimension * target, const ChannelDimension * base);
+
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
 
-#endif // MCX_CORE_CHANNELS_CHANNELDIMENSION_H
\ No newline at end of file
+#endif // MCX_CORE_CHANNELS_CHANNEL_DIMENSION_H
\ No newline at end of file
diff --git a/src/core/channels/ChannelInfo.c b/src/core/channels/ChannelInfo.c
index b88b83c..ff93130 100644
--- a/src/core/channels/ChannelInfo.c
+++ b/src/core/channels/ChannelInfo.c
@@ -233,7 +233,7 @@ McxStatus ChannelInfoSetFrom(ChannelInfo * info, const ChannelInfo * other) {
 
     object_destroy(info->dimension);
     if (other->dimension) {
-        info->dimension = ChannelDimensionClone(other->dimension);
+        info->dimension = CloneChannelDimension(other->dimension);
         if (!info->dimension) {
             mcx_log(LOG_ERROR, "ChannelInfoSetFrom: Failed to set dimension");
             return RETURN_ERROR;
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 218059a..79be3d3 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -167,11 +167,11 @@ size_t ChannelTypeNumElements(const ChannelType * type) {
 int ChannelTypeConformable(ChannelType * a, ChannelDimension * sliceA, ChannelType * b, ChannelDimension * sliceB) {
     if (a->con == CHANNEL_ARRAY && b->con == CHANNEL_ARRAY) {
         if (sliceA && sliceB) {
-            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionConformable(sliceA, sliceB);
+            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionConformsToDimension(sliceA, sliceB);
         } else if (sliceA && !sliceB) {
-            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionsConform(sliceA, b->ty.a.dims, b->ty.a.numDims);
+            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionConformsTo(sliceA, b->ty.a.dims, b->ty.a.numDims);
         } else if (!sliceA && sliceB) {
-            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionsConform(sliceB, a->ty.a.dims, a->ty.a.numDims);
+            return a->ty.a.inner == b->ty.a.inner && ChannelDimensionConformsTo(sliceB, a->ty.a.dims, a->ty.a.numDims);
         } else {
             return ChannelTypeEq(a, b);
         }
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index fa57c79..8ffbe90 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1177,13 +1177,13 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
         ChannelValue * inChannelValue = inInfo->initialValue;
         ChannelDimension * srcDim = NULL;
 
-        srcDim = ChannelDimensionClone(info->targetDimension);
+        srcDim = CloneChannelDimension(info->targetDimension);
         if (srcDim) {
             mcx_log(LOG_ERROR, "Could not clone source dimension");
             retVal = RETURN_ERROR;
             goto cleanup_1;
         }
-        retVal = ChannelDimensionNormalize(srcDim, inInfo->dimension);
+        retVal = ChannelDimensionAlignIndicesWithZero(srcDim, inInfo->dimension);
         if (retVal == RETURN_ERROR) {
             mcx_log(LOG_ERROR, "Dimension normalization failed");
             goto cleanup_1;
@@ -1219,14 +1219,14 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             goto cleanup;
         }
     } else if (outInfo->initialValue) {
-        ChannelDimension * targetDim = ChannelDimensionClone(info->sourceDimension);
+        ChannelDimension * targetDim = CloneChannelDimension(info->sourceDimension);
         if (targetDim) {
             mcx_log(LOG_ERROR, "Could not clone target dimension");
             retVal = RETURN_ERROR;
             goto cleanup;
         }
 
-        retVal = ChannelDimensionNormalize(targetDim, outInfo->dimension);
+        retVal = ChannelDimensionAlignIndicesWithZero(targetDim, outInfo->dimension);
         if (retVal == RETURN_ERROR) {
             mcx_log(LOG_ERROR, "Dimension normalization failed");
             object_destroy(targetDim);
@@ -1282,8 +1282,8 @@ static McxStatus ConnectionInitSetToStore(Connection * connection) {
     storeRef->ref.value = &connection->store_;
 
     ConnectionInfo * connInfo = connection->GetInfo(connection);
-    ChannelDimension * clone = ChannelDimensionClone(connInfo->sourceDimension);
-    ChannelDimensionNormalize(clone, info->dimension);
+    ChannelDimension * clone = CloneChannelDimension(connInfo->sourceDimension);
+    ChannelDimensionAlignIndicesWithZero(clone, info->dimension);
     if (RETURN_OK != ChannelValueRefSetFromReference(storeRef, channel->GetValueReference(channel), clone, NULL)) {
         return RETURN_ERROR;
     }
diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index 1fea098..1e73034 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -117,7 +117,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
 
         // arrays/multiplexing: source slice dimensions
         if (connInput->fromType == ENDPOINT_VECTOR) {
-            ChannelDimension* sourceDimension = (ChannelDimension*)object_create(ChannelDimension);
+            ChannelDimension * sourceDimension = MakeChannelDimension();
             if (!sourceDimension) {
                 retVal = RETURN_ERROR;
                 goto cleanup;
@@ -126,12 +126,14 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             if (RETURN_OK != ChannelDimensionSetup(sourceDimension, 1)) {
                 mcx_log(LOG_ERROR, "Source port %s: Could not set number of dimensions", strFromChannel);
                 retVal = RETURN_ERROR;
+                DestroyChannelDimension(&sourceDimension);
                 goto cleanup;
             }
 
             if (RETURN_OK != ChannelDimensionSetDimension(sourceDimension, 0, connInput->from.vectorEndpoint->startIndex, connInput->from.vectorEndpoint->endIndex)) {
                 mcx_log(LOG_ERROR, "Source port %s: Could not set dimension boundaries", strFromChannel);
                 retVal = RETURN_ERROR;
+                DestroyChannelDimension(&sourceDimension);
                 goto cleanup;
             }
 
@@ -201,7 +203,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
 
         // arrays/multiplexing: target slice dimensions
         if (connInput->toType == ENDPOINT_VECTOR) {
-            ChannelDimension * targetDimension = (ChannelDimension *) object_create(ChannelDimension);
+            ChannelDimension * targetDimension = MakeChannelDimension();
             if (!targetDimension) {
                 retVal = RETURN_ERROR;
                 goto cleanup;
@@ -210,6 +212,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             if (RETURN_OK != ChannelDimensionSetup(targetDimension, 1)) {
                 mcx_log(LOG_ERROR, "Target port %s: Could not set number of dimensions", strToChannel);
                 retVal = RETURN_ERROR;
+                DestroyChannelDimension(&targetDimension);
                 goto cleanup;
             }
 
@@ -220,6 +223,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             {
                 mcx_log(LOG_ERROR, "Target port %s: Could not set dimension boundaries", strToChannel);
                 retVal = RETURN_ERROR;
+                DestroyChannelDimension(&targetDimension);
                 goto cleanup;
             }
 
@@ -282,36 +286,6 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             info->targetComponent->GetName(info->targetComponent), strFromChannel, info->sourceComponent->GetName(info->sourceComponent), strToChannel);
     }
 
-    // source dimension
-    {
-        EndpointInputType endpointType = connectionInverted ? connInput->toType : connInput->fromType;
-
-        if (endpointType == ENDPOINT_VECTOR) {
-            size_t startIndex = (size_t) (connectionInverted ? connInput->to.vectorEndpoint->startIndex : connInput->from.vectorEndpoint->startIndex);
-            size_t endIndex = (size_t)(connectionInverted ? connInput->to.vectorEndpoint->endIndex : connInput->from.vectorEndpoint->endIndex);
-
-            ChannelDimension* sourceDimension = (ChannelDimension*)object_create(ChannelDimension);
-            if (!sourceDimension) {
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            }
-
-            if (RETURN_OK != ChannelDimensionSetup(sourceDimension, 1)) {
-                mcx_log(LOG_ERROR, "Could not setup ChannelDimension");
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            }
-
-            if (RETURN_OK != ChannelDimensionSetDimension(sourceDimension, 0, startIndex, endIndex)) {
-                mcx_log(LOG_ERROR, "Could not SetDimension");
-                retVal = RETURN_ERROR;
-                goto cleanup;
-            }
-
-            info->sourceDimension = sourceDimension;
-        }
-    }
-
     {
         // check that connection endpoint dimensions match
         ChannelDimension * sourceDim = info->sourceDimension;

From 8335ddb83e7df2d741db92793f4af7940aca30f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 31 May 2022 11:14:11 +0200
Subject: [PATCH 126/166] Replace IsValid functions with their channel
 counterparts

Rename ChannelIsValid -> ChannelProvidesValue
Define a IsFullyConnected function for in and out channels
---
 src/components/comp_fmu.c   | 12 ++++--
 src/core/Component.c        | 10 ++---
 src/core/Databus.c          | 77 +----------------------------------
 src/core/Databus.h          | 31 --------------
 src/core/Model.c            | 35 ++++++++--------
 src/core/channels/Channel.c | 81 ++++++++++++++++++++++++++++++++-----
 src/core/channels/Channel.h | 11 ++++-
 7 files changed, 109 insertions(+), 148 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index a0495d0..3292f41 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -50,11 +50,12 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
     numChannels = DatabusInfoGetChannelNum(dbInfo);
     vals = fmu1->in;
     for (i = 0; i < numChannels; i++) {
+        Channel * ch = (Channel *) DatabusGetInChannel(db, i);
         ChannelInfo * info = DatabusInfoGetChannel(dbInfo, i);
         ChannelDimension * dimension = info->dimension;
         ChannelType * type = info->type;
 
-        if (DatabusChannelInIsValid(db, i)) {
+        if (ch->IsConnected(ch) || ch->info.defaultValue) {
             Fmu1Value * val = NULL;
             fmi1_import_variable_t * var = NULL;
 
@@ -375,10 +376,11 @@ static McxStatus Fmu2SetupChannelIn(ObjectContainer /* Fmu2Values */ * vals, Dat
     numChannels = DatabusInfoGetChannelNum(dbInfo);
 
     for (i = 0; i < numChannels; i++) {
+        Channel * ch = (Channel *)DatabusGetInChannel(db, i);
         ChannelInfo * info = DatabusInfoGetChannel(dbInfo, i);
         Fmu2Value * val = (Fmu2Value *) vals->At(vals, i);
 
-        if (DatabusChannelInIsValid(db, i)) {
+        if (ch->IsConnected(ch) || ch->info.defaultValue) {
             const char * channelName = info->nameInTool;
             if (NULL == channelName) {
                 channelName = ChannelInfoGetName(info);
@@ -1132,8 +1134,9 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
 
     for (i = 0; i < num_in_vars; ++i) {
         Fmu2Value *val = (Fmu2Value *)in_vars->At(in_vars, i);
+        Channel * ch = (Channel *) DatabusGetInChannel(db, i);
         ChannelInfo * info = DatabusInfoGetChannel(db_info, i);
-        if (DatabusChannelInIsValid(db, k) && info->connected) {
+        if (ch->IsConnected(ch)) {
             // key i in the map means channel i is connected
             in_channel_connectivity->Add(in_channel_connectivity, i, 1 /* true */);
         }
@@ -1284,7 +1287,8 @@ static struct Dependencies* Fmu2GetInOutGroupsInitialDependency(const Component
             size_t dummy_num_out = 1;
             dependencies = DependenciesCreate(num_in, dummy_num_out);
             for (j = 0; j < num_in; ++j) {
-                if (DatabusChannelInIsValid(db, j)) {
+                Channel * ch = (Channel *) DatabusGetInChannel(db, j);
+                if (ch->IsConnected(ch) || ch->info.defaultValue) {
                     retVal = SetDependency(dependencies, j, 0, DEP_DEPENDENT);
                     if (RETURN_OK != retVal) {
                         mcx_log(LOG_ERROR, "Initial dependency matrix for %s could not be created", comp->GetName(comp));
diff --git a/src/core/Component.c b/src/core/Component.c
index 93b8193..427e7e5 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -384,7 +384,7 @@ McxStatus ComponentRegisterStorage(Component * comp, ResultsStorage * storage) {
     for (i = 0; i < numInChannels; i++) {
         Channel * channel = (Channel *) DatabusGetInChannel(db, i);
 
-        if (channel->IsValid(channel)) {
+        if (channel->ProvidesValue(channel)) {
             retVal = compStore->RegisterChannel(compStore, CHANNEL_STORE_IN, channel);
             if (RETURN_OK != retVal) {
                 ComponentLog(comp, LOG_ERROR, "Could not register inport %d at storage", i);
@@ -650,7 +650,7 @@ static McxStatus AddObservableChannels(const Component * comp, StringContainer *
     for (i = 0; i < numIn; i++) {
         Channel * channel = (Channel *) DatabusGetInChannel(db, i);
         char * id = channel->info.id;
-        int isValid = DatabusChannelInIsValid(db, i);
+        int isValid = channel->IsConnected(channel) || channel->info.defaultValue;
 
         if (NULL != id && isValid) {
             StringContainerSetKeyValue(container, *count, id, channel);
@@ -661,7 +661,7 @@ static McxStatus AddObservableChannels(const Component * comp, StringContainer *
     for (i = 0; i < numLocal; i++) {
         Channel * channel = (Channel *) DatabusGetLocalChannel(db, i);
         char * id = channel->info.id;
-        int isValid = DatabusChannelLocalIsValid(db, i);
+        int isValid = channel->ProvidesValue(channel);
 
         if (NULL != id && isValid) {
             StringContainerSetKeyValue(container, *count, id, channel);
@@ -672,7 +672,7 @@ static McxStatus AddObservableChannels(const Component * comp, StringContainer *
     for (i = 0; i < numRTFactor; i++) {
         Channel * channel = (Channel *) DatabusGetRTFactorChannel(db, i);
         char * id = channel->info.id;
-        int isValid = DatabusChannelRTFactorIsValid(db, i);
+        int isValid = channel->ProvidesValue(channel);
 
         if (NULL != id && isValid) {
             StringContainerSetKeyValue(container, *count, id, channel);
@@ -690,7 +690,7 @@ static size_t ComponentGetNumConnectedOutChannels(const Component * comp) {
 
     for (i = 0; (int) i < DatabusInfoGetChannelNum(DatabusGetOutInfo(comp->data->databus)); i++) {
         Channel * channel = (Channel *) DatabusGetOutChannel(comp->data->databus, i);
-        if (channel->IsValid(channel)) {
+        if (channel->IsConnected(channel)) {
             count++;
         }
     }
diff --git a/src/core/Databus.c b/src/core/Databus.c
index e2c5e92..e5580c9 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -656,7 +656,7 @@ McxStatus DatabusTriggerInConnections(Databus * db, TimeInterval * consumerTime)
 
     for (i = 0; i < numIn; i++) {
         Channel * channel = (Channel *) db->data->in[i];
-        if (channel->IsValid(channel)) {
+        if (channel->IsConnected(channel) || channel->info.defaultValue) {
             retVal = channel->Update(channel, consumerTime);
             if (RETURN_OK != retVal) {
                 ChannelInfo * info = &channel->info;
@@ -1294,81 +1294,6 @@ ChannelInfo * DatabusGetLocalChannelInfo(Databus * db, size_t channel) {
     return (ChannelInfo *) data->infos->At(data->infos, channel);
 }
 
-int DatabusChannelInIsValid(Databus * db, size_t channel) {
-    Channel * in = NULL;
-
-    if (!db) {
-        return FALSE;
-    }
-
-    in = (Channel *) DatabusGetInChannel(db, channel);
-    if (!in) {
-        return FALSE;
-    }
-
-    return in->IsValid(in);
-}
-
-int DatabusChannelInIsConnected(struct Databus * db, size_t channel) {
-    Channel * in = NULL;
-
-    if (!db) {
-        return FALSE;
-    }
-
-    in = (Channel *) DatabusGetInChannel(db, channel);
-    if (!in) {
-        return FALSE;
-    }
-
-    return in->IsConnected(in);
-}
-
-int DatabusChannelOutIsValid(Databus * db, size_t channel) {
-    Channel * out = NULL;
-
-    if (!db) {
-        return FALSE;
-    }
-
-    out = (Channel *) DatabusGetOutChannel(db, channel);
-    if (!out) {
-        return FALSE;
-    }
-
-    return out->IsValid(out);
-}
-
-int DatabusChannelLocalIsValid(Databus * db, size_t channel) {
-    Channel * local = NULL;
-
-    if (!db) {
-        return FALSE;
-    }
-
-    local = (Channel *) DatabusGetLocalChannel(db, channel);
-    if (!local) {
-        return FALSE;
-    }
-
-    return local->IsValid(local);
-}
-
-int DatabusChannelRTFactorIsValid(Databus * db, size_t channel) {
-    Channel * rtfactor = NULL;
-
-    if (!db) {
-        return FALSE;
-    }
-
-    rtfactor = (Channel *) DatabusGetRTFactorChannel(db, channel);
-    if (!rtfactor) {
-        return FALSE;
-    }
-
-    return rtfactor->IsValid(rtfactor);
-}
-
 McxStatus DatabusCollectModeSwitchData(Databus * db) {
     Vector * infos = db->data->outInfo->data->infos;
     size_t size = infos->Size(infos);
diff --git a/src/core/Databus.h b/src/core/Databus.h
index 8ae0cfe..7e0df44 100644
--- a/src/core/Databus.h
+++ b/src/core/Databus.h
@@ -150,37 +150,6 @@ struct ChannelInfo * DatabusGetInChannelInfo (struct Databus * db, size_t channe
  */
 struct ChannelInfo * DatabusGetOutChannelInfo(struct Databus * db, size_t channel);
 
-/**
- * \return \c TRUE if the in channel \a channel in \a db is connected or
- * provides a default value, and \c FALSE if it is not connected or \a db or \a
- * channel are invalid.
- */
-int DatabusChannelInIsValid(struct Databus * db, size_t channel);
-
-/**
- * \return \c TRUE if the in channel \a channel in \a db is connected or
- * and \c FALSE otherwise
- */
-int DatabusChannelInIsConnected(struct Databus * db, size_t channel);
-
-/**
- * \return \c TRUE if the out channel \a channel in \a db is connected, and \c
- * FALSE if it is not connected or \a db or \a channel are invalid.
- */
-int DatabusChannelOutIsValid(struct Databus * db, size_t channel);
-
-/**
- * \return \c TRUE if the local channel \a channel in \a db has a reference, and \c
- * FALSE if it has no reference or \a db or \a channel are invalid.
- */
-int DatabusChannelLocalIsValid(struct Databus * db, size_t channel);
-
-/**
- * \return \c TRUE if the rtfactor channel \a channel in \a db has a reference, and \c
- * FALSE if it has no reference or \a db or \a channel are invalid.
- */
-int DatabusChannelRTFactorIsValid(struct Databus * db, size_t channel);
-
 
 /** private interface for Component **/
 
diff --git a/src/core/Model.c b/src/core/Model.c
index 1969b0d..2c97c22 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -950,12 +950,11 @@ static McxStatus ModelDoComponentConsistencyChecks(Component * comp, void * para
 
     for (i = 0; i < numInChannels; i++) {
         Channel * channel = (Channel *)DatabusGetInChannel(db, i);
+        ChannelIn * in = (ChannelIn *) channel;
         ChannelInfo * info = &channel->info;
 
-        if ((info->mode == CHANNEL_MANDATORY)
-            && !channel->IsValid(channel)) {
-            mcx_log(LOG_ERROR, "Model: %zu. inport (%s) of element %s not connected"
-                , i+1, ChannelInfoGetName(info), comp->GetName(comp));
+        if (info->mode == CHANNEL_MANDATORY && !channel->ProvidesValue(channel)) {
+            mcx_log(LOG_ERROR, "Model: %zu. inport (%s) of element %s not connected", i+1, ChannelInfoGetName(info), comp->GetName(comp));
             return RETURN_ERROR;
         }
     }
@@ -964,10 +963,8 @@ static McxStatus ModelDoComponentConsistencyChecks(Component * comp, void * para
         Channel * channel = (Channel *)DatabusGetOutChannel(db, i);
         ChannelInfo * info = &channel->info;
 
-        if ((info->mode == CHANNEL_MANDATORY)
-            && !channel->IsValid(channel)) {
-            mcx_log(LOG_ERROR, "Model: %zu. outport (%s) of element %s not connected"
-                , i+1, ChannelInfoGetName(info), comp->GetName(comp));
+        if (info->mode == CHANNEL_MANDATORY && !channel->ProvidesValue(channel)) {
+            mcx_log(LOG_ERROR, "Model: %zu. outport (%s) of element %s not connected", i+1, ChannelInfoGetName(info), comp->GetName(comp));
             return RETURN_ERROR;
         }
     }
@@ -1483,7 +1480,7 @@ McxStatus PrintComponentGraph(Component * comp,
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; j < GetDependencyNumIn(A); j++) {
             mcx_os_fprintf(dotFile, "        <tr>\n");
-            mcx_os_fprintf(dotFile, "          <td port=\"in%zu\">%zu</td>\n", j, j);
+            mcx_os_fprintf(dotFile, "          <td port=\"in%d\">%d</td>\n", j, j);
             mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1501,7 +1498,7 @@ McxStatus PrintComponentGraph(Component * comp,
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; j < DatabusGetOutChannelsNum(db); j++) {
             mcx_os_fprintf(dotFile, "        <tr>\n");
-            mcx_os_fprintf(dotFile, "          <td port=\"out%zu\">%zu</td>\n", j, j);
+            mcx_os_fprintf(dotFile, "          <td port=\"out%d\">%d</td>\n", j, j);
             mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1525,7 +1522,7 @@ McxStatus PrintComponentGraph(Component * comp,
             }
             GetDependency(A, i, grp, &dep);
             if (dep != DEP_INDEPENDENT) {
-                mcx_os_fprintf(dotFile, "in:in%zu -> out:out%zu;\n", i, j);
+                mcx_os_fprintf(dotFile, "in:in%d -> out:out%d;\n", i, j);
             }
         }
     }
@@ -1567,14 +1564,14 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetOutChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"out%zu\">%zu</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"out%d\">%d</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
         }
         mcx_os_fprintf(dotFile, "    </td>\n");
         mcx_os_fprintf(dotFile, "  </tr>\n");
-        mcx_os_fprintf(dotFile, "</table>>] comp%zu;\n", comps->Size(comps));
+        mcx_os_fprintf(dotFile, "</table>>] comp%d;\n", comps->Size(comps));
     }
 
     for (i = 0; i < comps->Size(comps); i++) {
@@ -1590,7 +1587,7 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetInChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"in%zu\">%zu</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"in%d\">%d</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1604,14 +1601,14 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetOutChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"out%zu\">%zu</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"out%d\">%d</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
         }
         mcx_os_fprintf(dotFile, "    </td>\n");
         mcx_os_fprintf(dotFile, "  </tr>\n");
-        mcx_os_fprintf(dotFile, "</table>>] comp%zu;\n", c->GetID(c));
+        mcx_os_fprintf(dotFile, "</table>>] comp%d;\n", c->GetID(c));
     }
 
     if (outComp) {
@@ -1626,7 +1623,7 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetInChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"in%zu\">%zu</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"in%d\">%d</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1634,13 +1631,13 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "    </td>\n");
         mcx_os_fprintf(dotFile, "    <td>out</td>\n");
         mcx_os_fprintf(dotFile, "  </tr>\n");
-        mcx_os_fprintf(dotFile, "</table>>] comp%zu;\n", comps->Size(comps) + 1);
+        mcx_os_fprintf(dotFile, "</table>>] comp%d;\n", comps->Size(comps) + 1);
     }
 
     mcx_os_fprintf(dotFile, "{\n");
 
     if (inComp && outComp) {
-        mcx_os_fprintf(dotFile, "comp%zu -> comp%zu [style=invis];\n",
+        mcx_os_fprintf(dotFile, "comp%d -> comp%d [style=invis];\n",
                 comps->Size(comps),
                 comps->Size(comps) + 1);
     }
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index e720d98..9a52e41 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -139,9 +139,10 @@ static Channel * ChannelCreate(Channel * channel) {
     // virtual functions
     channel->GetValueReference = NULL;
     channel->Update = NULL;
-    channel->IsValid = NULL;
+    channel->ProvidesValue = NULL;
 
     channel->IsConnected = NULL;
+    channel->IsFullyConnected = NULL;
 
     return channel;
 }
@@ -247,7 +248,7 @@ static McxStatus ChannelInSetReference(ChannelIn * in, void * reference, Channel
 
 static const void * ChannelInGetValueReference(Channel * channel) {
     ChannelIn * in = (ChannelIn *) channel;
-    if (!channel->IsValid(channel)) {
+    if (!channel->ProvidesValue(channel)) {
         const static int maxCountError = 10;
         static int i = 0;
         if (i < maxCountError) {
@@ -341,9 +342,28 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
     return RETURN_OK;
 }
 
-static int ChannelInIsValid(Channel * channel) {
+static int ChannelInIsFullyConnected(Channel * channel) {
+    ChannelIn * in = (ChannelIn *) channel;
+    size_t i = 0;
+    size_t connectedElems = 0;
+    size_t channelNumElems = channel->info.dimension ? ChannelDimensionNumElements(channel->info.dimension) : 1;
+
+    for (i = 0; i < in->data->connections->Size(in->data->connections); i++) {
+        Connection * conn = (Connection *) in->data->connections->At(in->data->connections, i);
+        ConnectionInfo * info = &conn->info;
 
-    if (channel->IsConnected(channel)) {
+        connectedElems += info->targetDimension ? ChannelDimensionNumElements(info->targetDimension) : 1;
+    }
+
+    if (connectedElems == channelNumElems) {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static int ChannelInProvidesValue(Channel * channel) {
+    if (ChannelInIsFullyConnected(channel)) {
         return TRUE;
     } else {
         ChannelInfo * info = &channel->info;
@@ -574,9 +594,10 @@ static ChannelIn * ChannelInCreate(ChannelIn * in) {
 
     // virtual functions
     channel->GetValueReference = ChannelInGetValueReference;
-    channel->IsValid           = ChannelInIsValid;
+    channel->ProvidesValue     = ChannelInProvidesValue;
     channel->Update            = ChannelInUpdate;
     channel->IsConnected       = ChannelInIsConnected;
+    channel->IsFullyConnected  = ChannelInIsFullyConnected;
 
     in->Setup        = ChannelInSetup;
     in->SetReference = ChannelInSetReference;
@@ -718,7 +739,7 @@ static const void * ChannelOutGetValueReference(Channel * channel) {
     ChannelInfo * info = &channel->info;
 
     // check if out is initialized
-    if (!channel->IsValid(channel)) {
+    if (!channel->ProvidesValue(channel)) {
         mcx_log(LOG_ERROR, "Port %s: Get value reference: No Value Reference", ChannelInfoGetLogName(info));
         return NULL;
     }
@@ -734,7 +755,7 @@ static ObjectList * ChannelOutGetConnections(ChannelOut * out) {
     return out->data->connections;
 }
 
-static int ChannelOutIsValid(Channel * channel) {
+static int ChannelOutProvidesValue(Channel * channel) {
     return (NULL != channel->internalValue);
 }
 
@@ -753,6 +774,43 @@ static int ChannelOutIsConnected(Channel * channel) {
     return FALSE;
 }
 
+static int ChannelOutIsFullyConnected(Channel * channel) {
+    ChannelOut * out = (ChannelOut *) channel;
+
+    if (ChannelTypeIsArray(&channel->info.type)) {
+        ObjectList* conns = out->data->connections;
+        size_t i = 0;
+        size_t num_elems = ChannelDimensionNumElements(channel->info.dimension);
+
+        int * connected = (int *) mcx_calloc(num_elems, sizeof(int));
+        if (!connected) {
+            mcx_log(LOG_ERROR, "ChannelOutIsFullyConnected: Not enough memory");
+            return -1;
+        }
+
+        for (i = 0; i < conns->Size(conns); i++) {
+            Connection * conn = (Connection *) out->data->connections->At(out->data->connections, i);
+            ConnectionInfo * info = &conn->info;
+            size_t j = 0;
+
+            for (j = 0; j < ChannelDimensionNumElements(info->sourceDimension); i++) {
+                size_t idx = ChannelDimensionGetIndex(info->sourceDimension, j, channel->info.type->ty.a.dims);
+                connected[idx] = 1;
+            }
+        }
+
+        for (i = 0; i < num_elems; i++) {
+            if (!connected[i]) {
+                return FALSE;
+            }
+        }
+
+        return TRUE;
+    } else {
+        return ChannelOutIsConnected(channel);
+    }
+}
+
 static McxStatus ChannelOutSetReference(ChannelOut * out, const void * reference, ChannelType * type) {
     Channel * channel = (Channel *) out;
     ChannelInfo * info = NULL;
@@ -978,9 +1036,10 @@ static ChannelOut * ChannelOutCreate(ChannelOut * out) {
 
     // virtual functions
     channel->GetValueReference = ChannelOutGetValueReference;
-    channel->IsValid           = ChannelOutIsValid;
+    channel->ProvidesValue     = ChannelOutProvidesValue;
     channel->Update            = ChannelOutUpdate;
     channel->IsConnected       = ChannelOutIsConnected;
+    channel->IsFullyConnected  = ChannelOutIsFullyConnected;
 
     out->Setup                = ChannelOutSetup;
     out->RegisterConnection   = ChannelOutRegisterConnection;
@@ -1020,7 +1079,7 @@ static McxStatus ChannelLocalUpdate(Channel * channel, TimeInterval * time) {
     return RETURN_OK;
 }
 
-static int ChannelLocalIsValid(Channel * channel) {
+static int ChannelLocalProvidesValue(Channel * channel) {
     return (channel->internalValue != NULL);
 }
 
@@ -1068,9 +1127,9 @@ static ChannelLocal * ChannelLocalCreate(ChannelLocal * local) {
     // virtual functions
     channel->GetValueReference = ChannelLocalGetValueReference;
     channel->Update            = ChannelLocalUpdate;
-    channel->IsValid           = ChannelLocalIsValid;
+    channel->ProvidesValue     = ChannelLocalProvidesValue;
 
-    channel->IsConnected       = ChannelLocalIsValid;
+    channel->IsConnected       = ChannelLocalProvidesValue;
 
     local->Setup        = ChannelLocalSetup;
     local->SetReference = ChannelLocalSetReference;
diff --git a/src/core/channels/Channel.h b/src/core/channels/Channel.h
index 7dae1cb..dbebf8d 100644
--- a/src/core/channels/Channel.h
+++ b/src/core/channels/Channel.h
@@ -37,6 +37,8 @@ typedef int (* fChannelIsValid)(Channel * channel);
 
 typedef int (* fChannelIsConnected)(Channel * channel);
 
+typedef int (* fChannelIsFullyConnected)(Channel * channel);
+
 typedef int (* fChannelIsDefinedDuringInit)(Channel * channel);
 
 typedef void (* fChannelSetDefinedDuringInit)(Channel * channel);
@@ -82,13 +84,18 @@ struct Channel {
      *
      * Returns true if a channel provides a value (connected or default value)
      */
-    fChannelIsValid IsValid;
+    fChannelIsValid ProvidesValue;
 
     /**
-     * Returns true if a channel is connected
+     * Returns true if a channel is connected (i.e., atleast one element of the channel)
      */
     fChannelIsConnected IsConnected;
 
+    /**
+     * Returns true if all elements of the channel are connected
+     */
+    fChannelIsFullyConnected IsFullyConnected;
+
     /**
      * Getter for the flag data->isDefinedDuringInit
      */

From e2aaaa817c16e08dc336d50cb83f7a21d71bfe89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 1 Jun 2022 09:16:26 +0200
Subject: [PATCH 127/166] FMU2: Take into account vector elements during
 dependency matrix generation

---
 src/components/comp_fmu.c | 236 ++++++++++++++++++++++++++++++++------
 1 file changed, 201 insertions(+), 35 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index 3292f41..c37e7c4 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -1095,6 +1095,41 @@ static ChannelMode GetInChannelDefaultMode(struct Component * comp) {
     return CHANNEL_OPTIONAL;
 }
 
+typedef struct ConnectedElems{
+    int is_connected;
+    size_t num_elems;
+    size_t * elems;
+} ConnectedElems;
+
+typedef struct ChannelElement {
+    size_t channel_idx;
+    size_t elem_idx;
+} ChannelElement;
+
+static Vector * GetAllElems(ChannelElement * elems, size_t num, size_t channel_idx) {
+    size_t i = 0;
+    Vector * indices = (Vector *) object_create(Vector);
+
+    if (!indices) {
+        mcx_log(LOG_ERROR, "GetAllElems: Not enough memory");
+        return NULL;
+    }
+
+    indices->Setup(indices, sizeof(size_t), NULL, NULL, NULL);
+
+    for (i = 0; i < num; i++) {
+        if (elems[i].channel_idx == channel_idx) {
+            if (RETURN_ERROR == indices->PushBack(indices, &elems[i].elem_idx)) {
+                mcx_log(LOG_ERROR, "GetAllElems: Collecting element indices failed");
+                object_destroy(indices);
+                return NULL;
+            }
+        }
+    }
+
+    return indices;
+}
+
 static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps) {
     Component * comp = (Component *) compFmu;
     McxStatus ret_val = RETURN_OK;
@@ -1107,12 +1142,10 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
     size_t num_dependencies = 0;
     size_t dep_idx = 0;
 
+    // mapping between dependency indices (from the modelDescription file) and the dependency <-> channel mapping
     SizeTSizeTMap *dependencies_to_in_channels = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
-    // dictionary used to store input connection information
-    SizeTSizeTMap *in_channel_connectivity = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
+    // mapping between unknown indices (from the modelDescription file) and the unknowns <-> channel list
     SizeTSizeTMap *unknowns_to_out_channels = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
-    // dictionary used to later find ommitted <Unknown> elements
-    SizeTSizeTMap *processed_out_channels = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
 
     // get dependency information via the fmi library
     fmi2_import_variable_list_t * init_unknowns = fmi2_import_get_initial_unknowns_list(compFmu->fmu2.fmiImport);
@@ -1132,19 +1165,104 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
     DatabusInfo * db_info = DatabusGetInInfo(db);
     size_t num_in_channels = DatabusInfoGetChannelNum(db_info);
 
+    // list describing for each channel which channel elements are connected
+    ConnectedElems * in_channel_connectivity = (ConnectedElems *) mcx_calloc(num_in_channels, sizeof(ConnectedElems));
+    if (!in_channel_connectivity) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity map allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    // List which for each dependency describes which channel and element index it corresponds to
+    // The index of elements in this list doesn't correspond to the dependency index from the modelDescription file
+    ChannelElement * dependencies_to_inputs = (ChannelElement *) mcx_calloc(DatabusGetInChannelsElemNum(db), sizeof(ChannelElement));
+    if (!dependencies_to_inputs) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Dependencies to inputs map allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    // list used to know the mapping between unknowns and channels/elements
+    ChannelElement * unknowns_to_outputs = (ChannelElement *) mcx_calloc(DatabusGetOutChannelsElemNum(db), sizeof(ChannelElement));
+    if (!unknowns_to_outputs) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Unknowns to outputs map allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    // List used to later find ommitted <Unknown> elements
+    ChannelElement * processed_output_elems = (ChannelElement *) mcx_calloc(DatabusGetOutChannelsElemNum(db), sizeof(ChannelElement));
+    if (!processed_output_elems) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Processed output elements allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
     for (i = 0; i < num_in_vars; ++i) {
         Fmu2Value *val = (Fmu2Value *)in_vars->At(in_vars, i);
         Channel * ch = (Channel *) DatabusGetInChannel(db, i);
+        ChannelIn * in = (ChannelIn *) ch;
         ChannelInfo * info = DatabusInfoGetChannel(db_info, i);
         if (ch->IsConnected(ch)) {
-            // key i in the map means channel i is connected
-            in_channel_connectivity->Add(in_channel_connectivity, i, 1 /* true */);
+            if (ChannelTypeIsArray(info->type)) {
+                in_channel_connectivity[i].is_connected = TRUE;
+                in_channel_connectivity[i].num_elems = 0;
+                in_channel_connectivity[i].elems = (int *) mcx_calloc(ChannelDimensionNumElements(info->dimension), sizeof(size_t));
+                if (!in_channel_connectivity[i].elems) {
+                    mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity element container allocation failed");
+                    ret_val = RETURN_ERROR;
+                    goto cleanup;
+                }
+
+                // if an element index appears in elems, it means that element is connected
+                ObjectContainer * connInfos = in->GetConnectionInfos(in);
+                for (j = 0; j < connInfos->Size(connInfos); j++) {
+                    ConnectionInfo * connInfo = (ConnectionInfo *) connInfos->At(connInfos, j);
+                    size_t k = 0;
+
+                    for (k = 0; k < ChannelDimensionNumElements(connInfo->targetDimension); k++) {
+                        size_t idx = ChannelDimensionGetIndex(connInfo->targetDimension, k, info->type->ty.a.dims) - info->dimension->startIdxs[0];
+                        in_channel_connectivity[i].elems[in_channel_connectivity[i].num_elems++] = idx;
+                    }
+                }
+            } else {
+                in_channel_connectivity[i].is_connected = TRUE;
+                // scalar channels are treated like they have 1 element (equal to zero)
+                in_channel_connectivity[i].num_elems = 1;
+                in_channel_connectivity[i].elems = (int*)mcx_calloc(1, sizeof(size_t));
+                if (!in_channel_connectivity[i].elems) {
+                    mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity element allocation failed");
+                    ret_val = RETURN_ERROR;
+                    goto cleanup;
+                }
+                in_channel_connectivity[i].elems[0] = 0;
+            }
         }
 
         if (val->data->type == FMU2_VALUE_SCALAR) {
             fmi2_import_variable_t *var = val->data->data.scalar;
             size_t idx = fmi2_import_get_variable_original_order(var) + 1;
-            dependencies_to_in_channels->Add(dependencies_to_in_channels, idx, i);
+            dependencies_to_in_channels->Add(dependencies_to_in_channels, idx, dep_idx);
+
+            dependencies_to_inputs[dep_idx].channel_idx = i;
+            dep_idx++;
+        } else if (val->data->type == FMU2_VALUE_ARRAY) {
+            size_t num_elems = 1;
+            size_t j = 0;
+
+            for (j = 0; j < val->data->data.array.numDims; j++) {
+                num_elems *= val->data->data.array.dims[j];
+            }
+
+            for (j = 0; j < num_elems; j++) {
+                fmi2_import_variable_t * var = val->data->data.array.values[j];
+                size_t idx = fmi2_import_get_variable_original_order(var) + 1;
+                dependencies_to_in_channels->Add(dependencies_to_in_channels, idx, dep_idx);
+
+                dependencies_to_inputs[dep_idx].channel_idx = i;
+                dependencies_to_inputs[dep_idx].elem_idx = j;
+                dep_idx++;
+            }
         }
     }
 
@@ -1153,8 +1271,7 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
     if (start_index == NULL) {
         for (i = 0; i < GetDependencyNumOut(deps); ++i) {
             for (j = 0; j < GetDependencyNumIn(deps); ++j) {
-                SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, j);
-                if (elem) {
+                if (in_channel_connectivity[j].is_connected) {
                     ret_val = SetDependency(deps, j, i, DEP_DEPENDENT);
                     if (RETURN_OK != ret_val) {
                         goto cleanup;
@@ -1167,20 +1284,42 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
     }
 
     // map each initial_unkown index to an output channel index
+    // for array channels, there might be multiple entries initial_unknown_idx -> channel_idx
     ObjectContainer *out_vars = compFmu->fmu2.out;
     size_t num_out_vars = out_vars->Size(out_vars);
-
+    size_t unknown_idx = 0;
     for (i = 0; i < num_out_vars; ++i) {
         Fmu2Value *val = (Fmu2Value *)out_vars->At(out_vars, i);
 
         if (val->data->type == FMU2_VALUE_SCALAR) {
             fmi2_import_variable_t *var = val->data->data.scalar;
             size_t idx = fmi2_import_get_variable_original_order(var) + 1;
-            unknowns_to_out_channels->Add(unknowns_to_out_channels, idx, i);
+            unknowns_to_out_channels->Add(unknowns_to_out_channels, idx, unknown_idx);
+
+            unknowns_to_outputs[unknown_idx].channel_idx = i;
+            unknown_idx++;
+        } else if (val->data->type == FMU2_VALUE_ARRAY) {
+            size_t num_elems = 1;
+            size_t j = 0;
+
+            for (j = 0; j < val->data->data.array.numDims; j++) {
+                num_elems *= val->data->data.array.dims[j];
+            }
+
+            for (j = 0; j < num_elems; j++) {
+                fmi2_import_variable_t * var = val->data->data.array.values[j];
+                size_t idx = fmi2_import_get_variable_original_order(var) + 1;
+                unknowns_to_out_channels->Add(unknowns_to_out_channels, idx, unknown_idx);
+
+                unknowns_to_outputs[unknown_idx].channel_idx = i;
+                unknowns_to_outputs[unknown_idx].elem_idx = j;
+                unknown_idx++;
+            }
         }
     }
 
     // fill up the dependency matrix
+    size_t processed_elems = 0;
     for (i = 0; i < num_init_unknowns; ++i) {
         fmi2_import_variable_t *init_unknown = fmi2_import_get_variable(init_unknowns, i);
         size_t init_unknown_idx = fmi2_import_get_variable_original_order(init_unknown) + 1;
@@ -1190,7 +1329,11 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
             continue;      // in case some variables are ommitted from the input file
         }
 
-        processed_out_channels->Add(processed_out_channels, out_pair->value, 1);
+        ChannelElement * out_elem = &unknowns_to_outputs[out_pair->value];
+
+        processed_output_elems[processed_elems].channel_idx = out_elem->channel_idx;
+        processed_output_elems[processed_elems].elem_idx = out_elem->elem_idx;
+        processed_elems++;
 
         num_dependencies = start_index[i + 1] - start_index[i];
         for (j = 0; j < num_dependencies; ++j) {
@@ -1199,9 +1342,8 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
                 // The <Unknown> element does not explicitly define a `dependencies` attribute
                 // In this case it depends on all inputs
                 for (k = 0; k < num_in_channels; ++k) {
-                    SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, k);
-                    if (elem) {
-                        ret_val = SetDependency(deps, k, out_pair->value, DEP_DEPENDENT);
+                    if (in_channel_connectivity[k].is_connected) {
+                        ret_val = SetDependency(deps, k, out_elem->channel_idx, DEP_DEPENDENT);
                         if (RETURN_OK != ret_val) {
                             goto cleanup;
                         }
@@ -1210,13 +1352,20 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
             } else {
                 // The <Unknown> element explicitly defines its dependencies
                 SizeTSizeTElem * in_pair = dependencies_to_in_channels->Get(dependencies_to_in_channels, dep_idx);
-
                 if (in_pair) {
-                    SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, in_pair->value);
-                    if (elem) {
-                        ret_val = SetDependency(deps, in_pair->value, out_pair->value, DEP_DEPENDENT);
-                        if (RETURN_OK != ret_val) {
-                            goto cleanup;
+                    ChannelElement * dep = &dependencies_to_inputs[in_pair->value];
+
+                    ConnectedElems * elems = &in_channel_connectivity[dep->channel_idx];
+                    if (elems->is_connected) {
+                        size_t k = 0;
+                        for (k = 0; k < elems->num_elems; k++) {
+                            if (elems->elems[k] == dep->elem_idx) {
+                                ret_val = SetDependency(deps, dep->channel_idx, out_elem->channel_idx, DEP_DEPENDENT);
+                                if (RETURN_OK != ret_val) {
+                                    goto cleanup;
+                                }
+                                break;
+                            }
                         }
                     }
                 }
@@ -1227,16 +1376,23 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
     // Initial unknowns which are ommitted from the <InitialUnknowns> element in
     // modelDescription.xml file depend on all inputs
     for (i = 0; i < num_out_vars; ++i) {
-        if (processed_out_channels->Get(processed_out_channels, i) == NULL) {
-            Fmu2Value *val = (Fmu2Value *)out_vars->At(out_vars, i);
+        Fmu2Value * val = (Fmu2Value *) out_vars->At(out_vars, i);
+
+        Vector * elems = GetAllElems(processed_output_elems, processed_elems, i);
+
+        if (val->data->type == FMU2_VALUE_ARRAY) {
+            size_t num_elems = 1;
+            size_t j = 0;
 
-            if (val->data->type == FMU2_VALUE_ARRAY) {
-                size_t elem_idx = 0;
-                for (elem_idx = 0; elem_idx < val->data->data.array.numDims; elem_idx++) {
-                    if (fmi2_import_get_initial(val->data->data.array.values[elem_idx]) != fmi2_initial_enu_exact) {
+            for (j = 0; j < val->data->data.array.numDims; j++) {
+                num_elems *= val->data->data.array.dims[j];
+            }
+
+            for (j = 0; j < num_elems; j++) {
+                if (!elems->Contains(elems, &j)) {
+                    if (fmi2_import_get_initial(val->data->data.array.values[j]) != fmi2_initial_enu_exact) {
                         for (k = 0; k < num_in_channels; ++k) {
-                            SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, k);
-                            if (elem) {
+                            if (in_channel_connectivity[k].is_connected) {
                                 ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
                                 if (RETURN_OK != ret_val) {
                                     goto cleanup;
@@ -1245,27 +1401,37 @@ static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps
                         }
                     }
                 }
-            } else {
+            }
+        } else {
+            if (elems->Size(elems) == 0) {
                 if (fmi2_import_get_initial(val->data->data.scalar) != fmi2_initial_enu_exact) {
                     for (k = 0; k < num_in_channels; ++k) {
-                        SizeTSizeTElem * elem = in_channel_connectivity->Get(in_channel_connectivity, k);
-                        if (elem) {
+                        if (in_channel_connectivity[k].is_connected) {
                             ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
                             if (RETURN_OK != ret_val) {
-                                goto cleanup;
+                                goto cleanup_1;
                             }
                         }
                     }
                 }
             }
         }
+
+        object_destroy(elems);
+        continue;
+
+cleanup_1:
+        object_destroy(elems);
+        goto cleanup;
     }
 
 cleanup:    // free dynamically allocated objects
     object_destroy(dependencies_to_in_channels);
-    object_destroy(in_channel_connectivity);
     object_destroy(unknowns_to_out_channels);
-    object_destroy(processed_out_channels);
+    if (in_channel_connectivity) { mcx_free(in_channel_connectivity); }
+    if (dependencies_to_inputs) { mcx_free(dependencies_to_inputs); }
+    if (unknowns_to_outputs) { mcx_free(unknowns_to_outputs); }
+    if (processed_output_elems) { mcx_free(processed_output_elems); }
     fmi2_import_free_variable_list(init_unknowns);
 
     return ret_val;

From 505c84959209aae9538c23c34585cfe0fe2acfb1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 1 Jun 2022 12:01:15 +0200
Subject: [PATCH 128/166] Move dependency matrix generation code to common

---
 src/components/comp_fmu.c | 344 +------------------------------------
 src/core/Dependency.h     |   2 +-
 src/fmu/common_fmu2.c     | 349 ++++++++++++++++++++++++++++++++++++++
 src/fmu/common_fmu2.h     |   4 +
 4 files changed, 355 insertions(+), 344 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index c37e7c4..ca8cf76 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -1095,348 +1095,6 @@ static ChannelMode GetInChannelDefaultMode(struct Component * comp) {
     return CHANNEL_OPTIONAL;
 }
 
-typedef struct ConnectedElems{
-    int is_connected;
-    size_t num_elems;
-    size_t * elems;
-} ConnectedElems;
-
-typedef struct ChannelElement {
-    size_t channel_idx;
-    size_t elem_idx;
-} ChannelElement;
-
-static Vector * GetAllElems(ChannelElement * elems, size_t num, size_t channel_idx) {
-    size_t i = 0;
-    Vector * indices = (Vector *) object_create(Vector);
-
-    if (!indices) {
-        mcx_log(LOG_ERROR, "GetAllElems: Not enough memory");
-        return NULL;
-    }
-
-    indices->Setup(indices, sizeof(size_t), NULL, NULL, NULL);
-
-    for (i = 0; i < num; i++) {
-        if (elems[i].channel_idx == channel_idx) {
-            if (RETURN_ERROR == indices->PushBack(indices, &elems[i].elem_idx)) {
-                mcx_log(LOG_ERROR, "GetAllElems: Collecting element indices failed");
-                object_destroy(indices);
-                return NULL;
-            }
-        }
-    }
-
-    return indices;
-}
-
-static McxStatus SetDependenciesFMU2(CompFMU *compFmu, struct Dependencies *deps) {
-    Component * comp = (Component *) compFmu;
-    McxStatus ret_val = RETURN_OK;
-
-    size_t *start_index = NULL;
-    size_t *dependency = NULL;
-    char   *factor_kind = NULL;
-
-    size_t i = 0, j = 0, k = 0;
-    size_t num_dependencies = 0;
-    size_t dep_idx = 0;
-
-    // mapping between dependency indices (from the modelDescription file) and the dependency <-> channel mapping
-    SizeTSizeTMap *dependencies_to_in_channels = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
-    // mapping between unknown indices (from the modelDescription file) and the unknowns <-> channel list
-    SizeTSizeTMap *unknowns_to_out_channels = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
-
-    // get dependency information via the fmi library
-    fmi2_import_variable_list_t * init_unknowns = fmi2_import_get_initial_unknowns_list(compFmu->fmu2.fmiImport);
-    size_t num_init_unknowns = fmi2_import_get_variable_list_size(init_unknowns);
-
-    fmi2_import_get_initial_unknowns_dependencies(compFmu->fmu2.fmiImport, &start_index, &dependency, &factor_kind);
-
-    // the dependency information in <InitialUnknowns> is encoded via variable indices in modelDescription.xml
-    // our dependency matrix uses channel indices
-    // to align those 2 index types we use helper dictionaries which store the mapping between them
-
-    // map each dependency index to an input channel index
-    ObjectContainer *in_vars = compFmu->fmu2.in;
-    size_t num_in_vars = in_vars->Size(in_vars);
-
-    Databus * db = comp->GetDatabus(comp);
-    DatabusInfo * db_info = DatabusGetInInfo(db);
-    size_t num_in_channels = DatabusInfoGetChannelNum(db_info);
-
-    // list describing for each channel which channel elements are connected
-    ConnectedElems * in_channel_connectivity = (ConnectedElems *) mcx_calloc(num_in_channels, sizeof(ConnectedElems));
-    if (!in_channel_connectivity) {
-        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity map allocation failed");
-        ret_val = RETURN_ERROR;
-        goto cleanup;
-    }
-
-    // List which for each dependency describes which channel and element index it corresponds to
-    // The index of elements in this list doesn't correspond to the dependency index from the modelDescription file
-    ChannelElement * dependencies_to_inputs = (ChannelElement *) mcx_calloc(DatabusGetInChannelsElemNum(db), sizeof(ChannelElement));
-    if (!dependencies_to_inputs) {
-        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Dependencies to inputs map allocation failed");
-        ret_val = RETURN_ERROR;
-        goto cleanup;
-    }
-
-    // list used to know the mapping between unknowns and channels/elements
-    ChannelElement * unknowns_to_outputs = (ChannelElement *) mcx_calloc(DatabusGetOutChannelsElemNum(db), sizeof(ChannelElement));
-    if (!unknowns_to_outputs) {
-        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Unknowns to outputs map allocation failed");
-        ret_val = RETURN_ERROR;
-        goto cleanup;
-    }
-
-    // List used to later find ommitted <Unknown> elements
-    ChannelElement * processed_output_elems = (ChannelElement *) mcx_calloc(DatabusGetOutChannelsElemNum(db), sizeof(ChannelElement));
-    if (!processed_output_elems) {
-        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Processed output elements allocation failed");
-        ret_val = RETURN_ERROR;
-        goto cleanup;
-    }
-
-    for (i = 0; i < num_in_vars; ++i) {
-        Fmu2Value *val = (Fmu2Value *)in_vars->At(in_vars, i);
-        Channel * ch = (Channel *) DatabusGetInChannel(db, i);
-        ChannelIn * in = (ChannelIn *) ch;
-        ChannelInfo * info = DatabusInfoGetChannel(db_info, i);
-        if (ch->IsConnected(ch)) {
-            if (ChannelTypeIsArray(info->type)) {
-                in_channel_connectivity[i].is_connected = TRUE;
-                in_channel_connectivity[i].num_elems = 0;
-                in_channel_connectivity[i].elems = (int *) mcx_calloc(ChannelDimensionNumElements(info->dimension), sizeof(size_t));
-                if (!in_channel_connectivity[i].elems) {
-                    mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity element container allocation failed");
-                    ret_val = RETURN_ERROR;
-                    goto cleanup;
-                }
-
-                // if an element index appears in elems, it means that element is connected
-                ObjectContainer * connInfos = in->GetConnectionInfos(in);
-                for (j = 0; j < connInfos->Size(connInfos); j++) {
-                    ConnectionInfo * connInfo = (ConnectionInfo *) connInfos->At(connInfos, j);
-                    size_t k = 0;
-
-                    for (k = 0; k < ChannelDimensionNumElements(connInfo->targetDimension); k++) {
-                        size_t idx = ChannelDimensionGetIndex(connInfo->targetDimension, k, info->type->ty.a.dims) - info->dimension->startIdxs[0];
-                        in_channel_connectivity[i].elems[in_channel_connectivity[i].num_elems++] = idx;
-                    }
-                }
-            } else {
-                in_channel_connectivity[i].is_connected = TRUE;
-                // scalar channels are treated like they have 1 element (equal to zero)
-                in_channel_connectivity[i].num_elems = 1;
-                in_channel_connectivity[i].elems = (int*)mcx_calloc(1, sizeof(size_t));
-                if (!in_channel_connectivity[i].elems) {
-                    mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity element allocation failed");
-                    ret_val = RETURN_ERROR;
-                    goto cleanup;
-                }
-                in_channel_connectivity[i].elems[0] = 0;
-            }
-        }
-
-        if (val->data->type == FMU2_VALUE_SCALAR) {
-            fmi2_import_variable_t *var = val->data->data.scalar;
-            size_t idx = fmi2_import_get_variable_original_order(var) + 1;
-            dependencies_to_in_channels->Add(dependencies_to_in_channels, idx, dep_idx);
-
-            dependencies_to_inputs[dep_idx].channel_idx = i;
-            dep_idx++;
-        } else if (val->data->type == FMU2_VALUE_ARRAY) {
-            size_t num_elems = 1;
-            size_t j = 0;
-
-            for (j = 0; j < val->data->data.array.numDims; j++) {
-                num_elems *= val->data->data.array.dims[j];
-            }
-
-            for (j = 0; j < num_elems; j++) {
-                fmi2_import_variable_t * var = val->data->data.array.values[j];
-                size_t idx = fmi2_import_get_variable_original_order(var) + 1;
-                dependencies_to_in_channels->Add(dependencies_to_in_channels, idx, dep_idx);
-
-                dependencies_to_inputs[dep_idx].channel_idx = i;
-                dependencies_to_inputs[dep_idx].elem_idx = j;
-                dep_idx++;
-            }
-        }
-    }
-
-    // <InitialUnknowns> element is not present in modelDescription.xml
-    // The dependency matrix consists of only 1 (if input is connected)
-    if (start_index == NULL) {
-        for (i = 0; i < GetDependencyNumOut(deps); ++i) {
-            for (j = 0; j < GetDependencyNumIn(deps); ++j) {
-                if (in_channel_connectivity[j].is_connected) {
-                    ret_val = SetDependency(deps, j, i, DEP_DEPENDENT);
-                    if (RETURN_OK != ret_val) {
-                        goto cleanup;
-                    }
-                }
-            }
-        }
-
-        goto cleanup;
-    }
-
-    // map each initial_unkown index to an output channel index
-    // for array channels, there might be multiple entries initial_unknown_idx -> channel_idx
-    ObjectContainer *out_vars = compFmu->fmu2.out;
-    size_t num_out_vars = out_vars->Size(out_vars);
-    size_t unknown_idx = 0;
-    for (i = 0; i < num_out_vars; ++i) {
-        Fmu2Value *val = (Fmu2Value *)out_vars->At(out_vars, i);
-
-        if (val->data->type == FMU2_VALUE_SCALAR) {
-            fmi2_import_variable_t *var = val->data->data.scalar;
-            size_t idx = fmi2_import_get_variable_original_order(var) + 1;
-            unknowns_to_out_channels->Add(unknowns_to_out_channels, idx, unknown_idx);
-
-            unknowns_to_outputs[unknown_idx].channel_idx = i;
-            unknown_idx++;
-        } else if (val->data->type == FMU2_VALUE_ARRAY) {
-            size_t num_elems = 1;
-            size_t j = 0;
-
-            for (j = 0; j < val->data->data.array.numDims; j++) {
-                num_elems *= val->data->data.array.dims[j];
-            }
-
-            for (j = 0; j < num_elems; j++) {
-                fmi2_import_variable_t * var = val->data->data.array.values[j];
-                size_t idx = fmi2_import_get_variable_original_order(var) + 1;
-                unknowns_to_out_channels->Add(unknowns_to_out_channels, idx, unknown_idx);
-
-                unknowns_to_outputs[unknown_idx].channel_idx = i;
-                unknowns_to_outputs[unknown_idx].elem_idx = j;
-                unknown_idx++;
-            }
-        }
-    }
-
-    // fill up the dependency matrix
-    size_t processed_elems = 0;
-    for (i = 0; i < num_init_unknowns; ++i) {
-        fmi2_import_variable_t *init_unknown = fmi2_import_get_variable(init_unknowns, i);
-        size_t init_unknown_idx = fmi2_import_get_variable_original_order(init_unknown) + 1;
-
-        SizeTSizeTElem * out_pair = unknowns_to_out_channels->Get(unknowns_to_out_channels, init_unknown_idx);
-        if (out_pair == NULL) {
-            continue;      // in case some variables are ommitted from the input file
-        }
-
-        ChannelElement * out_elem = &unknowns_to_outputs[out_pair->value];
-
-        processed_output_elems[processed_elems].channel_idx = out_elem->channel_idx;
-        processed_output_elems[processed_elems].elem_idx = out_elem->elem_idx;
-        processed_elems++;
-
-        num_dependencies = start_index[i + 1] - start_index[i];
-        for (j = 0; j < num_dependencies; ++j) {
-            dep_idx = dependency[start_index[i] + j];
-            if (dep_idx == 0) {
-                // The <Unknown> element does not explicitly define a `dependencies` attribute
-                // In this case it depends on all inputs
-                for (k = 0; k < num_in_channels; ++k) {
-                    if (in_channel_connectivity[k].is_connected) {
-                        ret_val = SetDependency(deps, k, out_elem->channel_idx, DEP_DEPENDENT);
-                        if (RETURN_OK != ret_val) {
-                            goto cleanup;
-                        }
-                    }
-                }
-            } else {
-                // The <Unknown> element explicitly defines its dependencies
-                SizeTSizeTElem * in_pair = dependencies_to_in_channels->Get(dependencies_to_in_channels, dep_idx);
-                if (in_pair) {
-                    ChannelElement * dep = &dependencies_to_inputs[in_pair->value];
-
-                    ConnectedElems * elems = &in_channel_connectivity[dep->channel_idx];
-                    if (elems->is_connected) {
-                        size_t k = 0;
-                        for (k = 0; k < elems->num_elems; k++) {
-                            if (elems->elems[k] == dep->elem_idx) {
-                                ret_val = SetDependency(deps, dep->channel_idx, out_elem->channel_idx, DEP_DEPENDENT);
-                                if (RETURN_OK != ret_val) {
-                                    goto cleanup;
-                                }
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // Initial unknowns which are ommitted from the <InitialUnknowns> element in
-    // modelDescription.xml file depend on all inputs
-    for (i = 0; i < num_out_vars; ++i) {
-        Fmu2Value * val = (Fmu2Value *) out_vars->At(out_vars, i);
-
-        Vector * elems = GetAllElems(processed_output_elems, processed_elems, i);
-
-        if (val->data->type == FMU2_VALUE_ARRAY) {
-            size_t num_elems = 1;
-            size_t j = 0;
-
-            for (j = 0; j < val->data->data.array.numDims; j++) {
-                num_elems *= val->data->data.array.dims[j];
-            }
-
-            for (j = 0; j < num_elems; j++) {
-                if (!elems->Contains(elems, &j)) {
-                    if (fmi2_import_get_initial(val->data->data.array.values[j]) != fmi2_initial_enu_exact) {
-                        for (k = 0; k < num_in_channels; ++k) {
-                            if (in_channel_connectivity[k].is_connected) {
-                                ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
-                                if (RETURN_OK != ret_val) {
-                                    goto cleanup;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            if (elems->Size(elems) == 0) {
-                if (fmi2_import_get_initial(val->data->data.scalar) != fmi2_initial_enu_exact) {
-                    for (k = 0; k < num_in_channels; ++k) {
-                        if (in_channel_connectivity[k].is_connected) {
-                            ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
-                            if (RETURN_OK != ret_val) {
-                                goto cleanup_1;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        object_destroy(elems);
-        continue;
-
-cleanup_1:
-        object_destroy(elems);
-        goto cleanup;
-    }
-
-cleanup:    // free dynamically allocated objects
-    object_destroy(dependencies_to_in_channels);
-    object_destroy(unknowns_to_out_channels);
-    if (in_channel_connectivity) { mcx_free(in_channel_connectivity); }
-    if (dependencies_to_inputs) { mcx_free(dependencies_to_inputs); }
-    if (unknowns_to_outputs) { mcx_free(unknowns_to_outputs); }
-    if (processed_output_elems) { mcx_free(processed_output_elems); }
-    fmi2_import_free_variable_list(init_unknowns);
-
-    return ret_val;
-}
-
 static struct Dependencies* Fmu2GetInOutGroupsInitialDependency(const Component * comp) {
     CompFMU *comp_fmu = (CompFMU *)comp;
     struct Dependencies *dependencies = NULL;
@@ -1464,7 +1122,7 @@ static struct Dependencies* Fmu2GetInOutGroupsInitialDependency(const Component
             }
         } else {
             dependencies = DependenciesCreate(num_in, num_out);
-            if (SetDependenciesFMU2(comp_fmu, dependencies) != RETURN_OK) {
+            if (Fmu2SetDependencies(&comp_fmu->fmu2, db, dependencies, TRUE) != RETURN_OK) {
                 mcx_log(LOG_ERROR, "Initial dependency matrix for %s could not be created", comp->GetName(comp));
                 return NULL;
             }
diff --git a/src/core/Dependency.h b/src/core/Dependency.h
index 861cca9..4a04a03 100644
--- a/src/core/Dependency.h
+++ b/src/core/Dependency.h
@@ -24,7 +24,7 @@ typedef enum DependencyDef {
     DEP_FIXED = 3,
 } Dependency;
 
-struct Dependencies;
+typedef struct Dependencies Dependencies;
 
 struct Dependencies * DependenciesCreate(size_t numIn, size_t numOut);
 
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 0602ecd..2aa3f0a 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -25,6 +25,8 @@
 #include "util/stdlib.h"
 #include "util/signals.h"
 
+#include "objects/Map.h"
+
 #include "fmilib.h"
 
 #ifdef __cplusplus
@@ -669,6 +671,353 @@ McxStatus Fmu2UpdateTunableParamValues(ObjectContainer * tunableParams, ObjectCo
     return retVal;
 }
 
+typedef struct ConnectedElems{
+    int is_connected;
+    size_t num_elems;
+    size_t * elems;
+} ConnectedElems;
+
+typedef struct ChannelElement {
+    size_t channel_idx;
+    size_t elem_idx;
+} ChannelElement;
+
+static Vector * GetAllElems(ChannelElement * elems, size_t num, size_t channel_idx) {
+    size_t i = 0;
+    Vector * indices = (Vector *) object_create(Vector);
+
+    if (!indices) {
+        mcx_log(LOG_ERROR, "GetAllElems: Not enough memory");
+        return NULL;
+    }
+
+    indices->Setup(indices, sizeof(size_t), NULL, NULL, NULL);
+
+    for (i = 0; i < num; i++) {
+        if (elems[i].channel_idx == channel_idx) {
+            if (RETURN_ERROR == indices->PushBack(indices, &elems[i].elem_idx)) {
+                mcx_log(LOG_ERROR, "GetAllElems: Collecting element indices failed");
+                object_destroy(indices);
+                return NULL;
+            }
+        }
+    }
+
+    return indices;
+}
+
+McxStatus Fmu2SetDependencies(Fmu2CommonStruct * fmu2, Databus * db, Dependencies * deps, int init) {
+    McxStatus ret_val = RETURN_OK;
+
+    size_t *start_index = NULL;
+    size_t *dependency = NULL;
+    char   *factor_kind = NULL;
+
+    size_t i = 0, j = 0, k = 0;
+    size_t num_dependencies = 0;
+    size_t dep_idx = 0;
+
+    // mapping between dependency indices (from the modelDescription file) and the dependency <-> channel mapping
+    SizeTSizeTMap *dependencies_to_in_channels = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
+    // mapping between unknown indices (from the modelDescription file) and the unknowns <-> channel list
+    SizeTSizeTMap *unknowns_to_out_channels = (SizeTSizeTMap*)object_create(SizeTSizeTMap);
+
+    // get dependency information via the fmi library
+    fmi2_import_variable_list_t * init_unknowns = NULL;
+
+    if (init) {
+        init_unknowns = fmi2_import_get_initial_unknowns_list(fmu2->fmiImport);
+        fmi2_import_get_initial_unknowns_dependencies(fmu2->fmiImport, &start_index, &dependency, &factor_kind);
+    } else {
+        init_unknowns = fmi2_import_get_outputs_list(fmu2->fmiImport);
+        fmi2_import_get_outputs_dependencies(fmu2->fmiImport, &start_index, &dependency, &factor_kind);
+    }
+
+    size_t num_init_unknowns = fmi2_import_get_variable_list_size(init_unknowns);
+
+    // the dependency information in <InitialUnknowns> is encoded via variable indices in modelDescription.xml
+    // our dependency matrix uses channel indices
+    // to align those 2 index types we use helper dictionaries which store the mapping between them
+
+    // map each dependency index to an input channel index
+    ObjectContainer *in_vars = fmu2->in;
+    size_t num_in_vars = in_vars->Size(in_vars);
+
+    DatabusInfo * db_info = DatabusGetInInfo(db);
+    size_t num_in_channels = DatabusInfoGetChannelNum(db_info);
+
+    // list describing for each channel which channel elements are connected
+    ConnectedElems * in_channel_connectivity = (ConnectedElems *) mcx_calloc(num_in_channels, sizeof(ConnectedElems));
+    if (!in_channel_connectivity) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity map allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    // List which for each dependency describes which channel and element index it corresponds to
+    // The index of elements in this list doesn't correspond to the dependency index from the modelDescription file
+    ChannelElement * dependencies_to_inputs = (ChannelElement *) mcx_calloc(DatabusGetInChannelsElemNum(db), sizeof(ChannelElement));
+    if (!dependencies_to_inputs) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Dependencies to inputs map allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    // list used to know the mapping between unknowns and channels/elements
+    ChannelElement * unknowns_to_outputs = (ChannelElement *) mcx_calloc(DatabusGetOutChannelsElemNum(db), sizeof(ChannelElement));
+    if (!unknowns_to_outputs) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Unknowns to outputs map allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    // List used to later find ommitted <Unknown> elements
+    ChannelElement * processed_output_elems = (ChannelElement *) mcx_calloc(DatabusGetOutChannelsElemNum(db), sizeof(ChannelElement));
+    if (!processed_output_elems) {
+        mcx_log(LOG_ERROR, "SetDependenciesFMU2: Processed output elements allocation failed");
+        ret_val = RETURN_ERROR;
+        goto cleanup;
+    }
+
+    for (i = 0; i < num_in_vars; ++i) {
+        Fmu2Value *val = (Fmu2Value *)in_vars->At(in_vars, i);
+        Channel * ch = (Channel *) DatabusGetInChannel(db, i);
+        ChannelIn * in = (ChannelIn *) ch;
+        ChannelInfo * info = DatabusInfoGetChannel(db_info, i);
+        if (ch->IsConnected(ch)) {
+            if (ChannelTypeIsArray(info->type)) {
+                in_channel_connectivity[i].is_connected = TRUE;
+                in_channel_connectivity[i].num_elems = 0;
+                in_channel_connectivity[i].elems = (int *) mcx_calloc(ChannelDimensionNumElements(info->dimension), sizeof(size_t));
+                if (!in_channel_connectivity[i].elems) {
+                    mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity element container allocation failed");
+                    ret_val = RETURN_ERROR;
+                    goto cleanup;
+                }
+
+                // if an element index appears in elems, it means that element is connected
+                ObjectContainer * connInfos = in->GetConnectionInfos(in);
+                for (j = 0; j < connInfos->Size(connInfos); j++) {
+                    ConnectionInfo * connInfo = (ConnectionInfo *) connInfos->At(connInfos, j);
+                    size_t k = 0;
+
+                    for (k = 0; k < ChannelDimensionNumElements(connInfo->targetDimension); k++) {
+                        size_t idx = ChannelDimensionGetIndex(connInfo->targetDimension, k, info->type->ty.a.dims) - info->dimension->startIdxs[0];
+                        in_channel_connectivity[i].elems[in_channel_connectivity[i].num_elems++] = idx;
+                    }
+                }
+            } else {
+                in_channel_connectivity[i].is_connected = TRUE;
+                // scalar channels are treated like they have 1 element (equal to zero)
+                in_channel_connectivity[i].num_elems = 1;
+                in_channel_connectivity[i].elems = (int*)mcx_calloc(1, sizeof(size_t));
+                if (!in_channel_connectivity[i].elems) {
+                    mcx_log(LOG_ERROR, "SetDependenciesFMU2: Input connectivity element allocation failed");
+                    ret_val = RETURN_ERROR;
+                    goto cleanup;
+                }
+                in_channel_connectivity[i].elems[0] = 0;
+            }
+        }
+
+        if (val->data->type == FMU2_VALUE_SCALAR) {
+            fmi2_import_variable_t *var = val->data->data.scalar;
+            size_t idx = fmi2_import_get_variable_original_order(var) + 1;
+            dependencies_to_in_channels->Add(dependencies_to_in_channels, idx, dep_idx);
+
+            dependencies_to_inputs[dep_idx].channel_idx = i;
+            dep_idx++;
+        } else if (val->data->type == FMU2_VALUE_ARRAY) {
+            size_t num_elems = 1;
+            size_t j = 0;
+
+            for (j = 0; j < val->data->data.array.numDims; j++) {
+                num_elems *= val->data->data.array.dims[j];
+            }
+
+            for (j = 0; j < num_elems; j++) {
+                fmi2_import_variable_t * var = val->data->data.array.values[j];
+                size_t idx = fmi2_import_get_variable_original_order(var) + 1;
+                dependencies_to_in_channels->Add(dependencies_to_in_channels, idx, dep_idx);
+
+                dependencies_to_inputs[dep_idx].channel_idx = i;
+                dependencies_to_inputs[dep_idx].elem_idx = j;
+                dep_idx++;
+            }
+        }
+    }
+
+    // <InitialUnknowns> element is not present in modelDescription.xml
+    // The dependency matrix consists of only 1 (if input is connected)
+    if (start_index == NULL) {
+        for (i = 0; i < GetDependencyNumOut(deps); ++i) {
+            for (j = 0; j < GetDependencyNumIn(deps); ++j) {
+                if (in_channel_connectivity[j].is_connected) {
+                    ret_val = SetDependency(deps, j, i, DEP_DEPENDENT);
+                    if (RETURN_OK != ret_val) {
+                        goto cleanup;
+                    }
+                }
+            }
+        }
+
+        goto cleanup;
+    }
+
+    // map each initial_unkown index to an output channel index
+    // for array channels, there might be multiple entries initial_unknown_idx -> channel_idx
+    ObjectContainer *out_vars = fmu2->out;
+    size_t num_out_vars = out_vars->Size(out_vars);
+    size_t unknown_idx = 0;
+    for (i = 0; i < num_out_vars; ++i) {
+        Fmu2Value *val = (Fmu2Value *)out_vars->At(out_vars, i);
+
+        if (val->data->type == FMU2_VALUE_SCALAR) {
+            fmi2_import_variable_t *var = val->data->data.scalar;
+            size_t idx = fmi2_import_get_variable_original_order(var) + 1;
+            unknowns_to_out_channels->Add(unknowns_to_out_channels, idx, unknown_idx);
+
+            unknowns_to_outputs[unknown_idx].channel_idx = i;
+            unknown_idx++;
+        } else if (val->data->type == FMU2_VALUE_ARRAY) {
+            size_t num_elems = 1;
+            size_t j = 0;
+
+            for (j = 0; j < val->data->data.array.numDims; j++) {
+                num_elems *= val->data->data.array.dims[j];
+            }
+
+            for (j = 0; j < num_elems; j++) {
+                fmi2_import_variable_t * var = val->data->data.array.values[j];
+                size_t idx = fmi2_import_get_variable_original_order(var) + 1;
+                unknowns_to_out_channels->Add(unknowns_to_out_channels, idx, unknown_idx);
+
+                unknowns_to_outputs[unknown_idx].channel_idx = i;
+                unknowns_to_outputs[unknown_idx].elem_idx = j;
+                unknown_idx++;
+            }
+        }
+    }
+
+    // fill up the dependency matrix
+    size_t processed_elems = 0;
+    for (i = 0; i < num_init_unknowns; ++i) {
+        fmi2_import_variable_t *init_unknown = fmi2_import_get_variable(init_unknowns, i);
+        size_t init_unknown_idx = fmi2_import_get_variable_original_order(init_unknown) + 1;
+
+        SizeTSizeTElem * out_pair = unknowns_to_out_channels->Get(unknowns_to_out_channels, init_unknown_idx);
+        if (out_pair == NULL) {
+            continue;      // in case some variables are ommitted from the input file
+        }
+
+        ChannelElement * out_elem = &unknowns_to_outputs[out_pair->value];
+
+        processed_output_elems[processed_elems].channel_idx = out_elem->channel_idx;
+        processed_output_elems[processed_elems].elem_idx = out_elem->elem_idx;
+        processed_elems++;
+
+        num_dependencies = start_index[i + 1] - start_index[i];
+        for (j = 0; j < num_dependencies; ++j) {
+            dep_idx = dependency[start_index[i] + j];
+            if (dep_idx == 0) {
+                // The <Unknown> element does not explicitly define a `dependencies` attribute
+                // In this case it depends on all inputs
+                for (k = 0; k < num_in_channels; ++k) {
+                    if (in_channel_connectivity[k].is_connected) {
+                        ret_val = SetDependency(deps, k, out_elem->channel_idx, DEP_DEPENDENT);
+                        if (RETURN_OK != ret_val) {
+                            goto cleanup;
+                        }
+                    }
+                }
+            } else {
+                // The <Unknown> element explicitly defines its dependencies
+                SizeTSizeTElem * in_pair = dependencies_to_in_channels->Get(dependencies_to_in_channels, dep_idx);
+                if (in_pair) {
+                    ChannelElement * dep = &dependencies_to_inputs[in_pair->value];
+
+                    ConnectedElems * elems = &in_channel_connectivity[dep->channel_idx];
+                    if (elems->is_connected) {
+                        size_t k = 0;
+                        for (k = 0; k < elems->num_elems; k++) {
+                            if (elems->elems[k] == dep->elem_idx) {
+                                ret_val = SetDependency(deps, dep->channel_idx, out_elem->channel_idx, DEP_DEPENDENT);
+                                if (RETURN_OK != ret_val) {
+                                    goto cleanup;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Initial unknowns which are ommitted from the <InitialUnknowns> element in
+    // modelDescription.xml file depend on all inputs
+    for (i = 0; i < num_out_vars; ++i) {
+        Fmu2Value * val = (Fmu2Value *) out_vars->At(out_vars, i);
+
+        Vector * elems = GetAllElems(processed_output_elems, processed_elems, i);
+
+        if (val->data->type == FMU2_VALUE_ARRAY) {
+            size_t num_elems = 1;
+            size_t j = 0;
+
+            for (j = 0; j < val->data->data.array.numDims; j++) {
+                num_elems *= val->data->data.array.dims[j];
+            }
+
+            for (j = 0; j < num_elems; j++) {
+                if (!elems->Contains(elems, &j)) {
+                    if (fmi2_import_get_initial(val->data->data.array.values[j]) != fmi2_initial_enu_exact) {
+                        for (k = 0; k < num_in_channels; ++k) {
+                            if (in_channel_connectivity[k].is_connected) {
+                                ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
+                                if (RETURN_OK != ret_val) {
+                                    goto cleanup;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            if (elems->Size(elems) == 0) {
+                if (fmi2_import_get_initial(val->data->data.scalar) != fmi2_initial_enu_exact) {
+                    for (k = 0; k < num_in_channels; ++k) {
+                        if (in_channel_connectivity[k].is_connected) {
+                            ret_val = SetDependency(deps, k, i, DEP_DEPENDENT);
+                            if (RETURN_OK != ret_val) {
+                                goto cleanup_1;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        object_destroy(elems);
+        continue;
+
+cleanup_1:
+        object_destroy(elems);
+        goto cleanup;
+    }
+
+cleanup:    // free dynamically allocated objects
+    object_destroy(dependencies_to_in_channels);
+    object_destroy(unknowns_to_out_channels);
+    if (in_channel_connectivity) { mcx_free(in_channel_connectivity); }
+    if (dependencies_to_inputs) { mcx_free(dependencies_to_inputs); }
+    if (unknowns_to_outputs) { mcx_free(unknowns_to_outputs); }
+    if (processed_output_elems) { mcx_free(processed_output_elems); }
+    fmi2_import_free_variable_list(init_unknowns);
+
+    return ret_val;
+}
+
 
 // TODO: move into fmu2value?
 McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
diff --git a/src/fmu/common_fmu2.h b/src/fmu/common_fmu2.h
index fe175bb..5b19e8a 100644
--- a/src/fmu/common_fmu2.h
+++ b/src/fmu/common_fmu2.h
@@ -19,6 +19,8 @@
 #include "reader/model/components/specific_data/FmuInput.h"
 #include "reader/model/parameters/ParametersInput.h"
 
+#include "core/Dependency.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
@@ -32,6 +34,8 @@ typedef struct Fmu2CommonStruct Fmu2CommonStruct;
 
 McxStatus Fmu2ReadParams(ObjectContainer * params, ObjectContainer * arrayParams, ParametersInput * input, fmi2_import_t * import, ObjectContainer * ignore);
 
+McxStatus Fmu2SetDependencies(Fmu2CommonStruct * fmu2, Databus * db, Dependencies * deps, int init);
+
 // TODO: rename all variablearrays to something better
 McxStatus Fmu2SetVariableArray(Fmu2CommonStruct * fmu, ObjectContainer * vals);
 McxStatus Fmu2GetVariableArray(Fmu2CommonStruct * fmu, ObjectContainer * vals);

From b1fb63d1a3a80a56bf21353011e0144a287efccc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 1 Jun 2022 13:02:43 +0200
Subject: [PATCH 129/166] Optimize const connections away only if the whole
 destination channel is filled

---
 src/core/Model.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/core/Model.c b/src/core/Model.c
index 2c97c22..7c0ff98 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -191,6 +191,11 @@ static McxStatus ModelPreprocessConstConnections(Model * model) {
             continue;
         }
 
+        if (!ChannelDimensionEq(trgChannelInfo->dimension, info->targetDimension)) {
+            filteredConns->PushBack(filteredConns, info);
+            continue;
+        }
+
         // else kick the connection and update the channel default value
         srcCompConst = (CompConstant *) srcComp;
         src = (ChannelValue *) mcx_calloc(1, sizeof(ChannelValue));

From d0d8dfdfd3aa1bf653f822b68512bee33a83bc92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 1 Jun 2022 14:17:13 +0200
Subject: [PATCH 130/166] Rename ChannelValueReference ->
 ChannelValueDataPointer

---
 src/components/comp_fmu.c                     |  8 +++---
 src/components/comp_vector_integrator.c       | 14 +++++-----
 src/core/Conversion.c                         | 20 ++++++-------
 src/core/channels/Channel.c                   | 14 +++++-----
 src/core/channels/ChannelValue.c              |  4 +--
 src/core/channels/ChannelValue.h              |  2 +-
 src/core/channels/ChannelValueReference.c     |  4 +--
 src/core/connections/Connection.c             |  6 ++--
 src/core/connections/FilteredConnection.c     |  6 ++--
 src/core/connections/filters/DiscreteFilter.c |  2 +-
 src/fmu/Fmu2Value.c                           |  2 +-
 src/fmu/common_fmu1.c                         | 12 ++++----
 src/fmu/common_fmu2.c                         | 28 +++++++++----------
 13 files changed, 61 insertions(+), 61 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index ca8cf76..982efe7 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -83,7 +83,7 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
                 return RETURN_ERROR;
             }
 
-            retVal = DatabusSetInReference(db, i, ChannelValueReference(&val->val), ChannelValueType(&val->val));
+            retVal = DatabusSetInReference(db, i, ChannelValueDataPointer(&val->val), ChannelValueType(&val->val));
             if (RETURN_OK != retVal) {
                 ComponentLog(comp, LOG_ERROR, "Could not set reference for channel %s", channelName);
                 return RETURN_ERROR;
@@ -125,7 +125,7 @@ static McxStatus Fmu1SetupDatabus(Component * comp) {
             return RETURN_ERROR;
         }
 
-        retVal = DatabusSetOutReference(db, i, ChannelValueReference(&val->val), ChannelValueType(&val->val));
+        retVal = DatabusSetOutReference(db, i, ChannelValueDataPointer(&val->val), ChannelValueType(&val->val));
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not set reference for channel %s", channelName);
             return RETURN_ERROR;
@@ -392,7 +392,7 @@ static McxStatus Fmu2SetupChannelIn(ObjectContainer /* Fmu2Values */ * vals, Dat
                 ChannelValueInit(&val->val, ChannelTypeClone(info->type));
             }
             retVal = DatabusSetInReference(db, i,
-                           ChannelValueReference(&val->val),
+                           ChannelValueDataPointer(&val->val),
                            ChannelValueType(&val->val));
             if (RETURN_OK != retVal) {
                 mcx_log(LOG_ERROR, "%s: Could not set reference for channel %s", logPrefix, val->name);
@@ -430,7 +430,7 @@ static McxStatus Fmu2SetupChannelOut(ObjectContainer /* Fmu2Values */ * vals, Da
             ChannelValueInit(&val->val, ChannelTypeClone(info->type));
         }
         retVal = DatabusSetOutReference(db, i,
-                                        ChannelValueReference(&val->val),
+                                        ChannelValueDataPointer(&val->val),
                                         ChannelValueType(&val->val));
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "%s: Could not set reference for channel %s", logPrefix, channelName);
diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 2d054a4..102f9ab 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -96,13 +96,13 @@ static McxStatus Setup(Component * comp) {
         ChannelInfo * inInfo = DatabusGetInChannelInfo(db, i);
         ChannelInfo * outInfo = DatabusGetOutChannelInfo(db, i);
 
-        retVal = DatabusSetInReference(db, i, ChannelValueReference(&integrator->deriv[i]), inInfo->type);
+        retVal = DatabusSetInReference(db, i, ChannelValueDataPointer(&integrator->deriv[i]), inInfo->type);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register in channel reference");
             return RETURN_ERROR;
         }
 
-        retVal = DatabusSetOutReference(db, i, ChannelValueReference(&integrator->state[i]), outInfo->type);
+        retVal = DatabusSetOutReference(db, i, ChannelValueDataPointer(&integrator->state[i]), outInfo->type);
         if (RETURN_OK != retVal) {
             ComponentLog(comp, LOG_ERROR, "Could not register out channel reference");
             return RETURN_ERROR;
@@ -119,8 +119,8 @@ static McxStatus DoStep(Component * comp, size_t group, double time, double delt
     size_t i;
     for (i = 0; i < integrator->num; i++) {
         if (ChannelTypeIsArray(ChannelValueType(&integrator->state[i]))) {
-            mcx_array * state = ChannelValueReference(&integrator->state[i]);
-            mcx_array * deriv = ChannelValueReference(&integrator->deriv[i]);
+            mcx_array * state = ChannelValueDataPointer(&integrator->state[i]);
+            mcx_array * deriv = ChannelValueDataPointer(&integrator->deriv[i]);
 
             size_t j = 0;
             for (j = 0; j < mcx_array_num_elements(state); j++) {
@@ -128,8 +128,8 @@ static McxStatus DoStep(Component * comp, size_t group, double time, double delt
             }
 
         } else {
-            double * state = (double *) ChannelValueReference(&integrator->state[i]);
-            double * deriv = (double *) ChannelValueReference(&integrator->deriv[i]);
+            double * state = (double *) ChannelValueDataPointer(&integrator->state[i]);
+            double * deriv = (double *) ChannelValueDataPointer(&integrator->deriv[i]);
 
             (*state) = (*state) + (*deriv) * deltaTime;
         }
@@ -144,7 +144,7 @@ static McxStatus Initialize(Component * comp, size_t idx, double startTime) {
     size_t i;
     for (i = 0; i < integrator->num; i++) {
         if (ChannelTypeIsArray(ChannelValueType(&integrator->state[i]))) {
-            mcx_array * a = (mcx_array *) ChannelValueReference(&integrator->state[i]);
+            mcx_array * a = (mcx_array *) ChannelValueDataPointer(&integrator->state[i]);
             size_t j;
 
             for (j = 0; j < mcx_array_num_elements(a); j++) {
diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 96de63c..9e39f39 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -308,11 +308,11 @@ static int RangeConversionElementEqualsMax(void * element, ChannelType * type) {
 static int RangeConversionIsEmpty(RangeConversion * conversion) {
     switch (conversion->type->con) {
         case CHANNEL_DOUBLE:
-            return (!conversion->min || *(double *) ChannelValueReference(conversion->min) == (-DBL_MAX)) &&
-                   (!conversion->max || *(double *) ChannelValueReference(conversion->max) == DBL_MAX);
+            return (!conversion->min || *(double *) ChannelValueDataPointer(conversion->min) == (-DBL_MAX)) &&
+                   (!conversion->max || *(double *) ChannelValueDataPointer(conversion->max) == DBL_MAX);
         case CHANNEL_INTEGER:
-            return (!conversion->min || *(int *) ChannelValueReference(conversion->min) == INT_MIN) &&
-                   (!conversion->max || *(int *) ChannelValueReference(conversion->max) == INT_MAX);
+            return (!conversion->min || *(int *) ChannelValueDataPointer(conversion->min) == INT_MIN) &&
+                   (!conversion->max || *(int *) ChannelValueDataPointer(conversion->max) == INT_MAX);
         case CHANNEL_ARRAY:
             return (!conversion->min || mcx_array_all(&conversion->min->value.a, RangeConversionElementEqualsMin)) &&
                    (!conversion->max || mcx_array_all(&conversion->max->value.a, RangeConversionElementEqualsMax));
@@ -391,7 +391,7 @@ static McxStatus UnitConversionConvert(Conversion * conversion, ChannelValue * v
             *elem = UnitConversionConvertValue(conversion, *elem);
         }
     } else {
-        double val = UnitConversionConvertValue(unitConversion, *(double *) ChannelValueReference(value));
+        double val = UnitConversionConvertValue(unitConversion, *(double *) ChannelValueDataPointer(value));
         if (RETURN_OK != ChannelValueSetFromReference(value, &val)) {
             return RETURN_ERROR;
         }
@@ -691,12 +691,12 @@ static int LinearConversionIsEmpty(LinearConversion * conversion) {
     switch (conversion->type->con) {
     case CHANNEL_DOUBLE:
         return
-            (!conversion->factor || * (double *) ChannelValueReference(conversion->factor) == 1.0) &&
-            (!conversion->offset || * (double *) ChannelValueReference(conversion->offset) == 0.0);
+            (!conversion->factor || * (double *) ChannelValueDataPointer(conversion->factor) == 1.0) &&
+            (!conversion->offset || * (double *) ChannelValueDataPointer(conversion->offset) == 0.0);
     case CHANNEL_INTEGER:
         return
-            (!conversion->factor || * (int *) ChannelValueReference(conversion->factor) == 1) &&
-            (!conversion->offset || * (int *) ChannelValueReference(conversion->offset) == 0);
+            (!conversion->factor || * (int *) ChannelValueDataPointer(conversion->factor) == 1) &&
+            (!conversion->offset || * (int *) ChannelValueDataPointer(conversion->offset) == 0);
     case CHANNEL_ARRAY:
         return (!conversion->factor || mcx_array_all(&conversion->factor->value.a, LinearConversionElementEqualsOne)) &&
                (!conversion->offset || mcx_array_all(&conversion->offset->value.a, LinearConversionElementEqualsZero));
@@ -835,7 +835,7 @@ McxStatus ConvertType(ChannelValue * dest, ChannelDimension * destSlice, Channel
         goto cleanup;
     }
 
-    ChannelValueRefSetFromReference(ref, ChannelValueReference(src), srcSlice, typeConv);
+    ChannelValueRefSetFromReference(ref, ChannelValueDataPointer(src), srcSlice, typeConv);
 
 cleanup:
     object_destroy(typeConv);
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 9a52e41..b9d6a68 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -262,7 +262,7 @@ static const void * ChannelInGetValueReference(Channel * channel) {
         return NULL;
     }
 
-    return ChannelValueReference(&channel->value);
+    return ChannelValueDataPointer(&channel->value);
 }
 
 static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
@@ -681,7 +681,7 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
 
     // default value
     if (info->defaultValue) {
-        channel->internalValue = ChannelValueReference(channel->info.defaultValue);
+        channel->internalValue = ChannelValueDataPointer(channel->info.defaultValue);
     }
 
 
@@ -744,7 +744,7 @@ static const void * ChannelOutGetValueReference(Channel * channel) {
         return NULL;
     }
 
-    return ChannelValueReference(&channel->value);
+    return ChannelValueDataPointer(&channel->value);
 }
 
 static const proc * ChannelOutGetFunction(ChannelOut * out) {
@@ -825,7 +825,7 @@ static McxStatus ChannelOutSetReference(ChannelOut * out, const void * reference
         return RETURN_ERROR;
     }
     if (channel->internalValue
-        && !(info->defaultValue && channel->internalValue == ChannelValueReference(info->defaultValue))) {
+        && !(info->defaultValue && channel->internalValue == ChannelValueDataPointer(info->defaultValue))) {
         mcx_log(LOG_ERROR, "Port %s: Set outport reference: Reference already set", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
@@ -873,7 +873,7 @@ static McxStatus ChannelOutSetReferenceFunction(ChannelOut * out, const proc * r
     ChannelValueInit(&out->data->valueFunctionRes, ChannelTypeClone(type));
 
     // Setup value reference to point to internal value
-    channel->internalValue = ChannelValueReference(&channel->value);
+    channel->internalValue = ChannelValueDataPointer(&channel->value);
 
     return RETURN_OK;
 }
@@ -923,7 +923,7 @@ static McxStatus ChannelOutUpdate(Channel * channel, TimeInterval * time) {
                               out->data->valueFunctionRes.value.d);
             }
 #endif // MCX_DEBUG
-            if (RETURN_OK != ChannelValueSetFromReference(&channel->value, ChannelValueReference(&out->data->valueFunctionRes))) {
+            if (RETURN_OK != ChannelValueSetFromReference(&channel->value, ChannelValueDataPointer(&out->data->valueFunctionRes))) {
                 return RETURN_ERROR;
             }
         } else {
@@ -1096,7 +1096,7 @@ static McxStatus ChannelLocalSetReference(ChannelLocal * local,
         return RETURN_ERROR;
     }
     if (channel->internalValue
-        && !(info->defaultValue && channel->internalValue == ChannelValueReference(info->defaultValue))) {
+        && !(info->defaultValue && channel->internalValue == ChannelValueDataPointer(info->defaultValue))) {
         mcx_log(LOG_ERROR, "Port %s: Set local value reference: Reference already set", ChannelInfoGetLogName(info));
         return RETURN_ERROR;
     }
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 79be3d3..c4a076f 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -718,7 +718,7 @@ ChannelType * ChannelValueType(ChannelValue * value) {
     return value->type;
 }
 
-void * ChannelValueReference(ChannelValue * value) {
+void * ChannelValueDataPointer(ChannelValue * value) {
     if (value->type->con == CHANNEL_UNKNOWN) {
         return NULL;
     } else {
@@ -900,7 +900,7 @@ McxStatus ChannelValueSet(ChannelValue * value, const ChannelValue * source) {
         return RETURN_ERROR;
     }
 
-    if (RETURN_OK != ChannelValueSetFromReference(value, ChannelValueReference((ChannelValue *) source))) {
+    if (RETURN_OK != ChannelValueSetFromReference(value, ChannelValueDataPointer((ChannelValue *) source))) {
         return RETURN_ERROR;
     }
 
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index ff908e2..0e529b0 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -148,7 +148,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
 McxStatus ChannelValueToStringBuffer(const ChannelValue * value, char * buffer, size_t len);
 
 ChannelType * ChannelValueType(ChannelValue * value);
-void *      ChannelValueReference(ChannelValue * value);
+void *      ChannelValueDataPointer(ChannelValue * value);
 
 void ChannelValueDataDestructor(ChannelValueData * data, ChannelType * type);
 void ChannelValueDataInit(ChannelValueData * data, ChannelType * type);
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 083de27..f0a844f 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -165,7 +165,7 @@ McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapF
 
                 return RETURN_OK;
             } else {
-                return fn(ChannelValueReference(ref->ref.value), 0, ChannelValueType(ref->ref.value), ctx);
+                return fn(ChannelValueDataPointer(ref->ref.value), 0, ChannelValueType(ref->ref.value), ctx);
             }
         case CHANNEL_VALUE_REF_SLICE:
             if (ChannelTypeIsArray(ref->ref.slice->ref->type)) {
@@ -186,7 +186,7 @@ McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapF
 
                 return RETURN_OK;
             } else {
-                return fn(ChannelValueReference(ref->ref.slice->ref), 0, ChannelValueType(ref->ref.slice->ref), ctx);
+                return fn(ChannelValueDataPointer(ref->ref.slice->ref), 0, ChannelValueType(ref->ref.slice->ref), ctx);
             }
         default:
             mcx_log(LOG_ERROR, "ChannelValueRefElemMap: Invalid internal channel value reference type (%d)", ref->type);
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 8ffbe90..0ac4972 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1203,7 +1203,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             }
         }
 
-        retVal = ChannelValueRefSetFromReference(storeRef, ChannelValueReference(inChannelValue), srcDim, typeConv);
+        retVal = ChannelValueRefSetFromReference(storeRef, ChannelValueDataPointer(inChannelValue), srcDim, typeConv);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "Could not set up initial value in connection");
             goto cleanup_1;
@@ -1233,7 +1233,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             goto cleanup;
         }
 
-        ChannelValueRefSetFromReference(storeRef, ChannelValueReference(outInfo->initialValue), targetDim, NULL);
+        ChannelValueRefSetFromReference(storeRef, ChannelValueDataPointer(outInfo->initialValue), targetDim, NULL);
         connection->useInitialValue_ = TRUE;
     } else {
         {
@@ -1338,7 +1338,7 @@ static McxStatus ConnectionEnterInitializationMode(Connection * connection) {
     // set functions for initialization mode
     connection->UpdateFromInput = ConnectionInitUpdateFrom;
     connection->UpdateToOutput = ConnectionInitUpdateTo;
-    connection->value_ = ChannelValueReference(&connection->store_);
+    connection->value_ = ChannelValueDataPointer(&connection->store_);
     connection->IsDefinedDuringInit = ConnectionIsDefinedDuringInit;
     connection->SetDefinedDuringInit = ConnectionSetDefinedDuringInit;
 
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index 9693dd5..f4f684e 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -75,7 +75,7 @@ static McxStatus FilteredConnectionSetup(Connection * connection, ChannelOut * o
     ChannelValueInit(&filteredConnection->data->store, storeType);  // steals ownership of storeType -> no clone needed
 
     // value reference
-    connection->value_ = ChannelValueReference(&filteredConnection->data->store);
+    connection->value_ = ChannelValueDataPointer(&filteredConnection->data->store);
 
     // initialize the buffer for channel function calls
     ChannelValueInit(&filteredConnection->data->updateBuffer, ChannelTypeClone(storeType));
@@ -222,7 +222,7 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
             return RETURN_ERROR;
         }
 
-        if (RETURN_OK != filteredConnection->SetResult(filteredConnection, ChannelValueReference(&filteredConnection->data->updateBuffer))) {
+        if (RETURN_OK != filteredConnection->SetResult(filteredConnection, ChannelValueDataPointer(&filteredConnection->data->updateBuffer))) {
             mcx_log(LOG_ERROR, "FilteredConnection: SetResult failed");
             return RETURN_ERROR;
         }
@@ -244,7 +244,7 @@ static McxStatus FilteredConnectionUpdateToOutput(Connection * connection, TimeI
                 size_t numFilters = FilteredConnectionGetNumFilters(filteredConnection);
                 ChannelType * type = info->type;
 
-                mcx_array * elements = (mcx_array *) ChannelValueReference(&filteredConnection->data->updateBuffer);
+                mcx_array * elements = (mcx_array *) ChannelValueDataPointer(&filteredConnection->data->updateBuffer);
                 char * dest = (char *) elements->data;
                 for (i = 0; i < numFilters; i++) {
                     filter = filteredConnection->GetReadFilter(filteredConnection, i);
diff --git a/src/core/connections/filters/DiscreteFilter.c b/src/core/connections/filters/DiscreteFilter.c
index 5f41c77..2ad8241 100644
--- a/src/core/connections/filters/DiscreteFilter.c
+++ b/src/core/connections/filters/DiscreteFilter.c
@@ -29,7 +29,7 @@ static McxStatus DiscreteFilterSetValue(ChannelFilter * filter, double time, Cha
 static ChannelValueData DiscreteFilterGetValue(ChannelFilter * filter, double time) {
     DiscreteFilter * discreteFilter = (DiscreteFilter *) filter;
 
-    return * (ChannelValueData *) ChannelValueReference(&discreteFilter->lastSynchronizationStepValue);
+    return * (ChannelValueData *) ChannelValueDataPointer(&discreteFilter->lastSynchronizationStepValue);
 }
 
 static McxStatus DiscreteFilterEnterCouplingStepMode(ChannelFilter * filter
diff --git a/src/fmu/Fmu2Value.c b/src/fmu/Fmu2Value.c
index 3cff407..cf2e0e5 100644
--- a/src/fmu/Fmu2Value.c
+++ b/src/fmu/Fmu2Value.c
@@ -350,7 +350,7 @@ static McxStatus Fmu2ValueSetup(Fmu2Value * v, const char * name, Fmu2ValueData
             n *= data->data.array.dims[i];
         }
 
-        mcx_array * a = (mcx_array *) ChannelValueReference(&v->val);
+        mcx_array * a = (mcx_array *) ChannelValueDataPointer(&v->val);
 
         for (i = 0; i < n; i++) {
             if (RETURN_OK != Fmu2ValueGetArrayVariableStart(t, data->data.array.values[i], a, i)) {
diff --git a/src/fmu/common_fmu1.c b/src/fmu/common_fmu1.c
index 41582bd..64c2896 100644
--- a/src/fmu/common_fmu1.c
+++ b/src/fmu/common_fmu1.c
@@ -587,7 +587,7 @@ McxStatus Fmu1SetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     case CHANNEL_ARRAY:
     {
         fmi1_value_reference_t * vrs = fmuVal->data->vr.array.values;
-        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
+        mcx_array * a = (mcx_array *) ChannelValueDataPointer(&fmuVal->val);
 
         size_t num = mcx_array_num_elements(a);
         void * vals = a->data;
@@ -656,7 +656,7 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     case CHANNEL_DOUBLE:
     {
         fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
-        status = fmi1_import_get_real(fmu->fmiImport, vr, 1, (fmi1_real_t *) ChannelValueReference(chVal));
+        status = fmi1_import_get_real(fmu->fmiImport, vr, 1, (fmi1_real_t *) ChannelValueDataPointer(chVal));
         if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             fmuVal->val.value.d *= -1.;
         }
@@ -665,7 +665,7 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     case CHANNEL_INTEGER:
     {
         fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
-        status = fmi1_import_get_integer(fmu->fmiImport, vr, 1, (fmi1_integer_t *) ChannelValueReference(chVal));
+        status = fmi1_import_get_integer(fmu->fmiImport, vr, 1, (fmi1_integer_t *) ChannelValueDataPointer(chVal));
         if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             fmuVal->val.value.i *= -1;
         }
@@ -674,7 +674,7 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     case CHANNEL_BOOL:
     {
         fmi1_value_reference_t vr[] = {fmuVal->data->vr.scalar};
-        status = fmi1_import_get_boolean(fmu->fmiImport, vr, 1, (fmi1_boolean_t *) ChannelValueReference(chVal));
+        status = fmi1_import_get_boolean(fmu->fmiImport, vr, 1, (fmi1_boolean_t *) ChannelValueDataPointer(chVal));
         if (fmi1_variable_is_negated_alias == fmi1_import_get_variable_alias_kind(fmuVal->data->var.scalar)) {
             fmuVal->val.value.i = !fmuVal->val.value.i;
         }
@@ -694,7 +694,7 @@ McxStatus Fmu1GetVariable(Fmu1CommonStruct * fmu, Fmu1Value * fmuVal) {
     case CHANNEL_ARRAY:
     {
         fmi1_value_reference_t * vrs = fmuVal->data->vr.array.values;
-        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
+        mcx_array * a = (mcx_array *) ChannelValueDataPointer(&fmuVal->val);
 
         size_t num = mcx_array_num_elements(a);
         void * vals = a->data;
@@ -816,7 +816,7 @@ McxStatus fmi1AddLocalChannelsFromLocalValues(ObjectContainer * vals, const char
         }
 
 
-        retVal = DatabusAddLocalChannel(db, name, buffer, unitName, ChannelValueReference(&val->val), ChannelValueType(&val->val));
+        retVal = DatabusAddLocalChannel(db, name, buffer, unitName, ChannelValueDataPointer(&val->val), ChannelValueType(&val->val));
         mcx_free(buffer);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "%s: Adding channel %s to databus failed", compName, name);
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 2aa3f0a..44b5bf6 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -1039,9 +1039,9 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     {
         fmi2_value_reference_t vr[] = {fmuVal->data->vr.scalar};
 
-        status = fmi2_import_set_real(fmu->fmiImport, vr, 1, (const fmi2_real_t *) ChannelValueReference(chVal));
+        status = fmi2_import_set_real(fmu->fmiImport, vr, 1, (const fmi2_real_t *) ChannelValueDataPointer(chVal));
 
-        MCX_DEBUG_LOG("Set %s(%d)=%f", fmuVal->name, vr[0], *(double*)ChannelValueReference(chVal));
+        MCX_DEBUG_LOG("Set %s(%d)=%f", fmuVal->name, vr[0], *(double*)ChannelValueDataPointer(chVal));
 
         break;
     }
@@ -1049,9 +1049,9 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
 
-        status = fmi2_import_set_integer(fmu->fmiImport, vr, 1, (const fmi2_integer_t *) ChannelValueReference(chVal));
+        status = fmi2_import_set_integer(fmu->fmiImport, vr, 1, (const fmi2_integer_t *) ChannelValueDataPointer(chVal));
 
-        MCX_DEBUG_LOG("Set %s(%d)=%d", fmuVal->name, vr[0], *(int*)ChannelValueReference(chVal));
+        MCX_DEBUG_LOG("Set %s(%d)=%d", fmuVal->name, vr[0], *(int*)ChannelValueDataPointer(chVal));
 
         break;
     }
@@ -1059,7 +1059,7 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
 
-        status = fmi2_import_set_boolean(fmu->fmiImport, vr, 1, (const fmi2_boolean_t *) ChannelValueReference(chVal));
+        status = fmi2_import_set_boolean(fmu->fmiImport, vr, 1, (const fmi2_boolean_t *) ChannelValueDataPointer(chVal));
 
         break;
     }
@@ -1067,14 +1067,14 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
 
-        status = fmi2_import_set_string(fmu->fmiImport, vr, 1, (fmi2_string_t *) ChannelValueReference(chVal));
+        status = fmi2_import_set_string(fmu->fmiImport, vr, 1, (fmi2_string_t *) ChannelValueDataPointer(chVal));
 
         break;
     }
     case CHANNEL_BINARY:
     case CHANNEL_BINARY_REFERENCE:
     {
-        binary_string * binary = (binary_string *) ChannelValueReference(chVal);
+        binary_string * binary = (binary_string *) ChannelValueDataPointer(chVal);
 
         fmi2_value_reference_t vrs [] = { fmuVal->data->vr.binary.lo
                                         , fmuVal->data->vr.binary.hi
@@ -1093,7 +1093,7 @@ McxStatus Fmu2SetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     case CHANNEL_ARRAY:
     {
         fmi2_value_reference_t * vrs = fmuVal->data->vr.array.values;
-        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
+        mcx_array * a = (mcx_array *) ChannelValueDataPointer(&fmuVal->val);
 
         size_t num = mcx_array_num_elements(a);
         void * vals = a->data;
@@ -1167,9 +1167,9 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
 
-        status = fmi2_import_get_real(fmu->fmiImport, vr, 1, (fmi2_real_t *) ChannelValueReference(chVal));
+        status = fmi2_import_get_real(fmu->fmiImport, vr, 1, (fmi2_real_t *) ChannelValueDataPointer(chVal));
 
-        MCX_DEBUG_LOG("Get %s(%d)=%f", fmuVal->name, vr[0], *(double*)ChannelValueReference(chVal));
+        MCX_DEBUG_LOG("Get %s(%d)=%f", fmuVal->name, vr[0], *(double*)ChannelValueDataPointer(chVal));
 
         break;
     }
@@ -1177,7 +1177,7 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
 
-        status = fmi2_import_get_integer(fmu->fmiImport, vr, 1, (fmi2_integer_t *) ChannelValueReference(chVal));
+        status = fmi2_import_get_integer(fmu->fmiImport, vr, 1, (fmi2_integer_t *) ChannelValueDataPointer(chVal));
 
         break;
     }
@@ -1185,7 +1185,7 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     {
         fmi2_value_reference_t vr[] = { fmuVal->data->vr.scalar };
 
-        status = fmi2_import_get_boolean(fmu->fmiImport, vr, 1, (fmi2_boolean_t *) ChannelValueReference(chVal));
+        status = fmi2_import_get_boolean(fmu->fmiImport, vr, 1, (fmi2_boolean_t *) ChannelValueDataPointer(chVal));
 
         break;
     }
@@ -1228,7 +1228,7 @@ McxStatus Fmu2GetVariable(Fmu2CommonStruct * fmu, Fmu2Value * fmuVal) {
     case CHANNEL_ARRAY:
     {
         fmi2_value_reference_t * vrs = fmuVal->data->vr.array.values;
-        mcx_array * a = (mcx_array *) ChannelValueReference(&fmuVal->val);
+        mcx_array * a = (mcx_array *) ChannelValueDataPointer(&fmuVal->val);
 
         size_t num = mcx_array_num_elements(a);
         void * vals = a->data;
@@ -1339,7 +1339,7 @@ McxStatus Fmi2RegisterLocalChannelsAtDatabus(ObjectContainer * vals, const char
             return RETURN_ERROR;
         }
 
-        retVal = DatabusAddLocalChannel(db, name, buffer, unitName, ChannelValueReference(&val->val), ChannelValueType(&val->val));
+        retVal = DatabusAddLocalChannel(db, name, buffer, unitName, ChannelValueDataPointer(&val->val), ChannelValueType(&val->val));
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "%s: Adding channel %s to databus failed", compName, name);
             return RETURN_ERROR;

From 30a69dfb755d65f1245c8dd480f99f7fbdf3e28f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 2 Jun 2022 15:07:05 +0200
Subject: [PATCH 131/166] Mark tunable params as discrete for arrays as well

---
 src/fmu/common_fmu2.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 44b5bf6..6e3fc40 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -1516,6 +1516,31 @@ void Fmu2MarkTunableParamsAsInputAsDiscrete(ObjectContainer * in) {
                 mcx_log(LOG_DEBUG, "Setting input \"%s\" as discrete", ChannelInfoGetLogName(info));
                 in->SetDiscrete(in);
             }
+        } else if (val->data->type == FMU2_VALUE_ARRAY) {
+            size_t num_elems = 1;
+            size_t j = 0;
+            int all_tunable = TRUE;
+
+            for (j = 0; j < val->data->data.array.numDims; j++) {
+                num_elems *= val->data->data.array.dims[j];
+            }
+
+            for (j = 0; j < num_elems; j++) {
+                fmi2_import_variable_t * var = val->data->data.array.values[j];
+                fmi2_causality_enu_t causality = fmi2_import_get_causality(var);
+
+                if (fmi2_causality_enu_input == causality) {
+                    all_tunable = FALSE;
+                    break;
+                }
+            }
+
+            if (all_tunable) {
+                ChannelIn * in = (ChannelIn *) val->channel;
+                ChannelInfo * info = &((Channel *) in)->info;
+                mcx_log(LOG_DEBUG, "Setting input \"%s\" as discrete", ChannelInfoGetLogName(info));
+                in->SetDiscrete(in);
+            }
         }
     }
 }

From 722ae1153d6060089f4a8911b4260b0e5870b137 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 2 Jun 2022 16:05:53 +0200
Subject: [PATCH 132/166] Free the dimension of the ChannelValueReference slice

---
 src/core/channels/ChannelValueReference.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index f0a844f..a8d52c3 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -17,7 +17,11 @@ extern "C" {
 
 
 void ChannelValueRefDestructor(ChannelValueRef * ref) {
-    // TODO ???
+    if (ref->type == CHANNEL_VALUE_REF_SLICE) {
+        if (ref->ref.slice->dimension) {
+            DestroyChannelDimension(&ref->ref.slice->dimension);
+        }
+    }
 }
 
 ChannelValueRef * ChannelValueRefCreate(ChannelValueRef * ref) {

From 8510e66553d29fe4dd82db935a31fa8d11f523e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 28 Jun 2022 13:40:59 +0200
Subject: [PATCH 133/166] Make ChannelValueRef a normal struct

---
 src/core/Conversion.c                     | 62 +++++++++----------
 src/core/channels/Channel.c               | 20 +++---
 src/core/channels/ChannelValueReference.c | 74 +++++++++++------------
 src/core/channels/ChannelValueReference.h | 13 ++--
 src/core/connections/Connection.c         | 21 ++++---
 5 files changed, 89 insertions(+), 101 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 9e39f39..7822299 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -226,9 +226,9 @@ McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * va
 
     if (rangeConv) {
         if (slice) {
-            ChannelValueRef * ref = MakeChannelValueRef(value, slice);
+            ChannelValueRef * ref = MakeChannelValueReference(value, slice);
             retVal = RangeConversionConvertValueRef(rangeConv, ref);
-            object_destroy(ref);
+            DestroyChannelValueReference(ref);
         } else {
             retVal = RangeConversionConvert(rangeConv, value);
         }
@@ -482,9 +482,9 @@ McxStatus ConvertUnit(const char * fromUnit, const char * toUnit, ChannelValue *
 
     if (unitConv) {
         if (slice) {
-            ChannelValueRef * ref = MakeChannelValueRef(value, slice);
+            ChannelValueRef * ref = MakeChannelValueReference(value, slice);
             retVal = UnitConversionConvertValueRef(unitConv, ref);
-            object_destroy(ref);
+            DestroyChannelValueReference(ref);
         } else {
             retVal = UnitConversionConvert(unitConv, value);
         }
@@ -751,9 +751,9 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 
     if (linearConv) {
         if (slice) {
-            ChannelValueRef * ref = MakeChannelValueRef(value, slice);
+            ChannelValueRef * ref = MakeChannelValueReference(value, slice);
             retVal = LinearConversionConvertValueRef(linearConv, ref);
-            object_destroy(ref);
+            DestroyChannelValueReference(ref);
         } else {
             retVal = LinearConversionConvert(linearConv, value);
         }
@@ -829,7 +829,7 @@ McxStatus ConvertType(ChannelValue * dest, ChannelDimension * destSlice, Channel
         goto cleanup;
     }
 
-    ref = MakeChannelValueRef(dest, destSlice);
+    ref = MakeChannelValueReference(dest, destSlice);
     if (!ref) {
         mcx_log(LOG_ERROR, "ConvertType: Value reference allocation failed");
         goto cleanup;
@@ -839,7 +839,7 @@ McxStatus ConvertType(ChannelValue * dest, ChannelDimension * destSlice, Channel
 
 cleanup:
     object_destroy(typeConv);
-    object_destroy(ref);
+    DestroyChannelValueReference(ref);
 
     return retVal;
 }
@@ -875,7 +875,7 @@ static McxStatus CheckArrayReferencingOnlyOneElement(ChannelValueRef * dest, Cha
             return RETURN_ERROR;
         }
     } else {
-        if (ChannelDimensionNumElements(dest->ref.slice->dimension) != 1) {
+        if (ChannelDimensionNumElements(dest->ref.slice.dimension) != 1) {
             mcx_log(LOG_ERROR, "Type conversion: Destination value is not an array of size 1");
             return RETURN_ERROR;
         }
@@ -902,13 +902,13 @@ static McxStatus ArraysValidForConversion(ChannelValueRef * dest,
         if (dest->type == CHANNEL_VALUE_REF_VALUE) {
             return ChannelDimensionConformsTo(srcDimension, dest->ref.value->type->ty.a.dims, dest->ref.value->type->ty.a.numDims) ? RETURN_OK : RETURN_ERROR;
         } else {
-            return ChannelDimensionConformsToDimension(dest->ref.slice->dimension, srcDimension) ? RETURN_OK : RETURN_ERROR;
+            return ChannelDimensionConformsToDimension(dest->ref.slice.dimension, srcDimension) ? RETURN_OK : RETURN_ERROR;
         }
     } else {
         if (dest->type == CHANNEL_VALUE_REF_VALUE) {
             return mcx_array_dims_match(&dest->ref.value->value.a, src) ? RETURN_OK : RETURN_ERROR;
         } else {
-            return ChannelDimensionConformsTo(dest->ref.slice->dimension, src->dims, src->numDims) ? RETURN_OK : RETURN_ERROR;
+            return ChannelDimensionConformsTo(dest->ref.slice.dimension, src->dims, src->numDims) ? RETURN_OK : RETURN_ERROR;
         }
     }
 
@@ -1109,8 +1109,8 @@ static McxStatus TypeConversionConvertDoubleToArrayDouble(Conversion * conversio
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(double *) dest->ref.value->value.a.data = *(double *) src;
     } else {
-        double * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = *(double *) src;
+        double * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = *(double *) src;
     }
 
     return RETURN_OK;
@@ -1124,8 +1124,8 @@ static McxStatus TypeConversionConvertIntegerToArrayDouble(Conversion * conversi
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(double *) dest->ref.value->value.a.data = (double) *((int *) src);
     } else {
-        double * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = (double) *((int *) src);
+        double * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = (double) *((int *) src);
     }
 
     return RETURN_OK;
@@ -1139,8 +1139,8 @@ static McxStatus TypeConversionConvertBoolToArrayDouble(Conversion * conversion,
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(double *) dest->ref.value->value.a.data = *((int *) src) != 0 ? 1. : 0.;
     } else {
-        double * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((int *) src) != 0 ? 1. : 0.;
+        double * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = *((int *) src) != 0 ? 1. : 0.;
     }
 
     return RETURN_OK;
@@ -1154,8 +1154,8 @@ static McxStatus TypeConversionConvertDoubleToArrayInteger(Conversion * conversi
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(int *) dest->ref.value->value.a.data = (int) floor(*((double *) src) + 0.5);
     } else {
-        int * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = (int) floor(*((double *) src) + 0.5);
+        int * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = (int) floor(*((double *) src) + 0.5);
     }
 
     return RETURN_OK;
@@ -1169,8 +1169,8 @@ static McxStatus TypeConversionConvertIntegerToArrayInteger(Conversion * convers
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(int *) dest->ref.value->value.a.data = *(int *) src;
     } else {
-        int * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = *(int *) src;
+        int * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = *(int *) src;
     }
 
     return RETURN_OK;
@@ -1184,8 +1184,8 @@ static McxStatus TypeConversionConvertBoolToArrayInteger(Conversion * conversion
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(int *) dest->ref.value->value.a.data = *((int *) src) != 0 ? 1 : 0;
     } else {
-        int * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((int *) src) != 0 ? 1 : 0;
+        int * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = *((int *) src) != 0 ? 1 : 0;
     }
 
     return RETURN_OK;
@@ -1199,8 +1199,8 @@ static McxStatus TypeConversionConvertDoubleToArrayBool(Conversion * conversion,
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(int *) dest->ref.value->value.a.data = *((double *) src) > 0 ? 1 : 0;
     } else {
-        int * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((double *) src) > 0 ? 1 : 0;
+        int * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = *((double *) src) > 0 ? 1 : 0;
     }
 
     return RETURN_OK;
@@ -1214,8 +1214,8 @@ static McxStatus TypeConversionConvertIntegerToArrayBool(Conversion * conversion
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(int *) dest->ref.value->value.a.data = *((int *) src) != 0 ? 1 : 0;
     } else {
-        int * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = *((int *) src) != 0 ? 1 : 0;
+        int * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = *((int *) src) != 0 ? 1 : 0;
     }
 
     return RETURN_OK;
@@ -1229,8 +1229,8 @@ static McxStatus TypeConversionConvertBoolToArrayBool(Conversion * conversion, C
     if (dest->type == CHANNEL_VALUE_REF_VALUE) {
         *(int *) dest->ref.value->value.a.data = *(int *) src;
     } else {
-        int * data = dest->ref.slice->ref->value.a.data;
-        *(data + dest->ref.slice->dimension->startIdxs[0]) = *(int *) src;
+        int * data = dest->ref.slice.ref->value.a.data;
+        *(data + dest->ref.slice.dimension->startIdxs[0]) = *(int *) src;
     }
 
     return RETURN_OK;
@@ -1241,14 +1241,14 @@ static size_t IndexOfElemInSrcArray(size_t dest_idx, mcx_array * src_array, Chan
         if (dest->type == CHANNEL_VALUE_REF_VALUE) {
             return ChannelDimensionGetIndex(src_dim, dest_idx, src_array->dims);
         } else {
-            size_t idx = ChannelDimensionGetSliceIndex(dest->ref.slice->dimension, dest_idx, dest->ref.slice->ref->type->ty.a.dims);
+            size_t idx = ChannelDimensionGetSliceIndex(dest->ref.slice.dimension, dest_idx, dest->ref.slice.ref->type->ty.a.dims);
             return ChannelDimensionGetIndex(src_dim, idx, src_array->dims);
         }
     } else {
         if (dest->type == CHANNEL_VALUE_REF_VALUE) {
             return dest_idx;
         } else {
-            return ChannelDimensionGetSliceIndex(dest->ref.slice->dimension, dest_idx, dest->ref.slice->ref->type->ty.a.dims);
+            return ChannelDimensionGetSliceIndex(dest->ref.slice.dimension, dest_idx, dest->ref.slice.ref->type->ty.a.dims);
         }
     }
 }
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index b9d6a68..d47ca47 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -424,6 +424,7 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
     ConnectionInfo * connInfo = &connection->info;
     Channel * channel = (Channel *) in;
     ChannelInfo * inInfo = &channel->info;
+    ChannelValueRef * valRef = NULL;
 
     McxStatus retVal = RETURN_OK;
 
@@ -432,29 +433,22 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         return ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Could not register connection");
     }
 
-    // TODO setup valueReference
-    ChannelValueRef * valRef = (ChannelValueRef *) object_create(ChannelValueRef);
-    if (!valRef) {
-        return RETURN_ERROR;
-    }
-
     ChannelDimension * dimension = connInfo->targetDimension;
     // TODO check ret values
     // TODO do we need some plausibility checks?
     // TODO is it fine to use connInfo here?
     if (dimension && !ChannelDimensionEq(dimension, inInfo->dimension)) {
-        valRef->type = CHANNEL_VALUE_REF_SLICE;
-        valRef->ref.slice = (ArraySlice *) mcx_calloc(1, sizeof(ArraySlice));
-        valRef->ref.slice->ref = &channel->value;
-        valRef->ref.slice->dimension = CloneChannelDimension(dimension);
-        retVal = ChannelDimensionAlignIndicesWithZero(valRef->ref.slice->dimension, inInfo->dimension);
+        ChannelDimension * slice = CloneChannelDimension(dimension);
+
+        retVal = ChannelDimensionAlignIndicesWithZero(slice, inInfo->dimension);
         if (retVal == RETURN_ERROR) {
             ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Normalizing array slice dimension failed");
             return RETURN_ERROR;
         }
+
+        valRef = MakeChannelValueReference(&channel->value, slice);
     } else {
-        valRef->type = CHANNEL_VALUE_REF_VALUE;
-        valRef->ref.value = &channel->value;
+        valRef = MakeChannelValueReference(&channel->value, NULL);
     }
 
     retVal = in->data->valueReferences->PushBack(in->data->valueReferences, (Object *) valRef);
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index a8d52c3..6fa0e6c 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -16,23 +16,36 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-void ChannelValueRefDestructor(ChannelValueRef * ref) {
+void DestroyChannelValueReference(ChannelValueRef * ref) {
     if (ref->type == CHANNEL_VALUE_REF_SLICE) {
-        if (ref->ref.slice->dimension) {
-            DestroyChannelDimension(&ref->ref.slice->dimension);
+        if (ref->ref.slice.dimension) {
+            DestroyChannelDimension(&ref->ref.slice.dimension);
         }
     }
+
+    mcx_free(ref);
 }
 
-ChannelValueRef * ChannelValueRefCreate(ChannelValueRef * ref) {
-    ref->type = CHANNEL_VALUE_REF_VALUE;
-    ref->ref.value = NULL;
+
+ChannelValueRef * MakeChannelValueReference(ChannelValue * value, ChannelDimension * slice) {
+    ChannelValueRef * ref = (ChannelValueRef *) mcx_calloc(1, sizeof(ChannelValueRef));
+
+    if (!ref) {
+        return NULL;
+    }
+
+    if (slice) {
+        ref->type = CHANNEL_VALUE_REF_SLICE;
+        ref->ref.slice.dimension = slice;
+        ref->ref.slice.ref = value;
+    } else {
+        ref->type = CHANNEL_VALUE_REF_VALUE;
+        ref->ref.value = value;
+    }
 
     return ref;
 }
 
-OBJECT_CLASS(ChannelValueRef, Object);
-
 
 McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, ChannelDimension * srcDimension, TypeConversion * conv) {
     if (conv) {
@@ -90,11 +103,11 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
             }
         }
     } else {
-        if (ChannelTypeIsArray(ref->ref.slice->ref->type)) {
-            mcx_array * destArray = &ref->ref.slice->ref->value.a;
+        if (ChannelTypeIsArray(ref->ref.slice.ref->type)) {
+            mcx_array * destArray = &ref->ref.slice.ref->value.a;
             mcx_array * srcArray = (mcx_array *) reference;
 
-            ChannelDimension * destDimension = ref->ref.slice->dimension;
+            ChannelDimension * destDimension = ref->ref.slice.dimension;
 
             if (srcArray->data == NULL || destArray->data == NULL) {
                 mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Empty array data given");
@@ -138,11 +151,11 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
                 }
 
                 return ChannelValueDataSetFromReference(
-                    &ref->ref.slice->ref->value,
-                    ref->ref.slice->ref->type,
+                    &ref->ref.slice.ref->value,
+                    ref->ref.slice.ref->type,
                     mcx_array_get_elem_reference(src, ChannelDimensionGetIndex(srcDimension, 0, src->dims)));
             } else {
-                return ChannelValueDataSetFromReference(&ref->ref.slice->ref->value, ref->ref.slice->ref->type, reference);
+                return ChannelValueDataSetFromReference(&ref->ref.slice.ref->value, ref->ref.slice.ref->type, reference);
             }
         }
     }
@@ -172,25 +185,25 @@ McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapF
                 return fn(ChannelValueDataPointer(ref->ref.value), 0, ChannelValueType(ref->ref.value), ctx);
             }
         case CHANNEL_VALUE_REF_SLICE:
-            if (ChannelTypeIsArray(ref->ref.slice->ref->type)) {
+            if (ChannelTypeIsArray(ref->ref.slice.ref->type)) {
                 size_t i = 0;
 
-                for (i = 0; i < ChannelDimensionNumElements(ref->ref.slice->dimension); i++) {
-                    size_t idx = ChannelDimensionGetIndex(ref->ref.slice->dimension, i, ref->ref.slice->ref->value.a.dims);
+                for (i = 0; i < ChannelDimensionNumElements(ref->ref.slice.dimension); i++) {
+                    size_t idx = ChannelDimensionGetIndex(ref->ref.slice.dimension, i, ref->ref.slice.ref->value.a.dims);
 
-                    void * elem = mcx_array_get_elem_reference(&ref->ref.slice->ref->value.a, idx);
+                    void * elem = mcx_array_get_elem_reference(&ref->ref.slice.ref->value.a, idx);
                     if (!elem) {
                         return RETURN_ERROR;
                     }
 
-                    if (RETURN_ERROR == fn(elem, idx, ChannelValueType(ref->ref.slice->ref), ctx)) {
+                    if (RETURN_ERROR == fn(elem, idx, ChannelValueType(ref->ref.slice.ref), ctx)) {
                         return RETURN_ERROR;
                     }
                 }
 
                 return RETURN_OK;
             } else {
-                return fn(ChannelValueDataPointer(ref->ref.slice->ref), 0, ChannelValueType(ref->ref.slice->ref), ctx);
+                return fn(ChannelValueDataPointer(ref->ref.slice.ref), 0, ChannelValueType(ref->ref.slice.ref), ctx);
             }
         default:
             mcx_log(LOG_ERROR, "ChannelValueRefElemMap: Invalid internal channel value reference type (%d)", ref->type);
@@ -204,7 +217,7 @@ ChannelType * ChannelValueRefGetType(ChannelValueRef * ref) {
             return ChannelValueType(ref->ref.value);
         case CHANNEL_VALUE_REF_SLICE:
             // TODO (do we need to adapt the indices wrt. dimension) ?
-            return ChannelValueType(ref->ref.slice->ref);
+            return ChannelValueType(ref->ref.slice.ref);
         default:
             mcx_log(LOG_ERROR, "Invalid internal channel value reference type (%d)", ref->type);
             return NULL;
@@ -212,25 +225,6 @@ ChannelType * ChannelValueRefGetType(ChannelValueRef * ref) {
 }
 
 
-ChannelValueRef * MakeChannelValueRef(ChannelValue * val, ChannelDimension * slice) {
-    ChannelValueRef * ref = (ChannelValueRef *)object_create(ChannelValueRef);
-    if (!ref) {
-        return NULL;
-    }
-
-    if (slice) {
-        ref->type = CHANNEL_VALUE_REF_SLICE;
-        ref->ref.slice = (ArraySlice *) mcx_calloc(1, sizeof(ArraySlice));
-        ref->ref.slice->dimension = slice;
-        ref->ref.slice->ref = val;
-    } else {
-        ref->type = CHANNEL_VALUE_REF_VALUE;
-        ref->ref.value = val;
-    }
-
-    return ref;
-}
-
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index bf18bdc..166b531 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -33,18 +33,19 @@ typedef enum ChannelValueRefType {
 } ChannelValueRefType;
 
 
-extern const struct ObjectClass _ChannelValueRef;
-
 typedef struct ChannelValueRef {
-    Object _;
-
     ChannelValueRefType type;
     union {
         ChannelValue * value;
-        ArraySlice * slice;
+        ArraySlice slice;
     } ref;
 } ChannelValueRef;
 
+
+ChannelValueRef * MakeChannelValueReference(ChannelValue * value, ChannelDimension * slice);
+void DestroyChannelValueReference(ChannelValueRef * ref);
+
+
 McxStatus
 ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, ChannelDimension * srcDimension, TypeConversion * typeConv);
 ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
@@ -52,8 +53,6 @@ ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
 typedef McxStatus (*fChannelValueRefElemMapFunc)(void * element, size_t idx, ChannelType * type, void * ctx);
 McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapFunc fn, void * ctx);
 
-ChannelValueRef * MakeChannelValueRef(ChannelValue * val, ChannelDimension * slice);
-
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index 0ac4972..ab15f46 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1164,13 +1164,11 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
         return RETURN_ERROR;
     }
 
-    storeRef = (ChannelValueRef *) object_create(ChannelValueRef);
+    storeRef = MakeChannelValueReference(&connection->store_, NULL);
     if (!storeRef) {
         mcx_log(LOG_ERROR, "Could not create store reference for initial connection");
         return RETURN_ERROR;
     }
-    storeRef->type = CHANNEL_VALUE_REF_VALUE;
-    storeRef->ref.value = &connection->store_;
 
     if (inInfo->initialValue) {
         TypeConversion * typeConv = NULL;
@@ -1253,7 +1251,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
     }
 
 cleanup:
-    object_destroy(storeRef);
+    DestroyChannelValueReference(storeRef);
 
     return retVal;
 }
@@ -1272,23 +1270,26 @@ static void ConnectionInitUpdateFrom(Connection * connection, TimeInterval * tim
 static McxStatus ConnectionInitSetToStore(Connection * connection) {
     Channel* channel = (Channel*)connection->out_;
     ChannelInfo* info = &channel->info;
-    ChannelValueRef * storeRef = (ChannelValueRef *) object_create(ChannelValueRef);
+    ChannelValueRef * storeRef = MakeChannelValueReference(&connection->store_, NULL);
+    McxStatus retVal = RETURN_OK;
 
     if (!storeRef) {
         mcx_log(LOG_ERROR, "Could not create store reference for initial connection");
         return RETURN_ERROR;
     }
-    storeRef->type = CHANNEL_VALUE_REF_VALUE;
-    storeRef->ref.value = &connection->store_;
 
     ConnectionInfo * connInfo = connection->GetInfo(connection);
     ChannelDimension * clone = CloneChannelDimension(connInfo->sourceDimension);
     ChannelDimensionAlignIndicesWithZero(clone, info->dimension);
-    if (RETURN_OK != ChannelValueRefSetFromReference(storeRef, channel->GetValueReference(channel), clone, NULL)) {
-        return RETURN_ERROR;
+    retVal = ChannelValueRefSetFromReference(storeRef, channel->GetValueReference(channel), clone, NULL);
+    if (RETURN_ERROR == retVal) {
+        goto cleanup;
     }
 
-    return RETURN_OK;
+cleanup:
+    DestroyChannelValueReference(storeRef);
+
+    return retVal;
 }
 
 static McxStatus ConnectionInitUpdateTo(Connection * connection, TimeInterval * time) {

From 3ab7d69aefbc8ac19d645a4403bbea4a8d875004 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 28 Jun 2022 14:01:06 +0200
Subject: [PATCH 134/166] Rename ChannelValueRef -> ChannelValueReference

---
 src/core/Conversion.c                     | 156 +++++++++++-----------
 src/core/Conversion.h                     |   8 +-
 src/core/channels/Channel.c               |  10 +-
 src/core/channels/ChannelValueReference.c |  36 ++---
 src/core/channels/ChannelValueReference.h |  16 +--
 src/core/connections/Connection.c         |  10 +-
 6 files changed, 118 insertions(+), 118 deletions(-)

diff --git a/src/core/Conversion.c b/src/core/Conversion.c
index 7822299..6ccec92 100644
--- a/src/core/Conversion.c
+++ b/src/core/Conversion.c
@@ -149,20 +149,20 @@ McxStatus RangeConversionMaxValueRefConversion(void * element, size_t idx, Chann
     return RETURN_OK;
 }
 
-static McxStatus RangeConversionConvertValueRef(RangeConversion * conversion, ChannelValueRef * ref) {
+static McxStatus RangeConversionConvertValueRef(RangeConversion * conversion, ChannelValueReference * ref) {
     RangeConversion * rangeConversion = (RangeConversion *) conversion;
     McxStatus retVal = RETURN_OK;
 
-    if (!ChannelTypeEq(ChannelValueRefGetType(ref), rangeConversion->type)) {
+    if (!ChannelTypeEq(ChannelValueReferenceGetType(ref), rangeConversion->type)) {
         mcx_log(LOG_ERROR,
                 "Range conversion: Value has wrong type %s, expected: %s",
-                ChannelTypeToString(ChannelValueRefGetType(ref)),
+                ChannelTypeToString(ChannelValueReferenceGetType(ref)),
                 ChannelTypeToString(rangeConversion->type));
         return RETURN_ERROR;
     }
 
     if (rangeConversion->min) {
-        retVal = ChannelValueRefElemMap(ref, RangeConversionMinValueRefConversion, rangeConversion->min);
+        retVal = ChannelValueReferenceElemMap(ref, RangeConversionMinValueRefConversion, rangeConversion->min);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Range conversion: Set value to min failed");
             return RETURN_ERROR;
@@ -170,7 +170,7 @@ static McxStatus RangeConversionConvertValueRef(RangeConversion * conversion, Ch
     }
 
     if (rangeConversion->max) {
-        retVal = ChannelValueRefElemMap(ref, RangeConversionMaxValueRefConversion, rangeConversion->max);
+        retVal = ChannelValueReferenceElemMap(ref, RangeConversionMaxValueRefConversion, rangeConversion->max);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Range conversion: Set value to max failed");
             return RETURN_ERROR;
@@ -226,7 +226,7 @@ McxStatus ConvertRange(ChannelValue * min, ChannelValue * max, ChannelValue * va
 
     if (rangeConv) {
         if (slice) {
-            ChannelValueRef * ref = MakeChannelValueReference(value, slice);
+            ChannelValueReference * ref = MakeChannelValueReference(value, slice);
             retVal = RangeConversionConvertValueRef(rangeConv, ref);
             DestroyChannelValueReference(ref);
         } else {
@@ -409,16 +409,16 @@ McxStatus UnitConversionValueRefConversion(void * element, size_t idx, ChannelTy
     return RETURN_OK;
 }
 
-static McxStatus UnitConversionConvertValueRef(UnitConversion * conversion, ChannelValueRef * ref) {
-    if (!ChannelTypeEq(ChannelTypeBaseType(ChannelValueRefGetType(ref)), &ChannelTypeDouble)) {
+static McxStatus UnitConversionConvertValueRef(UnitConversion * conversion, ChannelValueReference * ref) {
+    if (!ChannelTypeEq(ChannelTypeBaseType(ChannelValueReferenceGetType(ref)), &ChannelTypeDouble)) {
         mcx_log(LOG_ERROR,
                 "Unit conversion: Value has wrong type %s, expected: %s",
-                ChannelTypeToString(ChannelTypeBaseType(ChannelValueRefGetType(ref))),
+                ChannelTypeToString(ChannelTypeBaseType(ChannelValueReferenceGetType(ref))),
                 ChannelTypeToString(&ChannelTypeDouble));
         return RETURN_ERROR;
     }
 
-    return ChannelValueRefElemMap(ref, UnitConversionValueRefConversion, conversion);
+    return ChannelValueReferenceElemMap(ref, UnitConversionValueRefConversion, conversion);
 }
 
 static McxStatus UnitConversionSetup(UnitConversion * conversion,
@@ -482,7 +482,7 @@ McxStatus ConvertUnit(const char * fromUnit, const char * toUnit, ChannelValue *
 
     if (unitConv) {
         if (slice) {
-            ChannelValueRef * ref = MakeChannelValueReference(value, slice);
+            ChannelValueReference * ref = MakeChannelValueReference(value, slice);
             retVal = UnitConversionConvertValueRef(unitConv, ref);
             DestroyChannelValueReference(ref);
         } else {
@@ -615,11 +615,11 @@ McxStatus LinearConversionOffsetValueRefConversion(void * element, size_t idx, C
     return RETURN_OK;
 }
 
-static McxStatus LinearConversionConvertValueRef(LinearConversion * linearConversion, ChannelValueRef * ref) {
+static McxStatus LinearConversionConvertValueRef(LinearConversion * linearConversion, ChannelValueReference * ref) {
     McxStatus retVal = RETURN_OK;
 
     if (linearConversion->factor) {
-        retVal = ChannelValueRefElemMap(ref, LinearConversionScaleValueRefConversion, linearConversion->factor);
+        retVal = ChannelValueReferenceElemMap(ref, LinearConversionScaleValueRefConversion, linearConversion->factor);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Linear conversion: Port value scaling failed");
             return RETURN_ERROR;
@@ -627,7 +627,7 @@ static McxStatus LinearConversionConvertValueRef(LinearConversion * linearConver
     }
 
     if (linearConversion->offset) {
-        retVal = ChannelValueRefElemMap(ref, LinearConversionOffsetValueRefConversion, linearConversion->offset);
+        retVal = ChannelValueReferenceElemMap(ref, LinearConversionOffsetValueRefConversion, linearConversion->offset);
         if (RETURN_OK != retVal) {
             mcx_log(LOG_ERROR, "Linear conversion: Adding offset failed");
             return RETURN_ERROR;
@@ -751,7 +751,7 @@ McxStatus ConvertLinear(ChannelValue * factor, ChannelValue * offset, ChannelVal
 
     if (linearConv) {
         if (slice) {
-            ChannelValueRef * ref = MakeChannelValueReference(value, slice);
+            ChannelValueReference * ref = MakeChannelValueReference(value, slice);
             retVal = LinearConversionConvertValueRef(linearConv, ref);
             DestroyChannelValueReference(ref);
         } else {
@@ -813,7 +813,7 @@ OBJECT_CLASS(LinearConversion, Conversion);
 // Type Conversion
 McxStatus ConvertType(ChannelValue * dest, ChannelDimension * destSlice, ChannelValue * src, ChannelDimension * srcSlice) {
     TypeConversion * typeConv = NULL;
-    ChannelValueRef * ref = NULL;
+    ChannelValueReference * ref = NULL;
 
     McxStatus retVal = RETURN_OK;
 
@@ -835,7 +835,7 @@ McxStatus ConvertType(ChannelValue * dest, ChannelDimension * destSlice, Channel
         goto cleanup;
     }
 
-    ChannelValueRefSetFromReference(ref, ChannelValueDataPointer(src), srcSlice, typeConv);
+    ChannelValueReferenceSetFromPointer(ref, ChannelValueDataPointer(src), srcSlice, typeConv);
 
 cleanup:
     object_destroy(typeConv);
@@ -858,13 +858,13 @@ static McxStatus CheckTypesValidForConversion(ChannelType * destType,
     return RETURN_OK;
 }
 
-static McxStatus CheckArrayReferencingOnlyOneElement(ChannelValueRef * dest, ChannelType * expectedDestType) {
-    if (!ChannelTypeIsArray(ChannelValueRefGetType(dest))) {
+static McxStatus CheckArrayReferencingOnlyOneElement(ChannelValueReference * dest, ChannelType * expectedDestType) {
+    if (!ChannelTypeIsArray(ChannelValueReferenceGetType(dest))) {
         mcx_log(LOG_ERROR, "Type conversion: Destination value is not an array");
         return RETURN_ERROR;
     }
 
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelTypeBaseType(ChannelValueRefGetType(dest)), expectedDestType)) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelTypeBaseType(ChannelValueReferenceGetType(dest)), expectedDestType)) {
         return RETURN_ERROR;
     }
 
@@ -884,16 +884,16 @@ static McxStatus CheckArrayReferencingOnlyOneElement(ChannelValueRef * dest, Cha
     return RETURN_OK;
 }
 
-static McxStatus ArraysValidForConversion(ChannelValueRef * dest,
+static McxStatus ArraysValidForConversion(ChannelValueReference * dest,
                                           ChannelType * expectedDestType,
                                           mcx_array * src,
                                           ChannelDimension * srcDimension) {
-    if (!ChannelTypeIsArray(ChannelValueRefGetType(dest))) {
+    if (!ChannelTypeIsArray(ChannelValueReferenceGetType(dest))) {
         mcx_log(LOG_ERROR, "Type conversion: Destination value is not an array");
         return RETURN_ERROR;
     }
 
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelTypeBaseType(ChannelValueRefGetType(dest)), expectedDestType)) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelTypeBaseType(ChannelValueReferenceGetType(dest)), expectedDestType)) {
         return RETURN_ERROR;
     }
 
@@ -915,8 +915,8 @@ static McxStatus ArraysValidForConversion(ChannelValueRef * dest,
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
@@ -925,8 +925,8 @@ static McxStatus TypeConversionConvertIntDouble(Conversion * conversion, Channel
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertDoubleInt(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+static McxStatus TypeConversionConvertDoubleInt(Conversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
 
@@ -935,8 +935,8 @@ static McxStatus TypeConversionConvertDoubleInt(Conversion * conversion, Channel
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertBoolDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+static McxStatus TypeConversionConvertBoolDouble(Conversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
@@ -945,8 +945,8 @@ static McxStatus TypeConversionConvertBoolDouble(Conversion * conversion, Channe
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertDoubleBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+static McxStatus TypeConversionConvertDoubleBool(Conversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
 
@@ -955,8 +955,8 @@ static McxStatus TypeConversionConvertDoubleBool(Conversion * conversion, Channe
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertBoolInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+static McxStatus TypeConversionConvertBoolInteger(Conversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
 
@@ -965,8 +965,8 @@ static McxStatus TypeConversionConvertBoolInteger(Conversion * conversion, Chann
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
 
@@ -975,8 +975,8 @@ static McxStatus TypeConversionConvertIntegerBool(Conversion * conversion, Chann
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayDoubleToDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+static McxStatus TypeConversionConvertArrayDoubleToDouble(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
@@ -989,8 +989,8 @@ static McxStatus TypeConversionConvertArrayDoubleToDouble(TypeConversion * conve
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayIntegerToDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+static McxStatus TypeConversionConvertArrayIntegerToDouble(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
@@ -1003,8 +1003,8 @@ static McxStatus TypeConversionConvertArrayIntegerToDouble(TypeConversion * conv
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayBoolToDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeDouble)) {
+static McxStatus TypeConversionConvertArrayBoolToDouble(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
 
@@ -1017,8 +1017,8 @@ static McxStatus TypeConversionConvertArrayBoolToDouble(TypeConversion * convers
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayDoubleToInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+static McxStatus TypeConversionConvertArrayDoubleToInteger(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
 
@@ -1031,8 +1031,8 @@ static McxStatus TypeConversionConvertArrayDoubleToInteger(TypeConversion * conv
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayIntegerToInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+static McxStatus TypeConversionConvertArrayIntegerToInteger(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
 
@@ -1045,8 +1045,8 @@ static McxStatus TypeConversionConvertArrayIntegerToInteger(TypeConversion * con
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayBoolToInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeInteger)) {
+static McxStatus TypeConversionConvertArrayBoolToInteger(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
 
@@ -1059,8 +1059,8 @@ static McxStatus TypeConversionConvertArrayBoolToInteger(TypeConversion * conver
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayDoubleToBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+static McxStatus TypeConversionConvertArrayDoubleToBool(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
 
@@ -1073,8 +1073,8 @@ static McxStatus TypeConversionConvertArrayDoubleToBool(TypeConversion * convers
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayIntegerToBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+static McxStatus TypeConversionConvertArrayIntegerToBool(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
 
@@ -1087,8 +1087,8 @@ static McxStatus TypeConversionConvertArrayIntegerToBool(TypeConversion * conver
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayBoolToBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueRefGetType(dest), &ChannelTypeBool)) {
+static McxStatus TypeConversionConvertArrayBoolToBool(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    if (RETURN_ERROR == CheckTypesValidForConversion(ChannelValueReferenceGetType(dest), &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
 
@@ -1101,7 +1101,7 @@ static McxStatus TypeConversionConvertArrayBoolToBool(TypeConversion * conversio
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertDoubleToArrayDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertDoubleToArrayDouble(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
@@ -1116,7 +1116,7 @@ static McxStatus TypeConversionConvertDoubleToArrayDouble(Conversion * conversio
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertIntegerToArrayDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertIntegerToArrayDouble(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
@@ -1131,7 +1131,7 @@ static McxStatus TypeConversionConvertIntegerToArrayDouble(Conversion * conversi
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertBoolToArrayDouble(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertBoolToArrayDouble(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeDouble)) {
         return RETURN_ERROR;
     }
@@ -1146,7 +1146,7 @@ static McxStatus TypeConversionConvertBoolToArrayDouble(Conversion * conversion,
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertDoubleToArrayInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertDoubleToArrayInteger(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
@@ -1161,7 +1161,7 @@ static McxStatus TypeConversionConvertDoubleToArrayInteger(Conversion * conversi
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertIntegerToArrayInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertIntegerToArrayInteger(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
@@ -1176,7 +1176,7 @@ static McxStatus TypeConversionConvertIntegerToArrayInteger(Conversion * convers
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertBoolToArrayInteger(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertBoolToArrayInteger(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeInteger)) {
         return RETURN_ERROR;
     }
@@ -1191,7 +1191,7 @@ static McxStatus TypeConversionConvertBoolToArrayInteger(Conversion * conversion
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertDoubleToArrayBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertDoubleToArrayBool(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
@@ -1206,7 +1206,7 @@ static McxStatus TypeConversionConvertDoubleToArrayBool(Conversion * conversion,
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertIntegerToArrayBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertIntegerToArrayBool(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
@@ -1221,7 +1221,7 @@ static McxStatus TypeConversionConvertIntegerToArrayBool(Conversion * conversion
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertBoolToArrayBool(Conversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertBoolToArrayBool(Conversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_ERROR == CheckArrayReferencingOnlyOneElement(dest, &ChannelTypeBool)) {
         return RETURN_ERROR;
     }
@@ -1236,7 +1236,7 @@ static McxStatus TypeConversionConvertBoolToArrayBool(Conversion * conversion, C
     return RETURN_OK;
 }
 
-static size_t IndexOfElemInSrcArray(size_t dest_idx, mcx_array * src_array, ChannelDimension * src_dim, ChannelValueRef * dest) {
+static size_t IndexOfElemInSrcArray(size_t dest_idx, mcx_array * src_array, ChannelDimension * src_dim, ChannelValueReference * dest) {
     if (src_dim) {
         if (dest->type == CHANNEL_VALUE_REF_VALUE) {
             return ChannelDimensionGetIndex(src_dim, dest_idx, src_array->dims);
@@ -1256,7 +1256,7 @@ static size_t IndexOfElemInSrcArray(size_t dest_idx, mcx_array * src_array, Chan
 typedef struct Array2ArrayCtx {
     mcx_array * src_array;
     ChannelDimension * src_dim;
-    ChannelValueRef * dest;
+    ChannelValueReference * dest;
 } Array2ArrayCtx;
 
 static McxStatus IntegerArrayToDouble(void * element, size_t idx, ChannelType * type, void * ctx) {
@@ -1343,62 +1343,62 @@ static McxStatus IntegerArrayToBool(void * element, size_t idx, ChannelType * ty
     return RETURN_OK;
 }
 
-static McxStatus TypeConversionConvertArrayIntegerToArrayDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertArrayIntegerToArrayDouble(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeDouble, (mcx_array *) src, conversion->sourceSlice)) {
         return RETURN_ERROR;
     }
 
     Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
-    return ChannelValueRefElemMap(dest, IntegerArrayToDouble, &ctx);
+    return ChannelValueReferenceElemMap(dest, IntegerArrayToDouble, &ctx);
 }
 
-static McxStatus TypeConversionConvertArrayBoolToArrayDouble(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertArrayBoolToArrayDouble(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeDouble, (mcx_array *) src, conversion->sourceSlice)) {
         return RETURN_ERROR;
     }
 
     Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
-    return ChannelValueRefElemMap(dest, BoolArrayToDouble, &ctx);
+    return ChannelValueReferenceElemMap(dest, BoolArrayToDouble, &ctx);
 }
 
-static McxStatus TypeConversionConvertArrayDoubleToArrayInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertArrayDoubleToArrayInteger(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeInteger, (mcx_array *) src, conversion->sourceSlice)) {
         return RETURN_ERROR;
     }
 
     Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
-    return ChannelValueRefElemMap(dest, DoubleArrayToInteger, &ctx);
+    return ChannelValueReferenceElemMap(dest, DoubleArrayToInteger, &ctx);
 }
 
-static McxStatus TypeConversionConvertArrayBoolToArrayInteger(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertArrayBoolToArrayInteger(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeInteger, (mcx_array *) src, conversion->sourceSlice)) {
         return RETURN_ERROR;
     }
 
     Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
-    return ChannelValueRefElemMap(dest, BoolArrayToInteger, &ctx);
+    return ChannelValueReferenceElemMap(dest, BoolArrayToInteger, &ctx);
 }
 
-static McxStatus TypeConversionConvertArrayDoubleToArrayBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertArrayDoubleToArrayBool(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeBool, (mcx_array *) src, conversion->sourceSlice)) {
         return RETURN_ERROR;
     }
 
     Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
-    return ChannelValueRefElemMap(dest, DoubleArrayToBool, &ctx);
+    return ChannelValueReferenceElemMap(dest, DoubleArrayToBool, &ctx);
 }
 
-static McxStatus TypeConversionConvertArrayIntegerToArrayBool(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
+static McxStatus TypeConversionConvertArrayIntegerToArrayBool(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
     if (RETURN_OK != ArraysValidForConversion(dest, &ChannelTypeBool, (mcx_array *) src, conversion->sourceSlice)) {
         return RETURN_ERROR;
     }
 
     Array2ArrayCtx ctx = {src, conversion->sourceSlice, dest};
-    return ChannelValueRefElemMap(dest, IntegerArrayToBool, &ctx);
+    return ChannelValueReferenceElemMap(dest, IntegerArrayToBool, &ctx);
 }
 
-static McxStatus TypeConversionConvertId(TypeConversion * conversion, ChannelValueRef * dest, void * src) {
-    return ChannelValueRefSetFromReference(dest, src, conversion->sourceSlice, NULL);
+static McxStatus TypeConversionConvertId(TypeConversion * conversion, ChannelValueReference * dest, void * src) {
+    return ChannelValueReferenceSetFromPointer(dest, src, conversion->sourceSlice, NULL);
 }
 
 static int DimensionsMatch(ChannelType * fromType, ChannelDimension * fromDimension, ChannelType * toType, ChannelDimension * toDimension) {
diff --git a/src/core/Conversion.h b/src/core/Conversion.h
index fe98f8b..1c2d3ed 100644
--- a/src/core/Conversion.h
+++ b/src/core/Conversion.h
@@ -20,7 +20,7 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-typedef struct ChannelValueRef ChannelValueRef;
+typedef struct ChannelValueReference ChannelValueReference;
 
 typedef struct Conversion Conversion;
 
@@ -70,7 +70,7 @@ typedef void(*fUnitConversionVector)(UnitConversion * conversion, double * value
 
 typedef McxStatus (* fUnitConversionSetup)(UnitConversion * conversion, const char * fromUnit, const char * toUnit);
 typedef int (* fUnitConversionIsEmpty)(UnitConversion * conversion);
-typedef McxStatus (*fUnitConversionConvertValueRef)(UnitConversion * conversion, ChannelValueRef * ref);
+typedef McxStatus (*fUnitConversionConvertValueRef)(UnitConversion * conversion, ChannelValueReference * ref);
 
 extern const struct ObjectClass _UnitConversion;
 
@@ -126,9 +126,9 @@ typedef McxStatus (*fTypeConversionSetup)(TypeConversion * conversion,
                                           const ChannelType * toType,
                                           ChannelDimension * toDimension);
 
-// TODO: Ideally the `src` argument would also be ChannelValueRef, but that requires quite of lot of changes
+// TODO: Ideally the `src` argument would also be ChannelValueReference, but that requires quite of lot of changes
 //       in the API of databus definition (i.e. DatabusSetIn(Out)Reference)
-typedef McxStatus (*fTypeConversionConvert)(TypeConversion * conversion, ChannelValueRef * dest, void * src);
+typedef McxStatus (*fTypeConversionConvert)(TypeConversion * conversion, ChannelValueReference * dest, void * src);
 
 extern const struct ObjectClass _TypeConversion;
 
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index d47ca47..f90d626 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -279,16 +279,16 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         ConnectionInfo * connInfo = &conn->info;
         TypeConversion * typeConv = (TypeConversion *) in->data->typeConversions->At(in->data->typeConversions, i);
         UnitConversion * unitConv = (UnitConversion *) in->data->unitConversions->At(in->data->unitConversions, i);
-        ChannelValueRef * valueRef = (ChannelValueRef *) in->data->valueReferences->At(in->data->valueReferences, i);
+        ChannelValueReference * valueRef = (ChannelValueReference *) in->data->valueReferences->At(in->data->valueReferences, i);
 
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
             return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "UpdateToOutput failed");
         }
 
-        // TODO: ideally make conn->GetValueReference return ChannelValueRef
-        if (RETURN_OK != ChannelValueRefSetFromReference(valueRef, conn->GetValueReference(conn), conn->GetValueDimension(conn), typeConv)) {
-            return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "ChannelValueRefSetFromReference failed");
+        // TODO: ideally make conn->GetValueReference return ChannelValueReference
+        if (RETURN_OK != ChannelValueReferenceSetFromPointer(valueRef, conn->GetValueReference(conn), conn->GetValueDimension(conn), typeConv)) {
+            return ReportConnStringError(info, "Update inport for connection %s: ", connInfo, "ChannelValueReferenceSetFromPointer failed");
         }
 
         // unit conversion
@@ -424,7 +424,7 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
     ConnectionInfo * connInfo = &connection->info;
     Channel * channel = (Channel *) in;
     ChannelInfo * inInfo = &channel->info;
-    ChannelValueRef * valRef = NULL;
+    ChannelValueReference * valRef = NULL;
 
     McxStatus retVal = RETURN_OK;
 
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 6fa0e6c..857aa29 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -16,7 +16,7 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-void DestroyChannelValueReference(ChannelValueRef * ref) {
+void DestroyChannelValueReference(ChannelValueReference * ref) {
     if (ref->type == CHANNEL_VALUE_REF_SLICE) {
         if (ref->ref.slice.dimension) {
             DestroyChannelDimension(&ref->ref.slice.dimension);
@@ -27,8 +27,8 @@ void DestroyChannelValueReference(ChannelValueRef * ref) {
 }
 
 
-ChannelValueRef * MakeChannelValueReference(ChannelValue * value, ChannelDimension * slice) {
-    ChannelValueRef * ref = (ChannelValueRef *) mcx_calloc(1, sizeof(ChannelValueRef));
+ChannelValueReference * MakeChannelValueReference(ChannelValue * value, ChannelDimension * slice) {
+    ChannelValueReference * ref = (ChannelValueReference *) mcx_calloc(1, sizeof(ChannelValueReference));
 
     if (!ref) {
         return NULL;
@@ -47,18 +47,18 @@ ChannelValueRef * MakeChannelValueReference(ChannelValue * value, ChannelDimensi
 }
 
 
-McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, ChannelDimension * srcDimension, TypeConversion * conv) {
+McxStatus ChannelValueReferenceSetFromPointer(ChannelValueReference * ref, const void * ptr, ChannelDimension * srcDimension, TypeConversion * conv) {
     if (conv) {
-        return conv->Convert(conv, ref, reference);
+        return conv->Convert(conv, ref, ptr);
     }
 
     if (ref->type == CHANNEL_VALUE_REF_VALUE) {
         if (ChannelTypeIsArray(ref->ref.value->type)) {
             mcx_array * destArray = &ref->ref.value->value.a;
-            mcx_array * srcArray = (mcx_array *) reference;
+            mcx_array * srcArray = (mcx_array *) ptr;
 
             if (srcArray->data == NULL || destArray->data == NULL) {
-                mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Empty array data given");
+                mcx_log(LOG_ERROR, "ChannelValueReferenceSetFromPointer: Empty array data given");
                 return RETURN_ERROR;
             }
 
@@ -87,10 +87,10 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
             return RETURN_OK;
         } else {
             if (srcDimension) {
-                mcx_array * src = (mcx_array *) (reference);
+                mcx_array * src = (mcx_array *) (ptr);
 
                 if (ChannelDimensionNumElements(srcDimension) != 1) {
-                    mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Setting scalar value from an array");
+                    mcx_log(LOG_ERROR, "ChannelValueReferenceSetFromPointer: Setting scalar value from an array");
                     return RETURN_ERROR;
                 }
 
@@ -99,18 +99,18 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
                     ref->ref.value->type,
                     mcx_array_get_elem_reference(src, ChannelDimensionGetIndex(srcDimension, 0, src->dims)));
             } else {
-                return ChannelValueDataSetFromReference(&ref->ref.value->value, ref->ref.value->type, reference);
+                return ChannelValueDataSetFromReference(&ref->ref.value->value, ref->ref.value->type, ptr);
             }
         }
     } else {
         if (ChannelTypeIsArray(ref->ref.slice.ref->type)) {
             mcx_array * destArray = &ref->ref.slice.ref->value.a;
-            mcx_array * srcArray = (mcx_array *) reference;
+            mcx_array * srcArray = (mcx_array *) ptr;
 
             ChannelDimension * destDimension = ref->ref.slice.dimension;
 
             if (srcArray->data == NULL || destArray->data == NULL) {
-                mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Empty array data given");
+                mcx_log(LOG_ERROR, "ChannelValueReferenceSetFromPointer: Empty array data given");
                 return RETURN_ERROR;
             }
 
@@ -143,10 +143,10 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
             return RETURN_OK;
         } else {
             if (srcDimension) {
-                mcx_array * src = (mcx_array *) (reference);
+                mcx_array * src = (mcx_array *) (ptr);
 
                 if (ChannelDimensionNumElements(srcDimension) != 1) {
-                    mcx_log(LOG_ERROR, "ChannelValueRefSetFromReference: Setting scalar value from an array");
+                    mcx_log(LOG_ERROR, "ChannelValueReferenceSetFromPointer: Setting scalar value from an array");
                     return RETURN_ERROR;
                 }
 
@@ -155,7 +155,7 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
                     ref->ref.slice.ref->type,
                     mcx_array_get_elem_reference(src, ChannelDimensionGetIndex(srcDimension, 0, src->dims)));
             } else {
-                return ChannelValueDataSetFromReference(&ref->ref.slice.ref->value, ref->ref.slice.ref->type, reference);
+                return ChannelValueDataSetFromReference(&ref->ref.slice.ref->value, ref->ref.slice.ref->type, ptr);
             }
         }
     }
@@ -163,7 +163,7 @@ McxStatus ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * re
     return RETURN_OK;
 }
 
-McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapFunc fn, void * ctx) {
+McxStatus ChannelValueReferenceElemMap(ChannelValueReference * ref, fChannelValueReferenceElemMapFunc fn, void * ctx) {
     switch (ref->type) {
         case CHANNEL_VALUE_REF_VALUE:
             if (ChannelTypeIsArray(ref->ref.value->type)) {
@@ -206,12 +206,12 @@ McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapF
                 return fn(ChannelValueDataPointer(ref->ref.slice.ref), 0, ChannelValueType(ref->ref.slice.ref), ctx);
             }
         default:
-            mcx_log(LOG_ERROR, "ChannelValueRefElemMap: Invalid internal channel value reference type (%d)", ref->type);
+            mcx_log(LOG_ERROR, "ChannelValueReferenceElemMap: Invalid internal channel value reference type (%d)", ref->type);
             return RETURN_ERROR;
     }
 }
 
-ChannelType * ChannelValueRefGetType(ChannelValueRef * ref) {
+ChannelType * ChannelValueReferenceGetType(ChannelValueReference * ref) {
     switch (ref->type) {
         case CHANNEL_VALUE_REF_VALUE:
             return ChannelValueType(ref->ref.value);
diff --git a/src/core/channels/ChannelValueReference.h b/src/core/channels/ChannelValueReference.h
index 166b531..10ea9bd 100644
--- a/src/core/channels/ChannelValueReference.h
+++ b/src/core/channels/ChannelValueReference.h
@@ -33,25 +33,25 @@ typedef enum ChannelValueRefType {
 } ChannelValueRefType;
 
 
-typedef struct ChannelValueRef {
+typedef struct ChannelValueReference {
     ChannelValueRefType type;
     union {
         ChannelValue * value;
         ArraySlice slice;
     } ref;
-} ChannelValueRef;
+} ChannelValueReference;
 
 
-ChannelValueRef * MakeChannelValueReference(ChannelValue * value, ChannelDimension * slice);
-void DestroyChannelValueReference(ChannelValueRef * ref);
+ChannelValueReference * MakeChannelValueReference(ChannelValue * value, ChannelDimension * slice);
+void DestroyChannelValueReference(ChannelValueReference * ref);
 
 
 McxStatus
-ChannelValueRefSetFromReference(ChannelValueRef * ref, const void * reference, ChannelDimension * srcDimension, TypeConversion * typeConv);
-ChannelType * ChannelValueRefGetType(ChannelValueRef * ref);
+ChannelValueReferenceSetFromPointer(ChannelValueReference * ref, const void * ptr, ChannelDimension * srcDimension, TypeConversion * typeConv);
+ChannelType * ChannelValueReferenceGetType(ChannelValueReference * ref);
 
-typedef McxStatus (*fChannelValueRefElemMapFunc)(void * element, size_t idx, ChannelType * type, void * ctx);
-McxStatus ChannelValueRefElemMap(ChannelValueRef * ref, fChannelValueRefElemMapFunc fn, void * ctx);
+typedef McxStatus (*fChannelValueReferenceElemMapFunc)(void * element, size_t idx, ChannelType * type, void * ctx);
+McxStatus ChannelValueReferenceElemMap(ChannelValueReference * ref, fChannelValueReferenceElemMapFunc fn, void * ctx);
 
 
 #ifdef __cplusplus
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index ab15f46..ccb00cb 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1146,7 +1146,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
     ChannelInfo * inInfo = &in->info;
     ChannelInfo * outInfo = &out->info;
 
-    ChannelValueRef * storeRef = NULL;
+    ChannelValueReference * storeRef = NULL;
 
     McxStatus retVal = RETURN_OK;
 
@@ -1201,7 +1201,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             }
         }
 
-        retVal = ChannelValueRefSetFromReference(storeRef, ChannelValueDataPointer(inChannelValue), srcDim, typeConv);
+        retVal = ChannelValueReferenceSetFromPointer(storeRef, ChannelValueDataPointer(inChannelValue), srcDim, typeConv);
         if (RETURN_ERROR == retVal) {
             mcx_log(LOG_ERROR, "Could not set up initial value in connection");
             goto cleanup_1;
@@ -1231,7 +1231,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
             goto cleanup;
         }
 
-        ChannelValueRefSetFromReference(storeRef, ChannelValueDataPointer(outInfo->initialValue), targetDim, NULL);
+        ChannelValueReferenceSetFromPointer(storeRef, ChannelValueDataPointer(outInfo->initialValue), targetDim, NULL);
         connection->useInitialValue_ = TRUE;
     } else {
         {
@@ -1270,7 +1270,7 @@ static void ConnectionInitUpdateFrom(Connection * connection, TimeInterval * tim
 static McxStatus ConnectionInitSetToStore(Connection * connection) {
     Channel* channel = (Channel*)connection->out_;
     ChannelInfo* info = &channel->info;
-    ChannelValueRef * storeRef = MakeChannelValueReference(&connection->store_, NULL);
+    ChannelValueReference * storeRef = MakeChannelValueReference(&connection->store_, NULL);
     McxStatus retVal = RETURN_OK;
 
     if (!storeRef) {
@@ -1281,7 +1281,7 @@ static McxStatus ConnectionInitSetToStore(Connection * connection) {
     ConnectionInfo * connInfo = connection->GetInfo(connection);
     ChannelDimension * clone = CloneChannelDimension(connInfo->sourceDimension);
     ChannelDimensionAlignIndicesWithZero(clone, info->dimension);
-    retVal = ChannelValueRefSetFromReference(storeRef, channel->GetValueReference(channel), clone, NULL);
+    retVal = ChannelValueReferenceSetFromPointer(storeRef, channel->GetValueReference(channel), clone, NULL);
     if (RETURN_ERROR == retVal) {
         goto cleanup;
     }

From cfbee10775276bbdd5f426e41a065cbf976d7b9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 28 Jun 2022 15:04:35 +0200
Subject: [PATCH 135/166] Make sure DirectConnection has the correct store size

---
 src/core/connections/Connection.c | 25 ++++++++++++++++++++-----
 src/core/connections/Connection.h |  6 ++++++
 2 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index ccb00cb..f689b11 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1401,7 +1401,6 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
 
     Channel * chOut = (Channel *) out;
     ChannelInfo * outInfo = &chOut->info;
-    ChannelType * storeType = NULL;
 
     connection->out_  = out;
     connection->in_   = in;
@@ -1412,13 +1411,14 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
 
     connection->info = *info;
 
-    storeType = ChannelTypeFromDimension(outInfo->type, info->sourceDimension);
-    if (!storeType) {
+    retVal = connection->SetupStore(connection, out, in, info);
+    if (RETURN_ERROR == retVal) {
+        char * buffer = ConnectionInfoConnectionString(info);
+        mcx_log(LOG_ERROR, "Connection %s: Store setup failed", buffer);
+        mcx_free(buffer);
         return RETURN_ERROR;
     }
 
-    ChannelValueInit(&connection->store_, storeType);
-
     // Add connection to channel out
     retVal = out->RegisterConnection(out, connection);
     if (RETURN_OK != retVal) {
@@ -1439,10 +1439,25 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
     return RETURN_OK;
 }
 
+McxStatus ConnectionSetupStore(Connection * connection, ChannelOut * out, ChannelIn * in, ConnectionInfo * info) {
+    Channel * chOut = (Channel *) out;
+    ChannelInfo * outInfo = &chOut->info;
+    ChannelType * storeType = ChannelTypeFromDimension(outInfo->type, info->sourceDimension);
+
+    if (!storeType) {
+        return RETURN_ERROR;
+    }
+
+    ChannelValueInit(&connection->store_, storeType);
+
+    return RETURN_OK;
+}
+
 static Connection * ConnectionCreate(Connection * connection) {
     McxStatus retVal = RETURN_OK;
 
     connection->Setup = NULL;
+    connection->SetupStore = ConnectionSetupStore;
 
     connection->GetSource = ConnectionGetSource;
     connection->GetTarget = ConnectionGetTarget;
diff --git a/src/core/connections/Connection.h b/src/core/connections/Connection.h
index bd07776..1e54b67 100644
--- a/src/core/connections/Connection.h
+++ b/src/core/connections/Connection.h
@@ -45,6 +45,10 @@ typedef McxStatus (* fConnectionSetup)(Connection * channel,
                                        struct ChannelOut        * out,
                                        struct ChannelIn         * in,
                                        struct ConnectionInfo    * info);
+typedef McxStatus (* fConnectionSetupStore)(Connection * conn,
+                                            struct ChannelOut * out,
+                                            struct ChannelIn * in,
+                                            struct ConnectionInfo * info);
 
 typedef struct ChannelOut * (* fConnectionGetSource)(Connection * connection);
 typedef struct ChannelIn  * (* fConnectionGetTarget)(Connection * connection);
@@ -119,6 +123,8 @@ struct Connection {
      */
     fConnectionSetup Setup;
 
+    fConnectionSetupStore SetupStore;
+
     /**
      * Returns the source out channel.
      */

From 6832d171391b8c91db585da2f7c6db4a98fce2b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Tue, 28 Jun 2022 16:25:08 +0200
Subject: [PATCH 136/166] ConnectionInfo: free dimensions

---
 src/core/Model.c                             |  4 ++--
 src/core/channels/ChannelDimension.c         |  8 +++-----
 src/core/channels/ChannelDimension.h         |  2 +-
 src/core/channels/ChannelValueReference.c    |  2 +-
 src/core/connections/Connection.c            |  6 +++++-
 src/core/connections/ConnectionInfo.c        | 16 ++++++++++++++++
 src/core/connections/ConnectionInfo.h        |  2 ++
 src/core/connections/ConnectionInfoFactory.c | 10 +++++-----
 8 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/src/core/Model.c b/src/core/Model.c
index 7c0ff98..58c5310 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -168,7 +168,7 @@ static McxStatus ModelPreprocessConstConnections(Model * model) {
         mcx_log(LOG_ERROR, "Not enough memory to filter out constant connections");
         return RETURN_ERROR;
     }
-    filteredConns->Setup(filteredConns, sizeof(ConnectionInfo), ConnectionInfoInit, NULL, NULL);
+    filteredConns->Setup(filteredConns, sizeof(ConnectionInfo), ConnectionInfoInit, ConnectionInfoSetFrom, DestroyConnectionInfo);
 
     for (i = 0; i < conns->Size(conns); i++) {
         ConnectionInfo * info = (ConnectionInfo *) conns->At(conns, i);
@@ -1716,7 +1716,7 @@ static Model * ModelCreate(Model * model) {
     // set to default values
     model->components = (ObjectContainer *) object_create(ObjectContainer);
     model->connections = (Vector *) object_create(Vector);
-    model->connections->Setup(model->connections, sizeof(ConnectionInfo), ConnectionInfoInit, NULL, NULL);
+    model->connections->Setup(model->connections, sizeof(ConnectionInfo), ConnectionInfoInit, ConnectionInfoSetFrom, DestroyConnectionInfo);
     model->factory = NULL;
 
     model->config = NULL;
diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index f86c675..41b03f9 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -319,11 +319,9 @@ ChannelDimension * MakeChannelDimension() {
     return dimension;
 }
 
-void DestroyChannelDimension(ChannelDimension ** dimension) {
-    if ((*dimension)->startIdxs) { mcx_free((*dimension)->startIdxs); }
-    if ((*dimension)->endIdxs) { mcx_free((*dimension)->endIdxs); }
-
-    *dimension = NULL;
+void DestroyChannelDimension(ChannelDimension * dimension) {
+    if (dimension->startIdxs) { mcx_free(dimension->startIdxs); }
+    if (dimension->endIdxs) { mcx_free(dimension->endIdxs); }
 }
 
 
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 0fdbf0d..7398fd6 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -30,7 +30,7 @@ typedef struct ChannelDimension {
 
 ChannelDimension * MakeChannelDimension();
 ChannelDimension * CloneChannelDimension(const ChannelDimension * dimension);
-void DestroyChannelDimension(ChannelDimension ** dimension);
+void DestroyChannelDimension(ChannelDimension * dimension);
 
 McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num);
 McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end);
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 857aa29..0279779 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -19,7 +19,7 @@ extern "C" {
 void DestroyChannelValueReference(ChannelValueReference * ref) {
     if (ref->type == CHANNEL_VALUE_REF_SLICE) {
         if (ref->ref.slice.dimension) {
-            DestroyChannelDimension(&ref->ref.slice.dimension);
+            DestroyChannelDimension(ref->ref.slice.dimension);
         }
     }
 
diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index f689b11..ac28c78 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1097,6 +1097,7 @@ static ChannelType * ConnectionGetValueType(Connection * connection) {
 
 static void ConnectionDestructor(Connection * connection) {
     ChannelValueDestructor(&connection->store_);
+    DestroyConnectionInfo(&connection->info);
 }
 
 static ChannelOut * ConnectionGetSource(Connection * connection) {
@@ -1409,7 +1410,10 @@ McxStatus ConnectionSetup(Connection * connection, ChannelOut * out, ChannelIn *
         info->hasDiscreteTarget = TRUE;
     }
 
-    connection->info = *info;
+    retVal = ConnectionInfoSetFrom(&connection->info, info);
+    if (RETURN_ERROR == retVal) {
+        return RETURN_ERROR;
+    }
 
     retVal = connection->SetupStore(connection, out, in, info);
     if (RETURN_ERROR == retVal) {
diff --git a/src/core/connections/ConnectionInfo.c b/src/core/connections/ConnectionInfo.c
index eec8b3b..4a4ae3c 100644
--- a/src/core/connections/ConnectionInfo.c
+++ b/src/core/connections/ConnectionInfo.c
@@ -137,6 +137,22 @@ char * ConnectionInfoConnectionString(ConnectionInfo * info) {
     return buffer;
 }
 
+void DestroyConnectionInfo(ConnectionInfo * info) {
+    if (info->sourceDimension) { DestroyChannelDimension(info->sourceDimension); }
+    if (info->targetDimension) { DestroyChannelDimension(info->targetDimension); }
+}
+
+McxStatus ConnectionInfoSetFrom(ConnectionInfo * info, const ConnectionInfo * other) {
+    McxStatus retVal = RETURN_OK;
+
+    memcpy(info, other, sizeof(ConnectionInfo));
+
+    info->sourceDimension = CloneChannelDimension(other->sourceDimension);
+    info->targetDimension = CloneChannelDimension(other->targetDimension);
+
+    return RETURN_OK;
+}
+
 McxStatus ConnectionInfoInit(ConnectionInfo * info) {
     info->sourceComponent = NULL;
     info->targetComponent = NULL;
diff --git a/src/core/connections/ConnectionInfo.h b/src/core/connections/ConnectionInfo.h
index 8d9a171..7b27627 100644
--- a/src/core/connections/ConnectionInfo.h
+++ b/src/core/connections/ConnectionInfo.h
@@ -55,6 +55,8 @@ typedef struct ConnectionInfo {
 
 
 McxStatus ConnectionInfoInit(ConnectionInfo * info);
+McxStatus ConnectionInfoSetFrom(ConnectionInfo * info, const ConnectionInfo * other);
+void DestroyConnectionInfo(ConnectionInfo * info);
 
 
 ChannelType * ConnectionInfoGetType(ConnectionInfo * info);
diff --git a/src/core/connections/ConnectionInfoFactory.c b/src/core/connections/ConnectionInfoFactory.c
index 1e73034..9f0ef0b 100644
--- a/src/core/connections/ConnectionInfoFactory.c
+++ b/src/core/connections/ConnectionInfoFactory.c
@@ -126,14 +126,14 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             if (RETURN_OK != ChannelDimensionSetup(sourceDimension, 1)) {
                 mcx_log(LOG_ERROR, "Source port %s: Could not set number of dimensions", strFromChannel);
                 retVal = RETURN_ERROR;
-                DestroyChannelDimension(&sourceDimension);
+                DestroyChannelDimension(sourceDimension);
                 goto cleanup;
             }
 
             if (RETURN_OK != ChannelDimensionSetDimension(sourceDimension, 0, connInput->from.vectorEndpoint->startIndex, connInput->from.vectorEndpoint->endIndex)) {
                 mcx_log(LOG_ERROR, "Source port %s: Could not set dimension boundaries", strFromChannel);
                 retVal = RETURN_ERROR;
-                DestroyChannelDimension(&sourceDimension);
+                DestroyChannelDimension(sourceDimension);
                 goto cleanup;
             }
 
@@ -212,7 +212,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             if (RETURN_OK != ChannelDimensionSetup(targetDimension, 1)) {
                 mcx_log(LOG_ERROR, "Target port %s: Could not set number of dimensions", strToChannel);
                 retVal = RETURN_ERROR;
-                DestroyChannelDimension(&targetDimension);
+                DestroyChannelDimension(targetDimension);
                 goto cleanup;
             }
 
@@ -223,7 +223,7 @@ static McxStatus ConnectionInfoFactoryInitConnectionInfo(ConnectionInfo * info,
             {
                 mcx_log(LOG_ERROR, "Target port %s: Could not set dimension boundaries", strToChannel);
                 retVal = RETURN_ERROR;
-                DestroyChannelDimension(&targetDimension);
+                DestroyChannelDimension(targetDimension);
                 goto cleanup;
             }
 
@@ -358,7 +358,7 @@ Vector * ConnectionInfoFactoryCreateConnectionInfos(
         goto cleanup;
     }
 
-    list->Setup(list, sizeof(ConnectionInfo), ConnectionInfoInit, NULL, NULL);
+    list->Setup(list, sizeof(ConnectionInfo), ConnectionInfoInit, ConnectionInfoSetFrom, DestroyConnectionInfo);
 
     retVal = ConnectionInfoFactoryInitConnectionInfo(&info, components, connInput, sourceCompOverride, targetCompOverride);
     if (RETURN_ERROR == retVal) {

From 3a0fe55078e36b0f0af19fdc22e2ce0fda8ca408 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 29 Jun 2022 11:59:33 +0200
Subject: [PATCH 137/166] GetInConnectionInfos: Use Vector instead of
 ObjectContainer

---
 src/core/Component.c        |  2 +-
 src/core/Component.h        |  3 ++-
 src/core/SubModel.c         | 13 +++++++++----
 src/core/channels/Channel.c |  8 +++++---
 src/core/channels/Channel.h |  2 +-
 src/fmu/common_fmu2.c       |  5 +++--
 6 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/src/core/Component.c b/src/core/Component.c
index 427e7e5..876f99f 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -840,7 +840,7 @@ static void ComponentSetModel(Component * comp, Model * model) {
     comp->data->model = model;
 }
 
-ObjectContainer * GetInConnectionInfos(const Component * comp, size_t channelID) {
+Vector * GetInConnectionInfos(const Component * comp, size_t channelID) {
     size_t channelNum = DatabusInfoGetChannelNum(DatabusGetInInfo(comp->data->databus));
 
     if (channelID < channelNum) {
diff --git a/src/core/Component.h b/src/core/Component.h
index 8abede0..3e1493a 100644
--- a/src/core/Component.h
+++ b/src/core/Component.h
@@ -16,6 +16,7 @@
 #include "core/Component_interface.h"
 #include "core/Dependency.h"
 #include "objects/StringContainer.h"
+#include "objects/Vector.h"
 #include "reader/model/components/ComponentInput.h"
 #include "core/connections/ConnectionInfo.h"
 
@@ -250,7 +251,7 @@ McxStatus ComponentDoCommunicationStep(Component * comp, size_t group, struct St
 McxStatus ComponentEnterCommunicationPoint(Component * comp, TimeInterval * time);
 McxStatus ComponentEnterCommunicationPointForConnections(Component * comp, ObjectList * connections, TimeInterval * time);
 
-struct ObjectContainer * GetInConnectionInfos(const Component * comp, size_t channelID);
+Vector * GetInConnectionInfos(const Component * comp, size_t channelID);
 struct ObjectContainer * GetInConnections(const Component * comp, size_t channelID);
 
 size_t ComponentGetNumOutGroups(const Component * comp);
diff --git a/src/core/SubModel.c b/src/core/SubModel.c
index c2315d9..c2999e0 100644
--- a/src/core/SubModel.c
+++ b/src/core/SubModel.c
@@ -689,7 +689,7 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
                 // initial inputs are always exact
                 if (info->initialValue) {
                     //check if connection exists (cosim init values are not deoupling connections, they only have lower priority than connection values)
-                    ObjectContainer * infos = GetInConnectionInfos(targetComp, targetInChannelID);
+                    Vector * infos = GetInConnectionInfos(targetComp, targetInChannelID);
                     size_t numInfos = infos->Size(infos);
                     size_t i = 0;
 
@@ -698,8 +698,9 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
                     } else {
                         int allDecoupled = TRUE;
                         for (i = 0; i < numInfos; i++) {
-                            ConnectionInfo * info = (ConnectionInfo *) infos->At(infos, i);
+                            ConnectionInfo * info = *(ConnectionInfo**) infos->At(infos, i);
                             if (!ConnectionInfoIsDecoupled(info)) {
+                                object_destroy(infos);
                                 allDecoupled = FALSE;
                                 break;
                             }
@@ -709,16 +710,17 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
                             dependency = DEP_INDEPENDENT;
                         }
                     }
+                    object_destroy(infos);
                 }
             }
 
             if (DEP_INDEPENDENT != dependency) {
-                ObjectContainer * infos = GetInConnectionInfos(targetComp, targetInChannelID);
+                Vector * infos = GetInConnectionInfos(targetComp, targetInChannelID);
                 ObjectContainer * conns = GetInConnections(targetComp, targetInChannelID);
                 size_t i = 0;
 
                 for (i = 0; i < infos->Size(infos); i++) {
-                    ConnectionInfo * info = infos->At(infos, i);
+                    ConnectionInfo * info = *(ConnectionInfo**) infos->At(infos, i);
                     Connection * conn = conns->At(conns, i);
 
                     if (info && (info->decoupleType & (DECOUPLE_NEVER | DECOUPLE_IFNEEDED)) && (!ConnectionInfoIsDecoupled(info)) &&
@@ -760,6 +762,7 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
                         if (RETURN_ERROR == retVal) {
                             mcx_log(LOG_ERROR, "SetDependency failed in SubModelGeneratorCreateDependencyMatrix");
                             mcx_free(A);
+                            object_destroy(infos);
                             return NULL;
                         }
 
@@ -779,6 +782,8 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
                         }
                     }
                 }
+
+                object_destroy(infos);
             }
         }
         if (targetCompDependency) {
diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index f90d626..09ade87 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -395,8 +395,8 @@ static int ChannelInIsConnected(Channel * channel) {
     return FALSE;
 }
 
-static ObjectContainer * ChannelInGetConnectionInfos(ChannelIn * in) {
-    ObjectContainer * infos = (ObjectContainer *) object_create(ObjectContainer);
+static Vector * ChannelInGetConnectionInfos(ChannelIn * in) {
+    Vector * infos = (Vector*) object_create(Vector);
     size_t numConns = in->data->connections->Size(in->data->connections);
     size_t i = 0;
 
@@ -404,10 +404,12 @@ static ObjectContainer * ChannelInGetConnectionInfos(ChannelIn * in) {
         return NULL;
     }
 
+    infos->Setup(infos, sizeof(ConnectionInfo*), NULL, NULL, NULL);
+
     for (i = 0; i < numConns; i++) {
         Connection * conn = in->data->connections->At(in->data->connections, i);
         ConnectionInfo * connInfo = &conn->info;
-        if (RETURN_ERROR == infos->PushBack(infos, (Object *) connInfo)) {
+        if (RETURN_ERROR == infos->PushBack(infos, &connInfo)) {
             object_destroy(infos);
             return NULL;
         }
diff --git a/src/core/channels/Channel.h b/src/core/channels/Channel.h
index dbebf8d..52d45d3 100644
--- a/src/core/channels/Channel.h
+++ b/src/core/channels/Channel.h
@@ -122,7 +122,7 @@ typedef McxStatus  (* fChannelInSetReference) (ChannelIn   * in,
                                                void        * reference,
                                                ChannelType * type);
 
-typedef struct ObjectContainer * (* fChannelInGetConnectionInfos)(ChannelIn * in);
+typedef struct Vector * (* fChannelInGetConnectionInfos)(ChannelIn * in);
 
 typedef struct ObjectContainer * (* fChannelInGetConnections)(ChannelIn * in);
 
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 6e3fc40..3a07319 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -796,9 +796,9 @@ McxStatus Fmu2SetDependencies(Fmu2CommonStruct * fmu2, Databus * db, Dependencie
                 }
 
                 // if an element index appears in elems, it means that element is connected
-                ObjectContainer * connInfos = in->GetConnectionInfos(in);
+                Vector * connInfos = in->GetConnectionInfos(in);
                 for (j = 0; j < connInfos->Size(connInfos); j++) {
-                    ConnectionInfo * connInfo = (ConnectionInfo *) connInfos->At(connInfos, j);
+                    ConnectionInfo * connInfo = *(ConnectionInfo**) connInfos->At(connInfos, j);
                     size_t k = 0;
 
                     for (k = 0; k < ChannelDimensionNumElements(connInfo->targetDimension); k++) {
@@ -806,6 +806,7 @@ McxStatus Fmu2SetDependencies(Fmu2CommonStruct * fmu2, Databus * db, Dependencie
                         in_channel_connectivity[i].elems[in_channel_connectivity[i].num_elems++] = idx;
                     }
                 }
+                object_destroy(connInfos);
             } else {
                 in_channel_connectivity[i].is_connected = TRUE;
                 // scalar channels are treated like they have 1 element (equal to zero)

From 31c26d3f41e11a0e9c1abf53acb1e2a64676d590 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 29 Jun 2022 12:35:56 +0200
Subject: [PATCH 138/166] Make sure to provide a type clone to ChannelValueInit

---
 src/components/comp_vector_integrator.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 102f9ab..77bc342 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -77,8 +77,8 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
             return RETURN_ERROR;
         }
 
-        ChannelValueInit(&integrator->deriv[i], type);
-        ChannelValueInit(&integrator->state[i], type);
+        ChannelValueInit(&integrator->deriv[i], ChannelTypeClone(type));
+        ChannelValueInit(&integrator->state[i], ChannelTypeClone(type));
     }
 
     return RETURN_OK;

From 7e988a5869a9f6c9a1aaac5f825d76451af805c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 29 Jun 2022 13:08:06 +0200
Subject: [PATCH 139/166] Use Vector to store ChannelValueReferences

---
 src/core/channels/Channel.c      | 11 ++++++++---
 src/core/channels/Channel_impl.h |  2 +-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 09ade87..19bc76d 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -154,6 +154,9 @@ static Channel * ChannelCreate(Channel * channel) {
 // object that is stored in target component that stores
 // the channel connection
 
+static void DestroyChannelValueReferencePtr(ChannelValueReference ** ptr) {
+    DestroyChannelValueReference(*ptr);
+}
 
 static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
     data->connections = (ObjectContainer *) object_create(ObjectContainer);
@@ -161,11 +164,13 @@ static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
         return NULL;
     }
 
-    data->valueReferences = (ObjectContainer *) object_create(ObjectContainer);
+    data->valueReferences = (Vector *) object_create(Vector);
     if (!data->valueReferences) {
         return NULL;
     }
 
+    data->valueReferences->Setup(data->valueReferences, sizeof(ChannelValueReference *), NULL, NULL, DestroyChannelValueReferencePtr);
+
     data->reference  = NULL;
     data->type = ChannelTypeClone(&ChannelTypeUnknown);
 
@@ -279,7 +284,7 @@ static McxStatus ChannelInUpdate(Channel * channel, TimeInterval * time) {
         ConnectionInfo * connInfo = &conn->info;
         TypeConversion * typeConv = (TypeConversion *) in->data->typeConversions->At(in->data->typeConversions, i);
         UnitConversion * unitConv = (UnitConversion *) in->data->unitConversions->At(in->data->unitConversions, i);
-        ChannelValueReference * valueRef = (ChannelValueReference *) in->data->valueReferences->At(in->data->valueReferences, i);
+        ChannelValueReference * valueRef = *(ChannelValueReference **) in->data->valueReferences->At(in->data->valueReferences, i);
 
         /* Update the connection for the current time */
         if (RETURN_OK != conn->UpdateToOutput(conn, time)) {
@@ -453,7 +458,7 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
         valRef = MakeChannelValueReference(&channel->value, NULL);
     }
 
-    retVal = in->data->valueReferences->PushBack(in->data->valueReferences, (Object *) valRef);
+    retVal = in->data->valueReferences->PushBack(in->data->valueReferences, &valRef);
     // TODO check retVal
 
     if (ChannelTypeEq(ChannelTypeBaseType(inInfo->type), &ChannelTypeDouble)) {
diff --git a/src/core/channels/Channel_impl.h b/src/core/channels/Channel_impl.h
index e594a78..2b330e6 100644
--- a/src/core/channels/Channel_impl.h
+++ b/src/core/channels/Channel_impl.h
@@ -29,7 +29,7 @@ typedef struct ChannelInData {
     Object _; // base class
 
     ObjectContainer * connections;      // connections (non-overlapping) going into the channel
-    ObjectContainer * valueReferences;  // references to non-overlapping parts of ChannelData::value, where
+    Vector * valueReferences;           // references to non-overlapping parts of ChannelData::value, where
                                         // values gotten from connections are going to be stored
 
     // ----------------------------------------------------------------------

From aef1a3bc3faf3e6e15a3b78aebc5103abd339764 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 29 Jun 2022 15:01:36 +0200
Subject: [PATCH 140/166] Get rid of TODOs

---
 src/core/channels/Channel.c               | 20 +++++++++++++-------
 src/core/channels/ChannelValue.h          |  1 -
 src/core/channels/ChannelValueReference.c |  1 -
 3 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/core/channels/Channel.c b/src/core/channels/Channel.c
index 19bc76d..73f945a 100644
--- a/src/core/channels/Channel.c
+++ b/src/core/channels/Channel.c
@@ -190,8 +190,6 @@ static ChannelInData * ChannelInDataCreate(ChannelInData * data) {
     return data;
 }
 
-// TODO fix Create and Destructor to properly free memory in case of failure
-
 static void ChannelInDataDestructor(ChannelInData * data) {
     // clean up conversion objects
     data->typeConversions->DestroyObjects(data->typeConversions);
@@ -210,7 +208,13 @@ static void ChannelInDataDestructor(ChannelInData * data) {
         ChannelTypeDestructor(data->type);
     }
 
-    // TODO destroy connections/valueReference ????
+    if (data->connections) {
+        object_destroy(data->connections);
+    }
+
+    if (data->valueReferences) {
+        object_destroy(data->valueReferences);
+    }
 }
 
 OBJECT_CLASS(ChannelInData, Object);
@@ -441,9 +445,6 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
     }
 
     ChannelDimension * dimension = connInfo->targetDimension;
-    // TODO check ret values
-    // TODO do we need some plausibility checks?
-    // TODO is it fine to use connInfo here?
     if (dimension && !ChannelDimensionEq(dimension, inInfo->dimension)) {
         ChannelDimension * slice = CloneChannelDimension(dimension);
 
@@ -459,7 +460,10 @@ static McxStatus ChannelInRegisterConnection(ChannelIn * in, Connection * connec
     }
 
     retVal = in->data->valueReferences->PushBack(in->data->valueReferences, &valRef);
-    // TODO check retVal
+    if (RETURN_ERROR == retVal) {
+        ReportConnStringError(inInfo, "Register inport connection %s: ", connInfo, "Storing value reference failed");
+        return RETURN_ERROR;
+    }
 
     if (ChannelTypeEq(ChannelTypeBaseType(inInfo->type), &ChannelTypeDouble)) {
         UnitConversion * conversion = (UnitConversion *) object_create(UnitConversion);
@@ -728,6 +732,8 @@ static McxStatus ChannelOutSetup(ChannelOut * out, ChannelInfo * info, Config *
 
 static McxStatus ChannelOutRegisterConnection(ChannelOut * out, Connection * connection) {
     ObjectList * conns = out->data->connections;
+    ChannelDimension * outDim = ((Channel*)out)->info.dimension;
+    ChannelDimension * connDim = connection->info.sourceDimension;
 
     // TODO: do we have to check that channelout and connection match
     // in type/dimension?
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 0e529b0..212aeb1 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -125,7 +125,6 @@ typedef int (*mcx_array_predicate_f_ptr)(void * element, ChannelType * type);
 int mcx_array_all(mcx_array * a, mcx_array_predicate_f_ptr predicate);
 int mcx_array_leq(const mcx_array * left, const mcx_array * right);
 
-// TODO: change concrete types to McxDouble, McxInteger, etc
 union ChannelValueData {
     /* the order is significant. double needs to be the first entry for union initialization to work */
     double d;
diff --git a/src/core/channels/ChannelValueReference.c b/src/core/channels/ChannelValueReference.c
index 0279779..152e363 100644
--- a/src/core/channels/ChannelValueReference.c
+++ b/src/core/channels/ChannelValueReference.c
@@ -216,7 +216,6 @@ ChannelType * ChannelValueReferenceGetType(ChannelValueReference * ref) {
         case CHANNEL_VALUE_REF_VALUE:
             return ChannelValueType(ref->ref.value);
         case CHANNEL_VALUE_REF_SLICE:
-            // TODO (do we need to adapt the indices wrt. dimension) ?
             return ChannelValueType(ref->ref.slice.ref);
         default:
             mcx_log(LOG_ERROR, "Invalid internal channel value reference type (%d)", ref->type);

From dcd906aeab59f1b29211bcee8b8c863676816840 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 7 Jul 2022 09:04:38 +0200
Subject: [PATCH 141/166] Rename ChannelDimensionSetDimension argument

---
 src/core/channels/ChannelDimension.c | 8 ++++----
 src/core/channels/ChannelDimension.h | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index 41b03f9..986ffc3 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -40,13 +40,13 @@ McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num) {
     return RETURN_ERROR;
 }
 
-McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end) {
-    if (num > dimension->num) {
+McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t dim, size_t start, size_t end) {
+    if (dim > dimension->num) {
         return RETURN_ERROR;
     }
 
-    dimension->startIdxs[num] = start;
-    dimension->endIdxs[num] = end;
+    dimension->startIdxs[dim] = start;
+    dimension->endIdxs[dim] = end;
 
     return RETURN_OK;
 }
diff --git a/src/core/channels/ChannelDimension.h b/src/core/channels/ChannelDimension.h
index 7398fd6..a98d6ef 100644
--- a/src/core/channels/ChannelDimension.h
+++ b/src/core/channels/ChannelDimension.h
@@ -33,7 +33,7 @@ ChannelDimension * CloneChannelDimension(const ChannelDimension * dimension);
 void DestroyChannelDimension(ChannelDimension * dimension);
 
 McxStatus ChannelDimensionSetup(ChannelDimension * dimension, size_t num);
-McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t num, size_t start, size_t end);
+McxStatus ChannelDimensionSetDimension(ChannelDimension * dimension, size_t dim, size_t start, size_t end);
 
 int ChannelDimensionEq(const ChannelDimension * first, const ChannelDimension * second);
 int ChannelDimensionConformsToDimension(const ChannelDimension * first, const ChannelDimension * second);

From 63ffb63dd2feb8dff4ab403c689baf9a6edcad6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 7 Jul 2022 09:14:54 +0200
Subject: [PATCH 142/166] Remove obsolete code

---
 src/components/comp_fmu.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/components/comp_fmu.c b/src/components/comp_fmu.c
index 982efe7..2024c88 100644
--- a/src/components/comp_fmu.c
+++ b/src/components/comp_fmu.c
@@ -381,11 +381,6 @@ static McxStatus Fmu2SetupChannelIn(ObjectContainer /* Fmu2Values */ * vals, Dat
         Fmu2Value * val = (Fmu2Value *) vals->At(vals, i);
 
         if (ch->IsConnected(ch) || ch->info.defaultValue) {
-            const char * channelName = info->nameInTool;
-            if (NULL == channelName) {
-                channelName = ChannelInfoGetName(info);
-            }
-
             val->SetChannel(val, info->channel);
 
             if (!ChannelTypeIsValid(val->val.type)) {

From b9cd4a41974550c9d46825045cbe2ce31035d4aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 7 Jul 2022 10:20:23 +0200
Subject: [PATCH 143/166] Avoid memory allocations due to C/C++ interface

---
 src/core/channels/ChannelValue.c | 28 ++++++++++++++++++++++++++++
 src/core/channels/ChannelValue.h |  1 +
 2 files changed, 29 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index c4a076f..9c21afd 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -117,6 +117,34 @@ ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dim
     return array;
 }
 
+ChannelType * ChannelTypeArrayLongDims(ChannelType * inner, size_t numDims, unsigned long * dims) {
+    ChannelType * array = NULL;
+    size_t i = 0;
+
+    if (!inner) {
+        return &ChannelTypeUnknown;
+    }
+
+    array = (ChannelType *) mcx_malloc(sizeof(ChannelType));
+    if (!array) {
+        return &ChannelTypeUnknown;
+    }
+
+    array->con = CHANNEL_ARRAY;
+    array->ty.a.inner = inner;
+    array->ty.a.numDims = numDims;
+    array->ty.a.dims = (size_t *) mcx_calloc(sizeof(size_t), numDims);
+    if (!array->ty.a.dims) {
+        return &ChannelTypeUnknown;
+    }
+
+    for (i = 0; i < numDims; i++) {
+        array->ty.a.dims[i] = dims[i];
+    }
+
+    return array;
+}
+
 ChannelType * ChannelTypeArrayInner(ChannelType * array) {
     if (!ChannelTypeIsArray(array)) {
         return &ChannelTypeUnknown;
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 212aeb1..7c8ebdd 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -57,6 +57,7 @@ extern ChannelType ChannelTypeString;
 extern ChannelType ChannelTypeBinary;
 extern ChannelType ChannelTypeBinaryReference;
 ChannelType * ChannelTypeArray(ChannelType * inner, size_t numDims, size_t * dims);
+ChannelType * ChannelTypeArrayLongDims(ChannelType * inner, size_t numDims, unsigned long * dims);
 
 ChannelType * ChannelTypeClone(ChannelType * type);
 void ChannelTypeDestructor(ChannelType * type);

From d6dc19ee317abfae08b83ecafeebdf0ede51e4e8 Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Fri, 8 Jul 2022 16:44:50 +0200
Subject: [PATCH 144/166] storage: Make utility function accessible to all
 backends

---
 src/storage/ChannelStorage.c    | 23 +++++++++++++++++++++++
 src/storage/ChannelStorage.h    |  3 +++
 src/storage/StorageBackendCsv.c | 24 +-----------------------
 3 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index e1c0f24..b885b84 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -348,6 +348,29 @@ static ChannelStorage * ChannelStorageCreate(ChannelStorage * channelStore) {
     return channelStore;
 }
 
+char ** ExpandedChannelNames(const char * name, size_t start, size_t end) {
+    char ** names = (char **) mcx_malloc(sizeof(char *) * (end - start + 1 + 1));
+    if (!names) { return NULL; }
+
+    size_t i = 0;
+
+    for (i = start; i <= end; i++) {
+        names[i-start] = CreateIndexedName(name, i);
+    }
+    names[i-start] = NULL;
+
+    return names;
+}
+
+void FreeExpandedChannelNames(char ** names) {
+    size_t i = 0;
+    while (names[i]) {
+        mcx_free(names[i]);
+        ++i;
+    }
+    mcx_free(names);
+}
+
 OBJECT_CLASS(ChannelStorage, Object);
 
 #ifdef __cplusplus
diff --git a/src/storage/ChannelStorage.h b/src/storage/ChannelStorage.h
index 481700a..3ed9e08 100644
--- a/src/storage/ChannelStorage.h
+++ b/src/storage/ChannelStorage.h
@@ -61,6 +61,9 @@ typedef struct ChannelStorage {
     size_t storeCallNum;
 } ChannelStorage;
 
+char ** ExpandedChannelNames(const char * name, size_t start, size_t end);
+void FreeExpandedChannelNames(char ** names);
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
diff --git a/src/storage/StorageBackendCsv.c b/src/storage/StorageBackendCsv.c
index 0a13c35..67e216b 100644
--- a/src/storage/StorageBackendCsv.c
+++ b/src/storage/StorageBackendCsv.c
@@ -16,6 +16,7 @@
 #include "storage/StorageBackendCsv.h"
 #include "storage/StorageBackendText_impl.h"
 #include "storage/PPD.h"
+#include "storage/ChannelStorage.h"
 #include "core/connections/ConnectionInfoFactory.h"
 
 #include "util/string.h"
@@ -183,29 +184,6 @@ static char * QuoteString(const char * _str) {
     return newStr;
 }
 
-static char * ExpandedChannelNames(const char * name, size_t start, size_t end) {
-    char ** names = (char **) mcx_malloc(sizeof(char *) * (end - start + 1 + 1));
-    if (!names) { return NULL; }
-
-    size_t i = 0;
-
-    for (i = start; i <= end; i++) {
-        names[i-start] = CreateIndexedName(name, i);
-    }
-    names[i-start] = NULL;
-
-    return names;
-}
-
-static void FreeExpandedChannelNames(char ** names) {
-    size_t i = 0;
-    while (names[i]) {
-        mcx_free(names[i]);
-        ++i;
-    }
-    mcx_free(names);
-}
-
 static McxStatus SetupComponentFilesCsv(StorageBackend * backend) {
     StorageBackendText * textBackend = (StorageBackendText *) backend;
     ResultsStorage * storage = backend->storage;

From 6cc43b214181572148e2957e175a26f783b8803f Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Fri, 15 Jul 2022 11:46:24 +0200
Subject: [PATCH 145/166] storage: Make function ANSI C compliant

---
 src/storage/ChannelStorage.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/storage/ChannelStorage.c b/src/storage/ChannelStorage.c
index b885b84..65ca204 100644
--- a/src/storage/ChannelStorage.c
+++ b/src/storage/ChannelStorage.c
@@ -349,11 +349,14 @@ static ChannelStorage * ChannelStorageCreate(ChannelStorage * channelStore) {
 }
 
 char ** ExpandedChannelNames(const char * name, size_t start, size_t end) {
-    char ** names = (char **) mcx_malloc(sizeof(char *) * (end - start + 1 + 1));
-    if (!names) { return NULL; }
-
+    char ** names = NULL;
     size_t i = 0;
 
+    names = (char **) mcx_malloc(sizeof(char *) * (end - start + 1 + 1));
+    if (!names) {
+        return NULL;
+    }
+
     for (i = start; i <= end; i++) {
         names[i-start] = CreateIndexedName(name, i);
     }

From d61a172c8b03e47f98d20d0a692b6a36b4f36939 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20Cau=C2=9Aevic?= <denis.causevic@avl.com>
Date: Fri, 29 Jul 2022 15:09:09 +0200
Subject: [PATCH 146/166] Move variables closer to the place where they are
 used

---
 src/core/channels/ChannelValue.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 9c21afd..fb8988d 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -612,9 +612,6 @@ char * ChannelValueToString(ChannelValue * value) {
         }
         break;
     case CHANNEL_ARRAY:{
-        size_t i = 0;
-        size_t n = 0;
-
         size_t (*fmt)(char * buffer, void * value, size_t i);
 
         if (ChannelTypeEq(ChannelTypeArrayInner(value->type), &ChannelTypeDouble)) {
@@ -635,6 +632,9 @@ char * ChannelValueToString(ChannelValue * value) {
         }
 
         if (mcx_array_num_elements(&value->value.a) > 0) {
+            size_t i = 0;
+            size_t n = 0;
+
             n += fmt(buffer + n, value->value.a.data, 0);
             for (i = 1; i < mcx_array_num_elements(&value->value.a); i++) {
                 n += sprintf(buffer + n, ",");

From 0c1e5cc2f639b1088fd57b51bf05ec8adc65b0e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 27 Jul 2022 13:00:47 +0200
Subject: [PATCH 147/166] Update element channels prior to exiting init mode in
 connections

---
 src/core/Model.c | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/src/core/Model.c b/src/core/Model.c
index 58c5310..076da2a 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -1363,6 +1363,35 @@ static McxStatus CompUpdateInitOutputs(CompAndGroup * compGroup, void * param) {
     return retVal;
 }
 
+static McxStatus CompUpdateInAndOutputs(CompAndGroup * compGroup, void * param) {
+    Component * comp = compGroup->comp;
+    double startTime = comp->GetTime(comp);
+    TimeInterval time = { startTime, startTime };
+    McxStatus retVal = RETURN_OK;
+
+    retVal = DatabusTriggerInConnections(comp->GetDatabus(comp), &time);
+    if (RETURN_ERROR == retVal) {
+        mcx_log(LOG_ERROR, "Model: Updating inports after initialization loop failed");
+        return RETURN_ERROR;
+    }
+
+    if (comp->UpdateInChannels) {
+        retVal = comp->UpdateInChannels(comp);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "Model: Updating inports failed");
+            return RETURN_ERROR;
+        }
+    }
+
+    retVal = ComponentUpdateOutChannels(comp, &time);
+    if (RETURN_ERROR == retVal) {
+        mcx_log(LOG_ERROR, "Model: Updating outports after initialization loop failed");
+        return RETURN_ERROR;
+    }
+
+    return retVal;
+}
+
 static McxStatus CompUpdateOutputs(CompAndGroup * compGroup, void * param) {
     Component  * comp  = compGroup->comp;
     const Task * task  = (const Task *) param;
@@ -1417,6 +1446,15 @@ static McxStatus ModelInitialize(Model * model) {
         return retVal;
     }
 
+    // Additional step for faulty elements which return zeroes as out channel values during initialization.
+    // This makes sure that after the element exits initialization (CompExitInit),
+    // the output channels contain good values before they get forwarded to the filters (ModelConnectionsExitInitMode)
+    retVal = subModel->LoopEvaluationList(subModel, CompUpdateInAndOutputs, (void*)model->task);
+    if (RETURN_ERROR == retVal) {
+        mcx_log(LOG_ERROR, "Model: Updating element channels failed");
+        return RETURN_ERROR;
+    }
+
     retVal = ModelConnectionsExitInitMode(model->components, model->task->params->time);
     if (RETURN_ERROR == retVal) {
         mcx_log(LOG_ERROR, "Model: Exiting initialization mode failed");

From 95302f6783633a2041b96707d981dcd5e5f798f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 25 Jul 2022 15:54:27 +0200
Subject: [PATCH 148/166] Make additional init step configurable via an
 environment variable

---
 src/core/Config.c | 13 +++++++++++++
 src/core/Config.h |  1 +
 src/core/Model.c  | 16 +++++++++-------
 3 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/src/core/Config.c b/src/core/Config.c
index 6842a0b..d94f3b5 100644
--- a/src/core/Config.c
+++ b/src/core/Config.c
@@ -416,6 +416,18 @@ static McxStatus ConfigSetupFromEnvironment(Config * config) {
         }
     }
 
+    {
+        char * wrongInitBehaviorDisabled = NULL;
+
+        wrongInitBehaviorDisabled = mcx_os_get_env_var("MCX_WRONG_INIT_BEHAVIOR");
+        if (wrongInitBehaviorDisabled) {
+            if (is_on(wrongInitBehaviorDisabled)) {
+                config->patchWrongInitBehavior = FALSE;
+            }
+            mcx_free(wrongInitBehaviorDisabled);
+        }
+    }
+
     {
         char * numWarnings = mcx_os_get_env_var("NUM_TIME_SNAP_WARNINGS");
         if (numWarnings) {
@@ -571,6 +583,7 @@ static Config * ConfigCreate(Config * config) {
     config->writeAllLogFile = FALSE;
 
     config->cosimInitEnabled = FALSE;
+    config->patchWrongInitBehavior = TRUE;
 
     config->maxNumTimeSnapWarnings = MAX_NUM_MSGS;
 
diff --git a/src/core/Config.h b/src/core/Config.h
index 7cd97eb..6ae1643 100644
--- a/src/core/Config.h
+++ b/src/core/Config.h
@@ -72,6 +72,7 @@ struct Config {
     size_t memFilterHistoryExtra;
 
     int cosimInitEnabled;
+    int patchWrongInitBehavior;
 
     int profilingMode;
 
diff --git a/src/core/Model.c b/src/core/Model.c
index 076da2a..719ea46 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -1446,13 +1446,15 @@ static McxStatus ModelInitialize(Model * model) {
         return retVal;
     }
 
-    // Additional step for faulty elements which return zeroes as out channel values during initialization.
-    // This makes sure that after the element exits initialization (CompExitInit),
-    // the output channels contain good values before they get forwarded to the filters (ModelConnectionsExitInitMode)
-    retVal = subModel->LoopEvaluationList(subModel, CompUpdateInAndOutputs, (void*)model->task);
-    if (RETURN_ERROR == retVal) {
-        mcx_log(LOG_ERROR, "Model: Updating element channels failed");
-        return RETURN_ERROR;
+    if (model->config->patchWrongInitBehavior) {
+        // Additional step for faulty elements which return zeroes as out channel values during initialization.
+        // This makes sure that after the element exits initialization (CompExitInit),
+        // the output channels contain good values before they get forwarded to the filters (ModelConnectionsExitInitMode)
+        retVal = subModel->LoopEvaluationList(subModel, CompUpdateInAndOutputs, (void*)model->task);
+        if (RETURN_ERROR == retVal) {
+            mcx_log(LOG_ERROR, "Model: Updating element channels failed");
+            return RETURN_ERROR;
+        }
     }
 
     retVal = ModelConnectionsExitInitMode(model->components, model->task->params->time);

From 2cb5d63102655335817988e50b9b466f99f9a09e Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Tue, 16 Aug 2022 11:44:29 +0200
Subject: [PATCH 149/166] ChannelValue: Return error when failing to allocate
 memory

---
 src/core/channels/ChannelValue.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index fb8988d..dfcb9e6 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -955,6 +955,8 @@ McxStatus ChannelValueDataSetToReference(ChannelValueData * value, ChannelType *
                 *(char **) reference = (char *) mcx_calloc(strlen(value->s) + 1, sizeof(char));
                 if (*(char **) reference) {
                     strncpy(*(char **) reference, value->s, strlen(value->s) + 1);
+                } else {
+                    return RETURN_ERROR;
                 }
             }
             break;

From 1cdbcf44dee5164ad419443efa66c098313b095e Mon Sep 17 00:00:00 2001
From: Klaus Schuch <klaus.schuch@avl.com>
Date: Sat, 4 Sep 2021 13:01:00 +0200
Subject: [PATCH 150/166] Task: Change default of sumTime to TRUE

---
 src/core/Task.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/core/Task.c b/src/core/Task.c
index 4882a82..85aba87 100644
--- a/src/core/Task.c
+++ b/src/core/Task.c
@@ -233,12 +233,14 @@ static McxStatus TaskRead(Task * task, TaskInput * taskInput) {
     task->params->timeStepSize = taskInput->deltaTime.defined ? taskInput->deltaTime.value : 0.01;
     mcx_log(LOG_INFO, "  Synchronization time step: %g s", task->params->timeStepSize);
 
-    task->params->sumTime = taskInput->sumTime.defined ? taskInput->sumTime.value : FALSE;
+    task->params->sumTime = taskInput->sumTime.defined ? taskInput->sumTime.value : TRUE;
     if (task->config && task->config->sumTimeDefined) {
         task->params->sumTime = task->config->sumTime;
     }
     if (task->params->sumTime) {
         mcx_log(LOG_DEBUG, "  Using summation for time calculation");
+    } else {
+        mcx_log(LOG_DEBUG, "  Using multiplication for time calculation");
     }
 
     task->stepTypeType = taskInput->stepType;

From fe56fa43b51ea502af3db1157504dfd51658b232 Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Fri, 13 May 2022 11:12:08 +0200
Subject: [PATCH 151/166] task/results: Store RTFactor in Task->Initialize

Previously, only local results were written in Initialize. This
resulted in no timing data being written at startTime (i.e. the
RTFactor results started at startTime + deltaTime).
---
 src/core/Task.c              |  1 +
 src/storage/ResultsStorage.c | 20 ++++++++++++++++++++
 src/storage/ResultsStorage.h |  1 +
 3 files changed, 22 insertions(+)

diff --git a/src/core/Task.c b/src/core/Task.c
index 85aba87..fa63a9f 100644
--- a/src/core/Task.c
+++ b/src/core/Task.c
@@ -135,6 +135,7 @@ static McxStatus TaskInitialize(Task * task, Model * model) {
 
     task->storage->StoreModelOut(task->storage, model->subModel, stepParams->time, STORE_SYNCHRONIZATION);
     task->storage->StoreModelLocal(task->storage, model->subModel, stepParams->time, STORE_SYNCHRONIZATION);
+    task->storage->StoreModelRTFactor(task->storage, model->subModel, stepParams->time, STORE_SYNCHRONIZATION);
 
     task->stepType->Configure(task->stepType, stepParams, subModel);
 
diff --git a/src/storage/ResultsStorage.c b/src/storage/ResultsStorage.c
index 2b9858e..2af07bd 100644
--- a/src/storage/ResultsStorage.c
+++ b/src/storage/ResultsStorage.c
@@ -161,6 +161,25 @@ static McxStatus StorageStoreModelLocal(ResultsStorage * storage, SubModel * sub
     return RETURN_OK;
 }
 
+static McxStatus StorageStoreModelRTFactor(ResultsStorage * storage, SubModel * subModel, double time, StoreLevel level) {
+    size_t i = 0;
+
+    McxStatus retVal = RETURN_OK;
+
+    // Get values from Components
+    for (i = 0; i < storage->numComponents; i++) {
+        ComponentStorage * compStore = storage->componentStorage[i];
+        if (subModel->IsElement(subModel, compStore->comp)) {
+            retVal = compStore->StoreChannels(compStore, CHANNEL_STORE_RTFACTOR, time, level);
+            if (RETURN_OK != retVal) {
+                return RETURN_ERROR;
+            }
+        }
+    }
+
+    return RETURN_OK;
+}
+
 static McxStatus StorageFinishModel(ResultsStorage * storage, SubModel * subModel) {
     size_t i = 0;
 
@@ -525,6 +544,7 @@ static ResultsStorage * ResultsStorageCreate(ResultsStorage * storage) {
     storage->StoreModel = StorageStoreModel;
     storage->StoreModelOut = StorageStoreModelOut;
     storage->StoreModelLocal = StorageStoreModelLocal;
+    storage->StoreModelRTFactor = StorageStoreModelRTFactor;
     storage->FinishModel = StorageFinishModel;
     storage->Finished   = StorageFinished;
 
diff --git a/src/storage/ResultsStorage.h b/src/storage/ResultsStorage.h
index 47ff582..4665128 100644
--- a/src/storage/ResultsStorage.h
+++ b/src/storage/ResultsStorage.h
@@ -93,6 +93,7 @@ struct ResultsStorage {
     fResultsStorageStoreModel StoreModel;
     fResultsStorageStoreModel StoreModelOut;
     fResultsStorageStoreModel StoreModelLocal;
+    fResultsStorageStoreModel StoreModelRTFactor;
     fResultsStorageFinishModel FinishModel;
 
     fResultsStorageRegisterComponent  RegisterComponent;

From c754c71ec4968237885881e6568327452585c3f7 Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Tue, 4 Oct 2022 17:04:37 +0200
Subject: [PATCH 152/166] util: Convert relative Dll paths to absolute ones

---
 libs/util/src/win/libs.c | 57 ++++++++++++++++++++++++++++------------
 1 file changed, 40 insertions(+), 17 deletions(-)

diff --git a/libs/util/src/win/libs.c b/libs/util/src/win/libs.c
index 9f0d20b..cdc1624 100644
--- a/libs/util/src/win/libs.c
+++ b/libs/util/src/win/libs.c
@@ -10,6 +10,7 @@
 
 #define _WINSOCKAPI_    // stops windows.h including winsock.h
 #include <windows.h>
+#include <shlwapi.h>
 
 #include "common/logging.h"
 #include "common/memory.h"
@@ -23,24 +24,12 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-McxStatus mcx_dll_load(DllHandle * handle, const char * dllPath) {
-    DllHandleCheck compValue;
-
-    wchar_t * wDllPath = mcx_string_to_widechar(dllPath);
-
-    * handle = LoadLibraryExW(wDllPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
-    mcx_free(wDllPath);
-
-    compValue = (DllHandleCheck) * handle;
-    if (compValue <= HINSTANCE_ERROR) {
-        LPVOID lpMsgBuf;
-        DWORD err = GetLastError();
-
-        mcx_log(LOG_ERROR, "Util: Dll (%s) could not be loaded", dllPath);
-
-        switch (err) {
+static void print_last_error() {
+    LPVOID lpMsgBuf;
+    DWORD err = GetLastError();
+    switch (err) {
         case ERROR_BAD_EXE_FORMAT:
-            mcx_log(LOG_ERROR, "Util: There is a mismatch in bitness (32/64) between current Model.CONNECT Execution Engine and the dynamic library", dllPath);
+            mcx_log(LOG_ERROR, "Util: There is a mismatch in bitness (32/64) between current Model.CONNECT Execution Engine and the dynamic library");
             break;
         default:
             FormatMessage(
@@ -56,7 +45,41 @@ McxStatus mcx_dll_load(DllHandle * handle, const char * dllPath) {
             mcx_log(LOG_ERROR, "Util: Error %d: %s", err, lpMsgBuf);
             LocalFree(lpMsgBuf);
             break;
+    }
+}
+
+
+McxStatus mcx_dll_load(DllHandle * handle, const char * dllPath) {
+    DllHandleCheck compValue;
+
+    wchar_t * wDllPath = mcx_string_to_widechar(dllPath);
+
+    if (PathIsRelativeW(wDllPath)) {
+        wchar_t * wFullDllPath = NULL;
+        DWORD length = GetFullPathNameW(wDllPath, 0, NULL, NULL);
+        if (length == 0) {
+            mcx_log(LOG_ERROR, "Util: Error retrieving length of absolute path of Dll (%s)", wDllPath);
+            print_last_error();
+            return RETURN_ERROR;
         }
+        wFullDllPath = (wchar_t *) mcx_malloc(sizeof(wchar_t) * length);
+        length = GetFullPathNameW(wDllPath, length, wFullDllPath, NULL);
+        if (length == 0) {
+            mcx_log(LOG_ERROR, "Util: Error creating full path for Dll (%s)", wDllPath);
+            print_last_error();
+            return RETURN_ERROR;
+        }
+        mcx_free(wDllPath);
+        wDllPath = wFullDllPath;
+    }
+
+    * handle = LoadLibraryExW(wDllPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+    mcx_free(wDllPath);
+
+    compValue = (DllHandleCheck) * handle;
+    if (compValue <= HINSTANCE_ERROR) {
+        mcx_log(LOG_ERROR, "Util: Dll (%s) could not be loaded", dllPath);
+        print_last_error();
         return RETURN_ERROR;
     }
 

From 75c167a091c78e85862fcedec08c697f0f5d7a96 Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Thu, 13 Oct 2022 12:12:10 +0200
Subject: [PATCH 153/166] util: Use goto cleanup strategy for handling errors

---
 libs/util/src/win/libs.c | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/libs/util/src/win/libs.c b/libs/util/src/win/libs.c
index cdc1624..112ef25 100644
--- a/libs/util/src/win/libs.c
+++ b/libs/util/src/win/libs.c
@@ -54,36 +54,51 @@ McxStatus mcx_dll_load(DllHandle * handle, const char * dllPath) {
 
     wchar_t * wDllPath = mcx_string_to_widechar(dllPath);
 
+    McxStatus retVal = RETURN_OK;
+
     if (PathIsRelativeW(wDllPath)) {
         wchar_t * wFullDllPath = NULL;
         DWORD length = GetFullPathNameW(wDllPath, 0, NULL, NULL);
         if (length == 0) {
             mcx_log(LOG_ERROR, "Util: Error retrieving length of absolute path of Dll (%s)", wDllPath);
             print_last_error();
-            return RETURN_ERROR;
+            retVal = RETURN_ERROR;
+            goto relpath_cleanup;
         }
         wFullDllPath = (wchar_t *) mcx_malloc(sizeof(wchar_t) * length);
         length = GetFullPathNameW(wDllPath, length, wFullDllPath, NULL);
         if (length == 0) {
             mcx_log(LOG_ERROR, "Util: Error creating full path for Dll (%s)", wDllPath);
             print_last_error();
-            return RETURN_ERROR;
+            retVal = RETURN_ERROR;
+            goto relpath_cleanup;
+        }
+relpath_cleanup:
+        if (wDllPath) {
+            mcx_free(wDllPath);
+        }
+        if (retVal != RETURN_OK) {
+            goto cleanup;
         }
-        mcx_free(wDllPath);
         wDllPath = wFullDllPath;
     }
 
     * handle = LoadLibraryExW(wDllPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
-    mcx_free(wDllPath);
 
     compValue = (DllHandleCheck) * handle;
     if (compValue <= HINSTANCE_ERROR) {
         mcx_log(LOG_ERROR, "Util: Dll (%s) could not be loaded", dllPath);
         print_last_error();
-        return RETURN_ERROR;
+        retVal = RETURN_ERROR;
+        goto cleanup;
+    }
+
+cleanup:
+    if (wDllPath) {
+        mcx_free(wDllPath);
     }
 
-    return RETURN_OK;
+    return retVal;
 }
 
 

From c91257f57430f40155fe19400a20bb384b9d03a2 Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Mon, 10 Oct 2022 10:57:12 +0200
Subject: [PATCH 154/166] util: Log (Debug) absolute path of Dll

---
 libs/util/src/win/libs.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/libs/util/src/win/libs.c b/libs/util/src/win/libs.c
index 112ef25..7f6bc34 100644
--- a/libs/util/src/win/libs.c
+++ b/libs/util/src/win/libs.c
@@ -60,7 +60,7 @@ McxStatus mcx_dll_load(DllHandle * handle, const char * dllPath) {
         wchar_t * wFullDllPath = NULL;
         DWORD length = GetFullPathNameW(wDllPath, 0, NULL, NULL);
         if (length == 0) {
-            mcx_log(LOG_ERROR, "Util: Error retrieving length of absolute path of Dll (%s)", wDllPath);
+            mcx_log(LOG_ERROR, "Util: Error retrieving length of absolute path of Dll (%s)", dllPath);
             print_last_error();
             retVal = RETURN_ERROR;
             goto relpath_cleanup;
@@ -68,7 +68,7 @@ McxStatus mcx_dll_load(DllHandle * handle, const char * dllPath) {
         wFullDllPath = (wchar_t *) mcx_malloc(sizeof(wchar_t) * length);
         length = GetFullPathNameW(wDllPath, length, wFullDllPath, NULL);
         if (length == 0) {
-            mcx_log(LOG_ERROR, "Util: Error creating full path for Dll (%s)", wDllPath);
+            mcx_log(LOG_ERROR, "Util: Error creating absolute path for Dll (%s)", dllPath);
             print_last_error();
             retVal = RETURN_ERROR;
             goto relpath_cleanup;
@@ -83,6 +83,8 @@ McxStatus mcx_dll_load(DllHandle * handle, const char * dllPath) {
         wDllPath = wFullDllPath;
     }
 
+    mcx_log(LOG_DEBUG, "Util: Loading Dll %S", wDllPath);
+
     * handle = LoadLibraryExW(wDllPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 
     compValue = (DllHandleCheck) * handle;

From cd6d38f6649f79a797efd9c98549d6641c28342a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 10 Oct 2022 10:32:11 +0200
Subject: [PATCH 155/166] Calculate first larger sync time multiple differently
 depending on SUM_TIME

---
 src/steptypes/StepTypeParallelMT.c | 1 +
 src/steptypes/StepTypeParallelMT.h | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/src/steptypes/StepTypeParallelMT.c b/src/steptypes/StepTypeParallelMT.c
index 23e5bdd..28050f8 100644
--- a/src/steptypes/StepTypeParallelMT.c
+++ b/src/steptypes/StepTypeParallelMT.c
@@ -103,6 +103,7 @@ static DoStepThreadArg * DoStepThreadArgCreate(DoStepThreadArg * arg) {
     arg->SetCounter = DoStepThreadArgSetCounter;
     arg->StartThread = DoStepThreadArgStartThread;
 
+    arg->reachedSyncTime = 0.0;
     arg->comp = NULL;
     arg->group = 0;
     arg->params = NULL;
diff --git a/src/steptypes/StepTypeParallelMT.h b/src/steptypes/StepTypeParallelMT.h
index deb3906..625f834 100644
--- a/src/steptypes/StepTypeParallelMT.h
+++ b/src/steptypes/StepTypeParallelMT.h
@@ -71,6 +71,9 @@ typedef struct DoStepThreadArg {
     // last status value
     McxStatus status;
 
+    // last reached synchronization point
+    double reachedSyncTime;
+
     // flag if thread should stop
     int finished;
 

From 3afd503904bce31a2b261740e20deadc0c39c48e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 17 Oct 2022 13:31:18 +0200
Subject: [PATCH 156/166] util: Expose function for absolute epsilon comparison

---
 src/util/common/compare.c | 19 +++++++++++++++++++
 src/util/compare.h        |  8 ++++++++
 2 files changed, 27 insertions(+)

diff --git a/src/util/common/compare.c b/src/util/common/compare.c
index ebc5a50..c0a7ff5 100644
--- a/src/util/common/compare.c
+++ b/src/util/common/compare.c
@@ -60,6 +60,12 @@ int double_almost_equal(double a, double b, double eps) {
     }
 }
 
+static int double_almost_equal_abs(double a, double b, double eps) {
+    double diff = (a - b);
+    diff = (diff < 0) ? -diff : diff;
+    return diff < eps;
+}
+
 cmp double_cmp_eps(double a, double b, double eps) {
     if (double_almost_equal(a, b, eps)) {
         return CMP_EQ;
@@ -73,6 +79,19 @@ cmp double_cmp_eps(double a, double b, double eps) {
     }
 }
 
+cmp double_cmp_eps_abs(double a, double b, double eps) {
+    if (double_almost_equal_abs(a, b, eps)) {
+        return CMP_EQ;
+    } else if (a < b) {
+        return CMP_LT;
+    } else if (a > b) {
+        return CMP_GT;
+    } else {
+        // error
+        return CMP_IN;
+    }
+}
+
 int double_eq(double a, double b) {
     return (double_cmp(a,b) == CMP_EQ);
 }
diff --git a/src/util/compare.h b/src/util/compare.h
index 1a81b67..5d6bb3c 100644
--- a/src/util/compare.h
+++ b/src/util/compare.h
@@ -46,6 +46,14 @@ cmp double_cmp(double a, double b);
  */
 cmp double_cmp_eps(double a, double b, double eps);
 
+/**
+ * Returns CMP_LT, CMP_EQ or CMP_GT if a < b, a == b, a > b within eps
+ * and CMP_IN if a and b are not comparable.
+ *
+ * The comparison is done in an absolute manner.
+ */
+cmp double_cmp_eps_abs(double a, double b, double eps);
+
 /**
  * Returns if a == b within an epsilon
  */

From 59f20cc5243d636cb9c01b21593a9d1ed0c45b16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 17 Oct 2022 14:21:44 +0200
Subject: [PATCH 157/166] Use absolute epsilon comparison to determine
 synchronization slots

When the step sizes are multiples of one another (sync and coupling),
it is possible to use a bigger epsilon (half of the smaller step
size) in order to push back the moment when components might fall out
of sync due to floating point operation errors.
---
 src/steptypes/StepType.c           | 33 ++++++++++++++++++++++++++++++
 src/steptypes/StepType.h           | 12 +++++++++++
 src/steptypes/StepTypeParallelMT.c |  5 +++++
 src/steptypes/StepTypeParallelMT.h |  2 ++
 4 files changed, 52 insertions(+)

diff --git a/src/steptypes/StepType.c b/src/steptypes/StepType.c
index d675c97..fb7b7d0 100644
--- a/src/steptypes/StepType.c
+++ b/src/steptypes/StepType.c
@@ -26,6 +26,39 @@ extern "C" {
 // ----------------------------------------------------------------------
 // Step Type: Common
 
+void StepTypeSynchronizationSetup(StepTypeSynchronization * stepTypes, Component * comp, double syncStepSize) {
+    double syncToCoupl = 0.0;
+    double couplToSync = 0.0;
+
+    if (!comp->HasOwnTime(comp)) {
+        return;
+    }
+
+    if (comp->GetTimeStep(comp) <= 0.0) {
+        return;
+    }
+
+    // If the coupling and synchronization step sizes are multiples of one another
+    // it is enough to use half the size of the smaller step for absolute time comparisons.
+    syncToCoupl = syncStepSize / comp->GetTimeStep(comp);
+    couplToSync = comp->GetTimeStep(comp) / syncStepSize;
+
+    if (double_eq(syncToCoupl, round(syncToCoupl))) {
+        stepTypes->stepSizesAreMultiples = TRUE;
+        stepTypes->eps = comp->GetTimeStep(comp) / 2.0;
+    }
+
+    if (double_eq(couplToSync, round(couplToSync))) {
+        stepTypes->stepSizesAreMultiples = TRUE;
+        stepTypes->eps = syncStepSize / 2.0;
+    }
+}
+
+void StepTypeSynchronizationInit(StepTypeSynchronization * stepTypes) {
+    stepTypes->stepSizesAreMultiples = FALSE;
+    stepTypes->eps = -1.0;
+}
+
 McxStatus ComponentDoCommunicationStep(Component * comp, size_t group, StepTypeParams * params) {
     McxStatus retVal = RETURN_OK;
     double time = params->time;
diff --git a/src/steptypes/StepType.h b/src/steptypes/StepType.h
index b5eac5d..b0676d0 100644
--- a/src/steptypes/StepType.h
+++ b/src/steptypes/StepType.h
@@ -24,6 +24,18 @@ typedef struct SubModel SubModel;
 typedef struct CompAndGroup CompAndGroup;
 
 
+typedef struct StepTypeSynchronization {
+    // flag whether the coupling and synchronization step size are multiples of one another
+    int stepSizesAreMultiples;
+
+    // epsilon used for time comparisons
+    double eps;
+} StepTypeSynchronization;
+
+void StepTypeSynchronizationSetup(StepTypeSynchronization * stepTypes, Component * comp, double syncStepSize);
+void StepTypeSynchronizationInit(StepTypeSynchronization * stepTypes);
+
+
 typedef enum StepTypeType {
     STEP_TYPE_UNDEFINED = -1,       /* "parallel_singlethreaded" */
     STEP_TYPE_SEQUENTIAL = 1,       /* "sequential" */
diff --git a/src/steptypes/StepTypeParallelMT.c b/src/steptypes/StepTypeParallelMT.c
index 28050f8..0eec47a 100644
--- a/src/steptypes/StepTypeParallelMT.c
+++ b/src/steptypes/StepTypeParallelMT.c
@@ -79,6 +79,8 @@ static void DoStepThreadArgSetup(DoStepThreadArg * arg, Component * comp, size_t
     arg->comp = comp;
     arg->group = group;
     arg->params = params;
+
+    StepTypeSynchronizationSetup(&arg->stepSizes, comp, params->timeStepSize);
 }
 
 static void DoStepThreadArgSetCounter(DoStepThreadArg * arg, DoStepThreadCounter * counter) {
@@ -109,6 +111,9 @@ static DoStepThreadArg * DoStepThreadArgCreate(DoStepThreadArg * arg) {
     arg->params = NULL;
     arg->status = RETURN_OK;
     arg->finished = FALSE;
+
+    StepTypeSynchronizationInit(&arg->stepSizes);
+
     status = mcx_event_create(&arg->startDoStepEvent);
     if (status) {
         mcx_log(LOG_ERROR, "Simulation: Failed to create DoStep start event");
diff --git a/src/steptypes/StepTypeParallelMT.h b/src/steptypes/StepTypeParallelMT.h
index 625f834..362c3a3 100644
--- a/src/steptypes/StepTypeParallelMT.h
+++ b/src/steptypes/StepTypeParallelMT.h
@@ -74,6 +74,8 @@ typedef struct DoStepThreadArg {
     // last reached synchronization point
     double reachedSyncTime;
 
+    StepTypeSynchronization stepSizes;
+
     // flag if thread should stop
     int finished;
 

From 54456a69b71673131c1ad5852c2bc11a4824c0f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 17 Oct 2022 14:46:09 +0200
Subject: [PATCH 158/166] Use same way of checking for sync slots both in
 component and step type

---
 src/core/Component.c               | 2 ++
 src/core/Component.h               | 4 ++++
 src/steptypes/StepType.c           | 9 ++++++++-
 src/steptypes/StepTypeParallelMT.c | 7 ++++---
 src/steptypes/StepTypeParallelMT.h | 2 --
 5 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/core/Component.c b/src/core/Component.c
index 876f99f..1cc9969 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -1292,6 +1292,8 @@ static Component * ComponentCreate(Component * comp) {
 
     comp->data->typeString = NULL;
 
+    comp->syncHintsConfigured = FALSE;
+    StepTypeSynchronizationInit(&comp->syncHints);
 
     comp->GetNumObservableChannels = ComponentGetNumObservableChannels;
     comp->AddObservableChannels = AddObservableChannels;
diff --git a/src/core/Component.h b/src/core/Component.h
index 3e1493a..d21d181 100644
--- a/src/core/Component.h
+++ b/src/core/Component.h
@@ -19,6 +19,7 @@
 #include "objects/Vector.h"
 #include "reader/model/components/ComponentInput.h"
 #include "core/connections/ConnectionInfo.h"
+#include "steptypes/StepType.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -228,6 +229,9 @@ struct Component {
     fOnConnectionsDone OnConnectionsDone;
 
     struct ComponentData * data;
+
+    int syncHintsConfigured;
+    StepTypeSynchronization syncHints;
 };
 
 /* these functions have to be called by subclasses */
diff --git a/src/steptypes/StepType.c b/src/steptypes/StepType.c
index fb7b7d0..79bad88 100644
--- a/src/steptypes/StepType.c
+++ b/src/steptypes/StepType.c
@@ -80,9 +80,16 @@ McxStatus ComponentDoCommunicationStep(Component * comp, size_t group, StepTypeP
 
     level = STORE_SYNCHRONIZATION;
 
+    if (!comp->syncHintsConfigured) {
+        StepTypeSynchronizationSetup(&comp->syncHints, comp, params->timeStepSize);
+        comp->syncHintsConfigured = TRUE;
+    }
+
     while (
         comp->GetFinishState(comp) != COMP_IS_FINISHED &&
-        double_lt(comp->GetTime(comp), stepEndTime)
+        comp->syncHints.stepSizesAreMultiples ?
+            double_cmp_eps_abs(comp->GetTime(comp), stepEndTime, comp->syncHints.eps) == CMP_LT :
+            double_lt(comp->GetTime(comp), stepEndTime)
     ) {
         if (comp->HasOwnTime(comp)) {
             interval.startTime = comp->GetTime(comp);
diff --git a/src/steptypes/StepTypeParallelMT.c b/src/steptypes/StepTypeParallelMT.c
index 0eec47a..f89fe3f 100644
--- a/src/steptypes/StepTypeParallelMT.c
+++ b/src/steptypes/StepTypeParallelMT.c
@@ -80,7 +80,10 @@ static void DoStepThreadArgSetup(DoStepThreadArg * arg, Component * comp, size_t
     arg->group = group;
     arg->params = params;
 
-    StepTypeSynchronizationSetup(&arg->stepSizes, comp, params->timeStepSize);
+    if (!comp->syncHintsConfigured) {
+        StepTypeSynchronizationSetup(&comp->syncHints, comp, params->timeStepSize);
+        comp->syncHintsConfigured = TRUE;
+    }
 }
 
 static void DoStepThreadArgSetCounter(DoStepThreadArg * arg, DoStepThreadCounter * counter) {
@@ -112,8 +115,6 @@ static DoStepThreadArg * DoStepThreadArgCreate(DoStepThreadArg * arg) {
     arg->status = RETURN_OK;
     arg->finished = FALSE;
 
-    StepTypeSynchronizationInit(&arg->stepSizes);
-
     status = mcx_event_create(&arg->startDoStepEvent);
     if (status) {
         mcx_log(LOG_ERROR, "Simulation: Failed to create DoStep start event");
diff --git a/src/steptypes/StepTypeParallelMT.h b/src/steptypes/StepTypeParallelMT.h
index 362c3a3..625f834 100644
--- a/src/steptypes/StepTypeParallelMT.h
+++ b/src/steptypes/StepTypeParallelMT.h
@@ -74,8 +74,6 @@ typedef struct DoStepThreadArg {
     // last reached synchronization point
     double reachedSyncTime;
 
-    StepTypeSynchronization stepSizes;
-
     // flag if thread should stop
     int finished;
 

From c05f57525758e9d19efb34dc37b71ea4d1172b7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Wed, 19 Oct 2022 09:18:22 +0200
Subject: [PATCH 159/166] Remove obsolete code

---
 src/core/Component.c               | 1 -
 src/core/Component.h               | 1 -
 src/steptypes/StepType.c           | 5 -----
 src/steptypes/StepTypeParallelMT.c | 5 +----
 4 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/src/core/Component.c b/src/core/Component.c
index 1cc9969..b8070aa 100644
--- a/src/core/Component.c
+++ b/src/core/Component.c
@@ -1292,7 +1292,6 @@ static Component * ComponentCreate(Component * comp) {
 
     comp->data->typeString = NULL;
 
-    comp->syncHintsConfigured = FALSE;
     StepTypeSynchronizationInit(&comp->syncHints);
 
     comp->GetNumObservableChannels = ComponentGetNumObservableChannels;
diff --git a/src/core/Component.h b/src/core/Component.h
index d21d181..4893dae 100644
--- a/src/core/Component.h
+++ b/src/core/Component.h
@@ -230,7 +230,6 @@ struct Component {
 
     struct ComponentData * data;
 
-    int syncHintsConfigured;
     StepTypeSynchronization syncHints;
 };
 
diff --git a/src/steptypes/StepType.c b/src/steptypes/StepType.c
index 79bad88..0a1a39d 100644
--- a/src/steptypes/StepType.c
+++ b/src/steptypes/StepType.c
@@ -80,11 +80,6 @@ McxStatus ComponentDoCommunicationStep(Component * comp, size_t group, StepTypeP
 
     level = STORE_SYNCHRONIZATION;
 
-    if (!comp->syncHintsConfigured) {
-        StepTypeSynchronizationSetup(&comp->syncHints, comp, params->timeStepSize);
-        comp->syncHintsConfigured = TRUE;
-    }
-
     while (
         comp->GetFinishState(comp) != COMP_IS_FINISHED &&
         comp->syncHints.stepSizesAreMultiples ?
diff --git a/src/steptypes/StepTypeParallelMT.c b/src/steptypes/StepTypeParallelMT.c
index f89fe3f..ee43557 100644
--- a/src/steptypes/StepTypeParallelMT.c
+++ b/src/steptypes/StepTypeParallelMT.c
@@ -80,10 +80,7 @@ static void DoStepThreadArgSetup(DoStepThreadArg * arg, Component * comp, size_t
     arg->group = group;
     arg->params = params;
 
-    if (!comp->syncHintsConfigured) {
-        StepTypeSynchronizationSetup(&comp->syncHints, comp, params->timeStepSize);
-        comp->syncHintsConfigured = TRUE;
-    }
+    StepTypeSynchronizationSetup(&comp->syncHints, comp, params->timeStepSize);
 }
 
 static void DoStepThreadArgSetCounter(DoStepThreadArg * arg, DoStepThreadCounter * counter) {

From 0b8f30ce53cc0a80728b15e271e0cdaa8261ed40 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 20 Oct 2022 11:33:44 +0200
Subject: [PATCH 160/166] Define a leq comparison function using absolute
 epsilon comparison

---
 src/util/common/compare.c | 4 ++++
 src/util/compare.h        | 5 +++++
 2 files changed, 9 insertions(+)

diff --git a/src/util/common/compare.c b/src/util/common/compare.c
index c0a7ff5..ea21285 100644
--- a/src/util/common/compare.c
+++ b/src/util/common/compare.c
@@ -114,6 +114,10 @@ int double_geq(double a, double b) {
             || double_cmp(a,b) == CMP_GT);
 }
 
+int double_leq_eps_abs(double a, double b, double eps) {
+    return (double_cmp_eps_abs(a, b, eps) == CMP_EQ || double_cmp_eps_abs(a, b, eps) == CMP_LT);
+}
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif /* __cplusplus */
\ No newline at end of file
diff --git a/src/util/compare.h b/src/util/compare.h
index 5d6bb3c..ae3e084 100644
--- a/src/util/compare.h
+++ b/src/util/compare.h
@@ -79,6 +79,11 @@ int double_leq(double a, double b);
  */
 int double_geq(double a, double b);
 
+/**
+ * Returns if a <= b modulo eps
+ */
+int double_leq_eps_abs(double a, double b, double eps);
+
 
 #ifdef __cplusplus
 } /* closing brace for extern "C" */

From c9bd0beae9336d6942a53904d0979fc5dff11ebe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 5 Sep 2022 15:48:55 +0200
Subject: [PATCH 161/166] Add const qualifiers

---
 src/core/channels/ChannelValue.c | 8 ++++----
 src/core/channels/ChannelValue.h | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index dfcb9e6..be7d644 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -169,7 +169,7 @@ int ChannelTypeIsBinary(const ChannelType * a) {
     return a->con == CHANNEL_BINARY || a->con == CHANNEL_BINARY_REFERENCE;
 }
 
-ChannelType * ChannelTypeBaseType(ChannelType * a) {
+ChannelType * ChannelTypeBaseType(const ChannelType * a) {
     if (ChannelTypeIsArray(a)) {
         return ChannelTypeBaseType(a->ty.a.inner);
     } else {
@@ -212,7 +212,7 @@ int ChannelTypeConformable(ChannelType * a, ChannelDimension * sliceA, ChannelTy
     }
 }
 
-int ChannelTypeEq(ChannelType * a, ChannelType * b) {
+int ChannelTypeEq(const ChannelType * a, const ChannelType * b) {
     if (a->con == CHANNEL_ARRAY && b->con == CHANNEL_ARRAY) {
         size_t i = 0;
         if (a->ty.a.numDims != b->ty.a.numDims) {
@@ -320,7 +320,7 @@ int mcx_array_dims_match(mcx_array * a, mcx_array * b) {
     return 1;
 }
 
-size_t mcx_array_num_elements(mcx_array * a) {
+size_t mcx_array_num_elements(const mcx_array * a) {
     size_t i = 0;
     size_t n = 1;
 
@@ -348,7 +348,7 @@ McxStatus mcx_array_map(mcx_array * a, mcx_array_map_f_ptr fn, void * ctx) {
     return RETURN_OK;
 }
 
-McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element) {
+McxStatus mcx_array_get_elem(const mcx_array * a, size_t idx, ChannelValueData * element) {
     size_t num_elems = mcx_array_num_elements(a);
 
     if (idx >= num_elems) {
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 7c8ebdd..6e9bf30 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -73,9 +73,9 @@ size_t ChannelTypeNumElements(const ChannelType * type);
 
 ChannelType * ChannelTypeFromDimension(ChannelType * base_type, ChannelDimension * dimension);
 
-ChannelType * ChannelTypeBaseType(ChannelType * a);
+ChannelType * ChannelTypeBaseType(const ChannelType * a);
 
-int ChannelTypeEq(ChannelType * a, ChannelType * b);
+int ChannelTypeEq(const ChannelType * a, const ChannelType * b);
 int ChannelTypeConformable(ChannelType * a, ChannelDimension * sliceA, ChannelType * b, ChannelDimension * sliceB);
 
 typedef struct MapStringChannelType {
@@ -112,12 +112,12 @@ typedef struct {
 McxStatus mcx_array_init(mcx_array * a, size_t numDims, size_t * dims, ChannelType * type);
 void mcx_array_destroy(mcx_array * a);
 int mcx_array_dims_match(mcx_array * a, mcx_array * b);
-size_t mcx_array_num_elements(mcx_array * a);
+size_t mcx_array_num_elements(const mcx_array * a);
 
 typedef int (*mcx_array_map_f_ptr)(void * element, size_t idx, ChannelType * type, void * ctx);
 
 McxStatus mcx_array_map(mcx_array * a, mcx_array_map_f_ptr fn, void * ctx);
-McxStatus mcx_array_get_elem(mcx_array * a, size_t idx, ChannelValueData * element);
+McxStatus mcx_array_get_elem(const mcx_array * a, size_t idx, ChannelValueData * element);
 McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 
 void * mcx_array_get_elem_reference(mcx_array * a, size_t idx);

From b002c77290395e777feb19f011bf20d2b96bc9c2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Fri, 16 Sep 2022 14:24:11 +0200
Subject: [PATCH 162/166] Add const qualifier

---
 src/core/channels/ChannelValue.c | 2 +-
 src/core/channels/ChannelValue.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index be7d644..82856b8 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -448,7 +448,7 @@ McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * eleme
     return RETURN_OK;
 }
 
-void * mcx_array_get_elem_reference(mcx_array * a, size_t idx) {
+void * mcx_array_get_elem_reference(const mcx_array * a, size_t idx) {
     size_t num_elems = mcx_array_num_elements(a);
     char * data = (char *) a->data;
 
diff --git a/src/core/channels/ChannelValue.h b/src/core/channels/ChannelValue.h
index 6e9bf30..a2936bd 100644
--- a/src/core/channels/ChannelValue.h
+++ b/src/core/channels/ChannelValue.h
@@ -120,7 +120,7 @@ McxStatus mcx_array_map(mcx_array * a, mcx_array_map_f_ptr fn, void * ctx);
 McxStatus mcx_array_get_elem(const mcx_array * a, size_t idx, ChannelValueData * element);
 McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * element);
 
-void * mcx_array_get_elem_reference(mcx_array * a, size_t idx);
+void * mcx_array_get_elem_reference(const mcx_array * a, size_t idx);
 
 typedef int (*mcx_array_predicate_f_ptr)(void * element, ChannelType * type);
 int mcx_array_all(mcx_array * a, mcx_array_predicate_f_ptr predicate);

From 29458bfb174a641f393cd3b590d3a4ce204b5d87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Mon, 26 Sep 2022 15:16:53 +0200
Subject: [PATCH 163/166] FMU2: Correctly use dimensions of naming convention
 arrays - do not flip dimensions from the asix file (dim0-major)

---
 src/fmu/common_fmu2.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index 3a07319..d83ff59 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -361,8 +361,8 @@ static ObjectContainer* Fmu2ReadArrayParamValues(const char * name,
         end2 = input->dims[1]->end;
     }
 
-    for (k = start2; k <= end2; k++) {
-        for (j = start1; j <= end1; j++, index++) {
+    for (k = start1; k <= end1; k++) {
+        for (j = start2; j <= end2; j++, index++) {
             Fmu2Value * val = NULL;
             char * varName = (char *) mcx_calloc(stringBufferLength, sizeof(char));
             fmi2_import_variable_t * var = NULL;
@@ -376,7 +376,7 @@ static ObjectContainer* Fmu2ReadArrayParamValues(const char * name,
             if (input->numDims == 2) {
                 snprintf(varName, stringBufferLength, "%s[%zu,%zu]", name, k, j);
             } else {
-                snprintf(varName, stringBufferLength, "%s[%zu]", name, j);
+                snprintf(varName, stringBufferLength, "%s[%zu]", name, k);
             }
 
             var = fmi2_import_get_variable_by_name(import, varName);

From 53cddb39f859400ae7714db1d4bcd02dd0b2a7f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20=C4=8Cau=C5=A1evi=C4=87?= <denis.causevic@avl.com>
Date: Thu, 27 Oct 2022 13:53:55 +0200
Subject: [PATCH 164/166] Correctly check if cloning was successful

---
 src/core/connections/Connection.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/connections/Connection.c b/src/core/connections/Connection.c
index ac28c78..01bc80a 100644
--- a/src/core/connections/Connection.c
+++ b/src/core/connections/Connection.c
@@ -1177,7 +1177,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
         ChannelDimension * srcDim = NULL;
 
         srcDim = CloneChannelDimension(info->targetDimension);
-        if (srcDim) {
+        if (info->targetDimension && !srcDim) {
             mcx_log(LOG_ERROR, "Could not clone source dimension");
             retVal = RETURN_ERROR;
             goto cleanup_1;
@@ -1219,7 +1219,7 @@ static McxStatus ConnectionUpdateInitialValue(Connection * connection) {
         }
     } else if (outInfo->initialValue) {
         ChannelDimension * targetDim = CloneChannelDimension(info->sourceDimension);
-        if (targetDim) {
+        if (info->sourceDimension && !targetDim) {
             mcx_log(LOG_ERROR, "Could not clone target dimension");
             retVal = RETURN_ERROR;
             goto cleanup;

From 1251484bd023798f272a1fccb14a95135e5e41e0 Mon Sep 17 00:00:00 2001
From: Dominic Hirtler <dominic.hirtler@avl.com>
Date: Fri, 15 Jul 2022 12:22:44 +0200
Subject: [PATCH 165/166] fmu: Remove check for valid dimension_1/2

---
 src/fmu/common_fmu1.c | 10 ----------
 src/fmu/common_fmu2.c | 10 ----------
 2 files changed, 20 deletions(-)

diff --git a/src/fmu/common_fmu1.c b/src/fmu/common_fmu1.c
index 64c2896..949e66d 100644
--- a/src/fmu/common_fmu1.c
+++ b/src/fmu/common_fmu1.c
@@ -473,16 +473,6 @@ ObjectContainer * Fmu1ReadParams(ParametersInput * input, fmi1_import_t * import
         }
 
         if (parameterInput->type == PARAMETER_ARRAY) {
-            // read parameter dimensions (if any) - should only be defined for array parameters
-            if (parameterInput->parameter.arrayParameter->numDims >= 2 &&
-                parameterInput->parameter.arrayParameter->dims[1] &&
-                !parameterInput->parameter.arrayParameter->dims[0]) {
-                mcx_log(LOG_ERROR, "FMU: Array parameter %s: Missing definition for the first dimension "
-                        "while the second dimension is defined.", parameterInput->parameter.arrayParameter->name);
-                ret = NULL;
-                goto cleanup;
-            }
-
             // array - split it into scalars
             vals = Fmu1ReadArrayParamValues(name, parameterInput->parameter.arrayParameter, import, params);
             if (vals == NULL) {
diff --git a/src/fmu/common_fmu2.c b/src/fmu/common_fmu2.c
index d83ff59..cb8fd8c 100644
--- a/src/fmu/common_fmu2.c
+++ b/src/fmu/common_fmu2.c
@@ -503,16 +503,6 @@ McxStatus Fmu2ReadParams(ObjectContainer * params, ObjectContainer * arrayParams
             ArrayParameterProxy * proxy = NULL;
             size_t j = 0;
 
-            // read parameter dimensions (if any) - should only be defined for array parameters
-            if (parameterInput->parameter.arrayParameter->numDims >=2 &&
-                parameterInput->parameter.arrayParameter->dims[1] &&
-                !parameterInput->parameter.arrayParameter->dims[0]) {
-                mcx_log(LOG_ERROR, "FMU: Array parameter %s: Missing definition for the first dimension "
-                        "while the second dimension is defined.", parameterInput->parameter.arrayParameter->name);
-                retVal = RETURN_ERROR;
-                goto cleanup_1;
-            }
-
             // array - split it into scalars
             vals = Fmu2ReadArrayParamValues(name, parameterInput->parameter.arrayParameter, import, params);
             if (vals == NULL) {

From 79a57c0521c29f79296280edc50b707ea81d1c2b Mon Sep 17 00:00:00 2001
From: Klaus Schuch <klaus.schuch@avl.com>
Date: Wed, 5 Mar 2025 18:42:47 +0100
Subject: [PATCH 166/166] Use %zu for size_t

---
 src/components/comp_vector_integrator.c   |  2 +-
 src/core/Databus.c                        |  8 ++++----
 src/core/Model.c                          | 22 +++++++++++-----------
 src/core/SubModel.c                       |  4 ++--
 src/core/channels/ChannelDimension.c      |  4 ++--
 src/core/channels/ChannelValue.c          | 18 +++++++++---------
 src/core/connections/FilteredConnection.c |  2 +-
 7 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/components/comp_vector_integrator.c b/src/components/comp_vector_integrator.c
index 77bc342..efd1ba7 100644
--- a/src/components/comp_vector_integrator.c
+++ b/src/components/comp_vector_integrator.c
@@ -42,7 +42,7 @@ static McxStatus Read(Component * comp, ComponentInput * input, const struct Con
     size_t numOut = DatabusGetOutChannelsNum(db);
 
     if (numIn != numOut) {
-        ComponentLog(comp, LOG_ERROR, "#inports (%d) does not match the #outports (%d)", numIn, numOut);
+        ComponentLog(comp, LOG_ERROR, "#inports (%zu) does not match the #outports (%zu)", numIn, numOut);
         return RETURN_ERROR;
     }
 
diff --git a/src/core/Databus.c b/src/core/Databus.c
index e5580c9..4385837 100644
--- a/src/core/Databus.c
+++ b/src/core/Databus.c
@@ -321,7 +321,7 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
 
         ChannelInfo * info = DatabusReadPortInput(portInput);
         if (!info) {
-            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read info of port %d", i);
+            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read info of port %zu", i);
             retVal = RETURN_ERROR;
             goto cleanup;
         }
@@ -330,7 +330,7 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
 
         const char * name = ChannelInfoGetName(info);
         if (info->dimension) {
-            mcx_log(LOG_DEBUG, "    Port: \"%s[%d:%d]\"", name, info->dimension->startIdxs[0], info->dimension->endIdxs[0]);
+            mcx_log(LOG_DEBUG, "    Port: \"%s[%zu:%zu]\"", name, info->dimension->startIdxs[0], info->dimension->endIdxs[0]);
         } else {
             mcx_log(LOG_DEBUG, "    Port: \"%s\"", name);
         }
@@ -348,13 +348,13 @@ McxStatus DatabusInfoRead(DatabusInfo * dbInfo,
         if (SpecificRead) {
             retVal = SpecificRead(comp, info, portInput, i);
             if (RETURN_ERROR == retVal) {
-                mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read element specific data of port %d", i);
+                mcx_log(LOG_ERROR, "Ports: Read port infos: Could not read element specific data of port %zu", i);
                 goto cleanup;
             }
         }
 
         if (RETURN_OK != dbInfos->PushBack(dbInfos, info)) {
-            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %d", i);
+            mcx_log(LOG_ERROR, "Ports: Read port infos: Could not append info of port %zu", i);
             retVal = RETURN_ERROR;
             goto cleanup;
         }
diff --git a/src/core/Model.c b/src/core/Model.c
index 719ea46..12321cb 100644
--- a/src/core/Model.c
+++ b/src/core/Model.c
@@ -1525,7 +1525,7 @@ McxStatus PrintComponentGraph(Component * comp,
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; j < GetDependencyNumIn(A); j++) {
             mcx_os_fprintf(dotFile, "        <tr>\n");
-            mcx_os_fprintf(dotFile, "          <td port=\"in%d\">%d</td>\n", j, j);
+            mcx_os_fprintf(dotFile, "          <td port=\"in%zu\">%zu</td>\n", j, j);
             mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1543,7 +1543,7 @@ McxStatus PrintComponentGraph(Component * comp,
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; j < DatabusGetOutChannelsNum(db); j++) {
             mcx_os_fprintf(dotFile, "        <tr>\n");
-            mcx_os_fprintf(dotFile, "          <td port=\"out%d\">%d</td>\n", j, j);
+            mcx_os_fprintf(dotFile, "          <td port=\"out%zu\">%zu</td>\n", j, j);
             mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1567,7 +1567,7 @@ McxStatus PrintComponentGraph(Component * comp,
             }
             GetDependency(A, i, grp, &dep);
             if (dep != DEP_INDEPENDENT) {
-                mcx_os_fprintf(dotFile, "in:in%d -> out:out%d;\n", i, j);
+                mcx_os_fprintf(dotFile, "in:in%zu -> out:out%zu;\n", i, j);
             }
         }
     }
@@ -1609,14 +1609,14 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetOutChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"out%d\">%d</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"out%zu\">%zu</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
         }
         mcx_os_fprintf(dotFile, "    </td>\n");
         mcx_os_fprintf(dotFile, "  </tr>\n");
-        mcx_os_fprintf(dotFile, "</table>>] comp%d;\n", comps->Size(comps));
+        mcx_os_fprintf(dotFile, "</table>>] comp%zu;\n", comps->Size(comps));
     }
 
     for (i = 0; i < comps->Size(comps); i++) {
@@ -1632,7 +1632,7 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetInChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"in%d\">%d</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"in%zu\">%zu</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1646,14 +1646,14 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetOutChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"out%d\">%d</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"out%zu\">%zu</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
         }
         mcx_os_fprintf(dotFile, "    </td>\n");
         mcx_os_fprintf(dotFile, "  </tr>\n");
-        mcx_os_fprintf(dotFile, "</table>>] comp%d;\n", c->GetID(c));
+        mcx_os_fprintf(dotFile, "</table>>] comp%zu;\n", c->GetID(c));
     }
 
     if (outComp) {
@@ -1668,7 +1668,7 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "      <table %s>\n", tableArgs);
         for (j = 0; (int) j < DatabusGetInChannelsNum(db); j++) {
         mcx_os_fprintf(dotFile, "        <tr>\n");
-        mcx_os_fprintf(dotFile, "          <td port=\"in%d\">%d</td>\n", j, j);
+        mcx_os_fprintf(dotFile, "          <td port=\"in%zu\">%zu</td>\n", j, j);
         mcx_os_fprintf(dotFile, "        </tr>\n");
         }
         mcx_os_fprintf(dotFile, "      </table>\n");
@@ -1676,13 +1676,13 @@ McxStatus PrintModelGraph(ObjectContainer * comps, Vector * conns, Component * i
         mcx_os_fprintf(dotFile, "    </td>\n");
         mcx_os_fprintf(dotFile, "    <td>out</td>\n");
         mcx_os_fprintf(dotFile, "  </tr>\n");
-        mcx_os_fprintf(dotFile, "</table>>] comp%d;\n", comps->Size(comps) + 1);
+        mcx_os_fprintf(dotFile, "</table>>] comp%zu;\n", comps->Size(comps) + 1);
     }
 
     mcx_os_fprintf(dotFile, "{\n");
 
     if (inComp && outComp) {
-        mcx_os_fprintf(dotFile, "comp%d -> comp%d [style=invis];\n",
+        mcx_os_fprintf(dotFile, "comp%zu -> comp%zu [style=invis];\n",
                 comps->Size(comps),
                 comps->Size(comps) + 1);
     }
diff --git a/src/core/SubModel.c b/src/core/SubModel.c
index c2999e0..f55ee35 100644
--- a/src/core/SubModel.c
+++ b/src/core/SubModel.c
@@ -768,13 +768,13 @@ static struct Dependencies * SubModelGeneratorCreateDependencyMatrix(SubModelGen
 
                         if (0 == numOutChannels && (INITIAL_DEPENDENCIES == depType)) {
                             mcx_log(LOG_DEBUG,
-                                    "(%s,%d) -> (%s,-)",
+                                    "(%s,%zu) -> (%s,-)",
                                     sourceComp->GetName(sourceComp),
                                     sourceOutGroup,
                                     targetComp->GetName(targetComp));
                         } else {
                             mcx_log(LOG_DEBUG,
-                                    "(%s,%d) -> (%s,%d)",
+                                    "(%s,%zu) -> (%s,%zu)",
                                     sourceComp->GetName(sourceComp),
                                     sourceOutGroup,
                                     targetComp->GetName(targetComp),
diff --git a/src/core/channels/ChannelDimension.c b/src/core/channels/ChannelDimension.c
index 986ffc3..03ef23e 100644
--- a/src/core/channels/ChannelDimension.c
+++ b/src/core/channels/ChannelDimension.c
@@ -214,7 +214,7 @@ size_t ChannelDimensionGetIndex(const ChannelDimension * dimension, size_t elem_
                 return slice_idx_0 * sizes[1] + slice_idx_1;
             }
         default:
-            mcx_log(LOG_ERROR, "ChannelDimensionGetIndex: Number of dimensions not supported (%d)", dimension->num);
+            mcx_log(LOG_ERROR, "ChannelDimensionGetIndex: Number of dimensions not supported (%zu)", dimension->num);
             break;
     }
 
@@ -246,7 +246,7 @@ size_t ChannelDimensionGetSliceIndex(const ChannelDimension * dimension, size_t
                 return slice_idx_0 * dim_1_slice_size * slice_idx_1;
             }
         default:
-            mcx_log(LOG_ERROR, "ChannelDimensionGetSliceIndex: Number of dimensions not supported (%d)", dimension->num);
+            mcx_log(LOG_ERROR, "ChannelDimensionGetSliceIndex: Number of dimensions not supported (%zu)", dimension->num);
             break;
     }
 
diff --git a/src/core/channels/ChannelValue.c b/src/core/channels/ChannelValue.c
index 82856b8..1e33f03 100644
--- a/src/core/channels/ChannelValue.c
+++ b/src/core/channels/ChannelValue.c
@@ -352,7 +352,7 @@ McxStatus mcx_array_get_elem(const mcx_array * a, size_t idx, ChannelValueData *
     size_t num_elems = mcx_array_num_elements(a);
 
     if (idx >= num_elems) {
-        mcx_log(LOG_ERROR, "mcx_array_get_elem: Array index out of range (idx: %d, num_elems: %d)", idx, num_elems);
+        mcx_log(LOG_ERROR, "mcx_array_get_elem: Array index out of range (idx: %zu, num_elems: %zu)", idx, num_elems);
         return RETURN_ERROR;
     }
 
@@ -386,7 +386,7 @@ McxStatus mcx_array_set_elem(mcx_array * a, size_t idx, ChannelValueData * eleme
     size_t num_elems = mcx_array_num_elements(a);
 
     if (idx >= num_elems) {
-        mcx_log(LOG_ERROR, "mcx_array_set_elem: Array index out of range (idx: %d, num_elems: %d)", idx, num_elems);
+        mcx_log(LOG_ERROR, "mcx_array_set_elem: Array index out of range (idx: %zu, num_elems: %zu)", idx, num_elems);
         return RETURN_ERROR;
     }
 
@@ -453,7 +453,7 @@ void * mcx_array_get_elem_reference(const mcx_array * a, size_t idx) {
     char * data = (char *) a->data;
 
     if (idx >= num_elems) {
-        mcx_log(LOG_ERROR, "mcx_array_get_elem_reference: Array index out of range (idx: %d, num_elems: %d)", idx, num_elems);
+        mcx_log(LOG_ERROR, "mcx_array_get_elem_reference: Array index out of range (idx: %zu, num_elems: %zu)", idx, num_elems);
         return NULL;
     }
 
@@ -662,7 +662,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
     case CHANNEL_DOUBLE:
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         if (len < length) {
-            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
+            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %zu, given: %zu", length, len);
             return RETURN_ERROR;
         }
         sprintf(buffer, doubleFmt, (unsigned)precision, (unsigned)precision, value->d);
@@ -671,7 +671,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
         length = 1 /* sign */ + mcx_digits10(abs(value->i)) + 1 /* string termination*/;
 
         if (len < length) {
-            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
+            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %zu, given: %zu", length, len);
             return RETURN_ERROR;
         }
         sprintf(buffer, "%d", value->i);
@@ -679,7 +679,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
     case CHANNEL_BOOL:
         length = 2;
         if (len < length) {
-            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
+            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %zu, given: %zu", length, len);
             return RETURN_ERROR;
         }
         sprintf(buffer, "%1d", (value->i != 0) ? 1 : 0);
@@ -691,7 +691,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
         }
         length = strlen(value->s) + 1 /* string termination */;
         if (len < length) {
-            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
+            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %zu, given: %zu", length, len);
             return RETURN_ERROR;
         }
         sprintf(buffer, "%s", value->s);
@@ -706,7 +706,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
     case CHANNEL_BINARY_REFERENCE:
         length = value->b.len * 4 + 1;
         if (len < length) {
-            mcx_log(LOG_DEBUG, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
+            mcx_log(LOG_DEBUG, "Port value to string: buffer too short. Needed: %zu, given: %zu", length, len);
             return RETURN_ERROR;
         }
         {
@@ -722,7 +722,7 @@ McxStatus ChannelValueDataToStringBuffer(const ChannelValueData * value, Channel
 
         length = 1 /* sign */ + 1 /* pre decimal place */ + 1 /* dot */ + precision + digits_of_exp + 1 /* string termination */;
         if (len < length) {
-            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %d, given: %d", length, len);
+            mcx_log(LOG_ERROR, "Port value to string: buffer too short. Needed: %zu, given: %zu", length, len);
             return RETURN_ERROR;
         }
         sprintf(buffer, doubleFmt, (unsigned)precision, (unsigned)precision, *(double *)value->a.data);
diff --git a/src/core/connections/FilteredConnection.c b/src/core/connections/FilteredConnection.c
index f4f684e..9815911 100644
--- a/src/core/connections/FilteredConnection.c
+++ b/src/core/connections/FilteredConnection.c
@@ -306,7 +306,7 @@ static McxStatus AddFilter(Connection * connection) {
                                                                      info->targetComponent,
                                                                      connString);
                 if (NULL == filteredConnection->data->filters[i]) {
-                    mcx_log(LOG_DEBUG, "Connection: Array filter creation failed for index %d", i);
+                    mcx_log(LOG_DEBUG, "Connection: Array filter creation failed for index %zu", i);
                     retVal = RETURN_ERROR;
                     goto cleanup;
                 }