Add ParmParse.to_dict()

Convert the `ParmParse` entries to a dict. Use type hints whenever
possible to create a proper value variable. Only file inputs and
CLI inputs are string values that way.

Author: ax3l

src/Base/ParmParse.cpp

@@ -103,5 +103,53 @@ void init_ParmParse(py::module &m)
         )
 
         // TODO: dumpTable, hasUnusedInputs, getUnusedInputs, getEntries
+
+        .def(
+            "to_dict",
+            [](ParmParse &pp) {
+                py::dict d;
+
+                auto g_table = pp.table();
+
+                std::vector<std::string> sorted_names;
+                sorted_names.reserve(g_table.size());
+                for (auto const& [name, entry] : g_table) {
+                    sorted_names.push_back(name);
+                }
+                std::sort(sorted_names.begin(), sorted_names.end());
+
+                for (auto const& name : sorted_names) {
+                    auto const& entry = g_table[name];
+                    for (auto const & vals : entry.m_vals) {
+                        if (vals.size() == 1) {
+                            std::visit(
+                                [&d,&name,&pp](auto&& arg) {
+                                    using T = std::remove_pointer_t<std::decay_t<decltype(arg)>>;
+                                    T v;
+                                    pp.get(name.c_str(), v);
+                                    d[name.c_str()] = v;
+                                },
+                                entry.m_typehint
+                            );
+                        } else {
+                            std::visit(
+                                [&d,&name,&pp](auto&& arg) {
+                                    using T = std::remove_pointer_t<std::decay_t<decltype(arg)>>;
+                                    if constexpr (!std::is_same_v<T, bool>) {
+                                        std::vector<T> valarr;
+                                        pp.getarr(name.c_str(), valarr);
+                                        d[name.c_str()] = valarr;
+                                    }
+                                },
+                                entry.m_typehint
+                            );
+                        }
+                    }
+                }
+
+                return d;
+            },
+            "DOC GOES HERE TODO TODO"
+        )
     ;
 }

tests/test_parmparse.py

@@ -13,8 +13,36 @@ def test_parmparse():
     dt = pp_param.get_real("dt")
     dopml = pp_param.get_bool("do_pml")
 
+    pp_param.add("ncell", 42)  # overwrite file
+    pp_param.add(
+        "question", "What is the answer to life, the universe, and everything?"
+    )
+    pp_param.add("answer", 41)
+    pp_param.add("answer", 42)  # last wins
+    pp_param.add("pi_approx", 3.1415)
+    pp_param.addarr("floats", [1.0, 2.0, 3.0])
+    pp_param.addarr("ints", [4, 5, 6])
+    pp_param.addarr("strs", ["Who", "Where", "What", "When", "How"])
+
     assert dopml
     assert dt == 1.0e-5
     assert ncell == 100
 
+    # printing
     pp.pretty_print_table()
+
+    # type hints
+    d = pp.to_dict()
+    assert isinstance(d["param.ncell"], int)  # overwritten
+    assert isinstance(d["param.dt"], str)  # file
+    assert isinstance(d["param.do_pml"], str)  # file
+    assert isinstance(d["param.question"], str)
+    assert isinstance(d["param.answer"], int)
+    assert d["param.answer"] == 42  # last wins
+    assert isinstance(d["param.pi_approx"], float)
+    assert isinstance(d["param.floats"], list)
+    assert isinstance(d["param.ints"], list)
+    assert isinstance(d["param.strs"], list)
+    assert d["param.floats"] == [1.0, 2.0, 3.0]
+    assert d["param.ints"] == [4, 5, 6]
+    assert d["param.strs"] == ["Who", "Where", "What", "When", "How"]