replace string conversion for array Variants with JSON

Framework/Core/include/Framework/VariantJSONHelpers.h

@@ -160,22 +160,19 @@ struct VariantReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Va
           if (currentKey == labels_rows_str) {
             labels_rows.push_back(str);
             return true;
-          } else if (currentKey == labels_cols_str) {
+          }
+          if (currentKey == labels_cols_str) {
             labels_cols.push_back(str);
             return true;
-          } else if (currentKey == "values") {
-            if constexpr (std::is_same_v<std::string, variant_array_element_type_t<V>>) {
-              accumulatedData.push_back(str);
-            } else {
-              states.push(State::IN_ERROR);
-            }
-            return true;
+          }
+        }
+        if (currentKey == "values") {
+          if constexpr (std::is_same_v<std::string, variant_array_element_type_t<V>>) {
+            accumulatedData.push_back(str);
           } else {
             states.push(State::IN_ERROR);
-            return true;
           }
-        } else {
-          accumulatedData.push_back(str);
+          return true;
         }
         return true;
       }

Framework/Core/src/PropertyTreeHelpers.cxx

@@ -11,9 +11,9 @@
 
 #include "PropertyTreeHelpers.h"
 #include "Framework/ConfigParamSpec.h"
-#include "Framework/VariantStringHelpers.h"
 #include "Framework/VariantPropertyTreeHelpers.h"
 #include "Framework/RuntimeError.h"
+#include "Framework/VariantJSONHelpers.h"
 
 #include <boost/program_options/variables_map.hpp>
 
@@ -22,7 +22,16 @@
 
 namespace o2::framework
 {
-
+namespace {
+/// Helper to get a Variant from a @a str
+template <VariantType T>
+inline Variant fromString(std::string const& str)
+{
+  std::stringstream ss;
+  ss.str(str);
+  return VariantJSONHelpers::read<T>(ss);
+}
+}
 void PropertyTreeHelpers::populateDefaults(std::vector<ConfigParamSpec> const& schema,
                                            boost::property_tree::ptree& pt,
                                            boost::property_tree::ptree& provenance)
@@ -177,28 +186,73 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
           pt.put(key, vmap[key].as<bool>());
           break;
         case VariantType::ArrayInt:
-          pt.put_child(key, vectorToBranch<int>(stringToVector<int>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayInt>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<int>(v.get<int*>(), v.size()));
+        }
           break;
         case VariantType::ArrayFloat:
-          pt.put_child(key, vectorToBranch<float>(stringToVector<float>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayFloat>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<float>(v.get<float*>(), v.size()));
+        }
           break;
         case VariantType::ArrayDouble:
-          pt.put_child(key, vectorToBranch<double>(stringToVector<double>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayDouble>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<double>(v.get<double*>(), v.size()));
+        }
           break;
         case VariantType::ArrayBool:
           //          pt.put_child(key, vectorToBranch<bool>(stringToVector<bool>(vmap[key].as<std::string>())));
           break;
         case VariantType::ArrayString:
-          pt.put_child(key, vectorToBranch<std::string>(stringToVector<std::string>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayString>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<std::string>(v.get<std::string*>(), v.size()));
+        }
           break;
         case VariantType::Array2DInt:
-          pt.put_child(key, array2DToBranch<int>(stringToArray2D<int>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::Array2DInt>(vmap[key].as<std::string>());
+          pt.put_child(key, array2DToBranch<int>(v.get<Array2D<int>>()));
+        }
           break;
         case VariantType::Array2DFloat:
-          pt.put_child(key, array2DToBranch<float>(stringToArray2D<float>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::Array2DFloat>(vmap[key].as<std::string>());
+          pt.put_child(key, array2DToBranch<float>(v.get<Array2D<float>>()));
+        }
           break;
         case VariantType::Array2DDouble:
-          pt.put_child(key, array2DToBranch<double>(stringToArray2D<double>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::Array2DDouble>(vmap[key].as<std::string>());
+          pt.put_child(key, array2DToBranch<double>(v.get<Array2D<double>>()));
+        }
+          break;
+        case VariantType::LabeledArrayInt:
+        {
+          auto v = fromString<VariantType::LabeledArrayInt>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<int>>()));
+        }
+          break;
+        case VariantType::LabeledArrayFloat:
+        {
+          auto v = fromString<VariantType::LabeledArrayFloat>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<float>>()));
+        }
+          break;
+        case VariantType::LabeledArrayDouble:
+        {
+          auto v = fromString<VariantType::LabeledArrayDouble>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<double>>()));
+        }
+          break;
+        case VariantType::LabeledArrayString:
+        {
+          auto v = fromString<VariantType::LabeledArrayString>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<std::string>>()));
+        }
           break;
         case VariantType::Dict:
           pt.put_child(key, vmap[key].as<boost::property_tree::ptree>());

Framework/Core/src/PropertyTreeHelpers.h

@@ -23,7 +23,7 @@ namespace o2::framework
 
 /// Helpers to manipulate property_trees.
 struct PropertyTreeHelpers {
-  /// For all the options specified in @a schama, this fills
+  /// For all the options specified in @a schema, this fills
   /// @a tree with the contents of @a vmap, which is populated via boost
   /// program options. Any key in the @a schema will be marked as
   /// "default" in the provenance ptree.

Framework/Core/src/Variant.cxx

@@ -10,46 +10,12 @@
 // or submit itself to any jurisdiction.
 #include "Framework/Variant.h"
 #include "Framework/VariantPropertyTreeHelpers.h"
+#include "Framework/VariantJSONHelpers.h"
 #include <iostream>
 #include <sstream>
 
 namespace o2::framework
 {
-
-namespace
-{
-template <typename T>
-void printArray(std::ostream& oss, T* array, size_t size)
-{
-  oss << variant_array_symbol<T>::symbol << "[";
-  oss << array[0];
-  for (auto i = 1U; i < size; ++i) {
-    oss << ", " << array[i];
-  }
-  oss << "]";
-}
-
-template <typename T>
-void printMatrix(std::ostream& oss, Array2D<T> const& m)
-{
-  oss << variant_array_symbol<T>::symbol << "[[";
-  oss << m(0, 0);
-  for (auto j = 1U; j < m.cols; ++j) {
-    oss << ", " << m(0, j);
-  }
-  oss << "]";
-  for (auto i = 1U; i < m.rows; ++i) {
-    oss << ", [";
-    oss << m(i, 0);
-    for (auto j = 1U; j < m.cols; ++j) {
-      oss << ", " << m(i, j);
-    }
-    oss << "]";
-  }
-  oss << "]";
-}
-} // namespace
-
 std::ostream& operator<<(std::ostream& oss, Variant const& val)
 {
   switch (val.type()) {
@@ -90,28 +56,14 @@ std::ostream& operator<<(std::ostream& oss, Variant const& val)
       oss << val.get<bool>();
       break;
     case VariantType::ArrayInt:
-      printArray<int>(oss, val.get<int*>(), val.size());
-      break;
     case VariantType::ArrayFloat:
-      printArray<float>(oss, val.get<float*>(), val.size());
-      break;
     case VariantType::ArrayDouble:
-      printArray<double>(oss, val.get<double*>(), val.size());
-      break;
     case VariantType::ArrayBool:
-      printArray<bool>(oss, val.get<bool*>(), val.size());
-      break;
     case VariantType::ArrayString:
-      printArray<std::string>(oss, val.get<std::string*>(), val.size());
-      break;
     case VariantType::Array2DInt:
-      printMatrix<int>(oss, val.get<Array2D<int>>());
-      break;
     case VariantType::Array2DFloat:
-      printMatrix<float>(oss, val.get<Array2D<float>>());
-      break;
     case VariantType::Array2DDouble:
-      printMatrix<double>(oss, val.get<Array2D<double>>());
+      VariantJSONHelpers::write(oss, val);
       break;
     case VariantType::Empty:
       break;

Framework/Core/test/test_Variants.cxx

@@ -11,7 +11,6 @@
 
 #include <catch_amalgamated.hpp>
 #include "Framework/Variant.h"
-#include "Framework/VariantStringHelpers.h"
 #include "Framework/VariantPropertyTreeHelpers.h"
 #include "Framework/VariantJSONHelpers.h"
 #include <sstream>
@@ -168,7 +167,7 @@ TEST_CASE("VariantTest")
   }
   std::stringstream ssm;
   ssm << vmma;
-  REQUIRE(ssm.str() == "f[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8], [0.9, 1, 1.1, 1.2]]");
+  REQUIRE(ssm.str() == "{\"values\":[[0.10000000149011612,0.20000000298023225,0.30000001192092898,0.4000000059604645],[0.5,0.6000000238418579,0.699999988079071,0.800000011920929],[0.8999999761581421,1.0,1.100000023841858,1.2000000476837159]]}");
 
   LabeledArray<float> laf{&m[0][0], 3, 4, {"r1", "r2", "r3"}, {"c1", "c2", "c3", "c4"}};
   Variant vlaf(laf);
@@ -253,7 +252,7 @@ TEST_CASE("LabeledArrayTest")
 
 TEST_CASE("VariantTreeConversionsTest")
 {
-  std::vector<std::string> vstrings{"0.1", "0.2", "0.3"};
+  std::vector<std::string> vstrings{"0 1", "0 2", "0 3"};
   Variant vvstr(std::move(vstrings));
 
   auto tree = vectorToBranch(vvstr.get<std::string*>(), vvstr.size());
@@ -326,7 +325,7 @@ TEST_CASE("VariantJSONConversionsTest")
     }
   }
 
-  std::vector<std::string> vstrings{"s1", "s2", "s3"};
+  std::vector<std::string> vstrings{"myoption_one", "myoption_two"};
   Variant vvstr(vstrings);
   std::stringstream osal;
   VariantJSONHelpers::write(osal, vvstr);