Move C++ layer to Node Tree architecture and delete CompactStructStore

Author: aylindmello

cpp/mexfunctions/readtomlMex.cpp

@@ -29,7 +29,7 @@ class MexFunction : public matlab::mex::Function {
         std::istringstream iss(std::move(content));
         toml::ordered_value data = toml::parse<toml::ordered_type_config>(iss, filename);
 
-        outputs[0] = tableToCompactStruct(data);
+        outputs[0] = tableToNode(data);
     }
 
 private:
@@ -55,47 +55,33 @@ class MexFunction : public matlab::mex::Function {
         }
     }
 
-    matlab::data::Array tableToCompactStruct(const toml::ordered_value& table) {
+    matlab::data::Array tableToNode(const toml::ordered_value& table) {
         const auto& tbl = table.as_table();
         size_t n = tbl.size();
 
         auto keys = factory.createArray<matlab::data::MATLABString>({1, n});
         auto values = factory.createArray<matlab::data::Array>({1, n});
-        std::vector<double> nullIdx, datetimeIdx;
 
         size_t i = 0;
         for (const auto& [key, val] : tbl) {
             keys[0][i] = utf8ToMATLABString(key);
 
             if (val.type() == toml::value_t::table) {
-                values[0][i] = tableToCompactStruct(val);
+                values[0][i] = tableToNode(val);
             } else if (val.type() == toml::value_t::array) {
                 values[0][i] = convertArray(val.as_array());
             } else if (isDatetimeType(val.type())) {
-                datetimeIdx.push_back(static_cast<double>(i + 1));
-                values[0][i] = factory.createScalar(utf8ToMATLABString(datetimeToString(val)));
+                values[0][i] = makeValueNode(factory,
+                    factory.createScalar(
+                        utf8ToMATLABString(datetimeToString(val))),
+                    "datetime");
             } else {
                 values[0][i] = convertScalar(val);
             }
             ++i;
         }
 
-        auto nullArr = toDoubleArray(nullIdx);
-        auto dtArr = toDoubleArray(datetimeIdx);
-        auto emptyArr = factory.createArray<double>({1, 0});
-
-        return makeCompactStruct(factory, keys, values, nullArr, dtArr, emptyArr);
-    }
-
-    matlab::data::Array toDoubleArray(const std::vector<double>& vec) {
-        if (vec.empty()) {
-            return factory.createArray<double>({1, 0});
-        }
-        auto arr = factory.createArray<double>({1, vec.size()});
-        for (size_t i = 0; i < vec.size(); ++i) {
-            arr[0][i] = vec[i];
-        }
-        return arr;
+        return makeTableNode(factory, keys, values);
     }
 
     matlab::data::Array convertScalar(const toml::value& val) {
@@ -129,7 +115,7 @@ class MexFunction : public matlab::mex::Function {
             size_t count = arr.size();
             auto out = factory.createArray<matlab::data::Array>({1, count});
             for (size_t i = 0; i < count; ++i) {
-                out[0][i] = tableToCompactStruct(arr[i]);
+                out[0][i] = tableToNode(arr[i]);
             }
             return out;
         }
@@ -171,7 +157,7 @@ class MexFunction : public matlab::mex::Function {
         elems.reserve(arr.size());
         for (const auto& elem : arr) {
             if (elem.type() == toml::value_t::table) {
-                elems.push_back(tableToCompactStruct(elem));
+                elems.push_back(tableToNode(elem));
             } else if (elem.type() == toml::value_t::array) {
                 elems.push_back(convertArray(elem.as_array()));
             } else if (isDatetimeType(elem.type())) {

cpp/mexfunctions/readyamlMex.cpp

@@ -48,7 +48,7 @@ class MexFunction : public matlab::mex::Function {
             if (root.num_children() > 0) {
                 outputs[0] = convertNode(root.first_child());
             } else {
-                outputs[0] = makeEmptyCompactStruct();
+                outputs[0] = makeEmptyTableNode();
             }
         } else {
             outputs[0] = convertNode(root);
@@ -60,12 +60,10 @@ class MexFunction : public matlab::mex::Function {
         return std::string(s.data(), s.size());
     }
 
-    matlab::data::Array makeEmptyCompactStruct() {
+    matlab::data::Array makeEmptyTableNode() {
         auto keys = factory.createArray<matlab::data::MATLABString>({1, 0});
         auto values = factory.createArray<matlab::data::Array>({1, 0});
-        auto empty = factory.createArray<double>({1, 0});
-
-        return makeCompactStruct(factory, keys, values, empty, empty, empty);
+        return makeTableNode(factory, keys, values);
     }
 
     // --- YAML 1.1 boolean detection ---
@@ -150,15 +148,14 @@ class MexFunction : public matlab::mex::Function {
         if (node.has_val()) {
             return convertTypedScalar(node);
         }
-        return makeEmptyCompactStruct();
+        return makeEmptyTableNode();
     }
 
     matlab::data::Array convertMap(ryml::ConstNodeRef node) {
         size_t n = node.num_children();
 
         auto keys = factory.createArray<matlab::data::MATLABString>({1, n});
         auto values = factory.createArray<matlab::data::Array>({1, n});
-        std::vector<double> nullIdx;
 
         size_t i = 0;
         for (ryml::ConstNodeRef child : node.children()) {
@@ -170,33 +167,19 @@ class MexFunction : public matlab::mex::Function {
                 values[0][i] = convertSequence(child);
             } else if (child.has_val()) {
                 if (child.val_is_null()) {
-                    nullIdx.push_back(static_cast<double>(i + 1));
-                    values[0][i] = factory.createArray<double>({0, 0});
+                    values[0][i] = makeValueNode(factory,
+                        factory.createArray<double>({0, 0}), "missing");
                 } else {
                     values[0][i] = convertTypedScalar(child);
                 }
             } else {
-                nullIdx.push_back(static_cast<double>(i + 1));
-                values[0][i] = factory.createArray<double>({0, 0});
+                values[0][i] = makeValueNode(factory,
+                    factory.createArray<double>({0, 0}), "missing");
             }
             ++i;
         }
 
-        auto nullArr = toDoubleArray(nullIdx);
-        auto emptyArr = factory.createArray<double>({1, 0});
-
-        return makeCompactStruct(factory, keys, values, nullArr, emptyArr, emptyArr);
-    }
-
-    matlab::data::Array toDoubleArray(const std::vector<double>& vec) {
-        if (vec.empty()) {
-            return factory.createArray<double>({1, 0});
-        }
-        auto arr = factory.createArray<double>({1, vec.size()});
-        for (size_t i = 0; i < vec.size(); ++i) {
-            arr[0][i] = vec[i];
-        }
-        return arr;
+        return makeTableNode(factory, keys, values);
     }
 
     matlab::data::Array convertSequence(ryml::ConstNodeRef node) {
@@ -232,10 +215,6 @@ class MexFunction : public matlab::mex::Function {
             elems.push_back(convertNode(child));
         }
 
-        if (sequenceAsCell) {
-            return makeCellArray(elems, count);
-        }
-
         return makeCellArray(elems, count);
     }
 

cpp/mexfunctions/util.hpp

@@ -14,19 +14,32 @@ void throwMexError(
     const std::string& id,
     const std::string& msg);
 
-inline matlab::data::StructArray makeCompactStruct(
+inline matlab::data::StructArray makeTableNode(
     matlab::data::ArrayFactory& factory,
     matlab::data::Array keys,
-    matlab::data::Array values,
-    matlab::data::Array nullIndices,
-    matlab::data::Array datetimeIndices,
-    matlab::data::Array quotedIndices) {
-    auto cs = factory.createStructArray({1, 1},
-        {"Keys", "Values", "NullIndices", "DatetimeIndices", "QuotedIndices"});
-    cs[0]["Keys"] = std::move(keys);
-    cs[0]["Values"] = std::move(values);
-    cs[0]["NullIndices"] = std::move(nullIndices);
-    cs[0]["DatetimeIndices"] = std::move(datetimeIndices);
-    cs[0]["QuotedIndices"] = std::move(quotedIndices);
-    return cs;
+    matlab::data::Array values) {
+    auto node = factory.createStructArray({1, 1}, {"Keys", "Values"});
+    node[0]["Keys"] = std::move(keys);
+    node[0]["Values"] = std::move(values);
+    return node;
+}
+
+inline matlab::data::StructArray makeValueNode(
+    matlab::data::ArrayFactory& factory,
+    matlab::data::Array data,
+    const std::string& type) {
+    auto node = factory.createStructArray({1, 1}, {"Data", "Type"});
+    node[0]["Data"] = std::move(data);
+    node[0]["Type"] = factory.createScalar(utf8ToMATLABString(type));
+    return node;
+}
+
+inline bool structHasField(
+    const matlab::data::StructArray& sa,
+    const std::string& name) {
+    matlab::data::MATLABFieldIdentifier target(name);
+    for (const auto& f : sa.getFieldNames()) {
+        if (f == target) return true;
+    }
+    return false;
 }

cpp/mexfunctions/writetomlMex.cpp

@@ -3,6 +3,7 @@
 #include "toml.hpp"
 
 #include <cmath>
+#include <sstream>
 #include <vector>
 
 using matlab::data::ArrayType;
@@ -26,7 +27,7 @@ class MexFunction : public matlab::mex::Function {
         if (inputs.size() < 1) {
             throwMexError(*engine, factory,
                 "writetomlMex:InvalidInput",
-                "CompactStruct data required.");
+                "Node tree data required.");
             return;
         }
 
@@ -95,68 +96,67 @@ class MexFunction : public matlab::mex::Function {
             getOptionDouble(opts, "Precision"));
     }
 
-    // --- Index set helper ---
+    // --- Node tree dispatch ---
 
-    static std::vector<bool> buildIndexSet(
-            const matlab::data::Array& indices, size_t n) {
-        std::vector<bool> flags(n + 1, false);
-        if (indices.getNumberOfElements() > 0) {
-            matlab::data::TypedArray<double> idx = indices;
-            for (auto v : idx) {
-                size_t i = static_cast<size_t>(v);
-                if (i >= 1 && i <= n) flags[i] = true;
-            }
-        }
-        return flags;
-    }
-
-    // --- Conversion from CompactStruct ---
-
-    toml::ordered_value convertTable(const matlab::data::Array& csArr) {
-        matlab::data::StructArray cs(csArr);
+    toml::ordered_value convertTable(const matlab::data::Array& nodeArr) {
+        matlab::data::StructArray node(nodeArr);
 
         matlab::data::TypedArray<matlab::data::MATLABString> keys =
-            cs[0]["Keys"];
+            node[0]["Keys"];
         matlab::data::TypedArray<matlab::data::Array> values =
-            cs[0]["Values"];
+            node[0]["Values"];
 
         size_t n = keys.getNumberOfElements();
-        auto isNull = buildIndexSet(cs[0]["NullIndices"], n);
-        auto isDt = buildIndexSet(cs[0]["DatetimeIndices"], n);
-
         toml::ordered_table tbl;
+
         for (size_t i = 0; i < n; ++i) {
             std::string key = matlabStringToUtf8(keys[i]);
-
-            if (isNull[i + 1]) {
-                continue;
-            }
-
             matlab::data::Array val = values[i];
 
-            if (isDt[i + 1]) {
-                tbl.push_back({key, convertDatetime(val)});
-            } else {
-                tbl.push_back({key, convert(val)});
-            }
+            if (isMissingNode(val)) continue;
+
+            tbl.push_back({key, convert(val)});
         }
 
         return toml::ordered_value(std::move(tbl));
     }
 
+    bool isMissingNode(const matlab::data::Array& val) {
+        if (val.getType() != ArrayType::STRUCT) return false;
+        matlab::data::StructArray sa(val);
+        if (!structHasField(sa, "Data")) return false;
+        if (!structHasField(sa, "Type")) return false;
+        matlab::data::TypedArray<matlab::data::MATLABString> typeArr =
+            sa[0]["Type"];
+        return matlabStringToUtf8(typeArr[0]) == "missing";
+    }
+
     toml::ordered_value convert(const matlab::data::Array& val) {
         auto type = val.getType();
         size_t numel = val.getNumberOfElements();
 
         if (type == ArrayType::STRUCT) {
-            return convertTable(val);
+            matlab::data::StructArray sa(val);
+            if (structHasField(sa, "Keys")) {
+                return convertTable(val);
+            }
+            if (structHasField(sa, "Data")) {
+                return convertValueNodeData(sa);
+            }
+            throwMexError(*engine, factory,
+                "writetomlMex:UnrecognizedNode",
+                "Unrecognized struct in node tree.");
+            return toml::ordered_value();
         }
 
         if (type == ArrayType::CELL) {
             matlab::data::TypedArray<matlab::data::Array> cells = val;
             if (numel > 0 &&
                 cells[0].getType() == ArrayType::STRUCT) {
-                return convertObjectArray(val, numel);
+                matlab::data::StructArray firstSa(cells[0]);
+                if (structHasField(firstSa, "Keys")) {
+                    return convertObjectArray(val, numel);
+                }
             }
             return convertCellArray(val, numel);
         }
@@ -221,6 +221,42 @@ class MexFunction : public matlab::mex::Function {
         }
     }
 
+    // --- ValueNode handling ---
+
+    toml::ordered_value convertValueNodeData(
+            const matlab::data::StructArray& node) {
+        if (structHasField(node, "Type")) {
+            matlab::data::TypedArray<matlab::data::MATLABString> typeArr =
+                node[0]["Type"];
+            std::string nodeType = matlabStringToUtf8(typeArr[0]);
+
+            if (nodeType == "missing") {
+                return toml::ordered_value();
+            }
+
+            if (nodeType == "datetime") {
+                matlab::data::Array data = node[0]["Data"];
+                if (data.getType() == ArrayType::MATLAB_STRING) {
+                    std::string dtStr = matlabStringToUtf8(
+                        matlab::data::TypedArray<matlab::data::MATLABString>(
+                            data)[0]);
+                    return parseDatetimeFromString(dtStr);
+                }
+                return convertDatetime(data);
+            }
+        }
+
+        matlab::data::Array data = node[0]["Data"];
+        return convert(data);
+    }
+
+    toml::ordered_value parseDatetimeFromString(const std::string& dtStr) {
+        std::string doc = "v = " + dtStr + "\n";
+        std::istringstream iss(doc);
+        auto parsed = toml::parse<toml::ordered_type_config>(iss, "");
+        return parsed.at("v");
+    }
+
     // --- Scalar converters ---
 
     toml::ordered_value convertDouble(double v) {