Update property tree to leverage nested exceptions during validation

Author: Levi-Armstrong

tesseract_common/include/tesseract_common/property_tree.h

@@ -29,13 +29,13 @@ constexpr std::string_view MAXIMUM{ "maximum" };
 class PropertyTree
 {
 public:
-  using ValidatorFn = std::function<bool(const PropertyTree&, std::vector<std::string>&, const std::string&)>;
+  using ValidatorFn = std::function<void(const PropertyTree&)>;
 
   PropertyTree() = default;
 
   void mergeSchema(const PropertyTree& schema);
 
-  bool validate(std::vector<std::string>& errors, const std::string& path = "") const;
+  void validate() const;
 
   void addValidator(ValidatorFn fn);
 
@@ -69,11 +69,11 @@ class PropertyTree
   std::vector<ValidatorFn> validators_;
 };
 
-bool validateRequired(const PropertyTree& node, std::vector<std::string>& errors, const std::string& path);
+void validateRequired(const PropertyTree& node);
 
-bool validateRange(const PropertyTree& node, std::vector<std::string>& errors, const std::string& path);
+void validateRange(const PropertyTree& node);
 
-bool validateEnum(const PropertyTree& node, std::vector<std::string>& errors, const std::string& path);
+void validateEnum(const PropertyTree& node);
 
 }  // namespace tesseract_common
 

tesseract_common/src/property_tree.cpp

@@ -42,23 +42,24 @@ void PropertyTree::mergeSchema(const PropertyTree& schema)
   }
 }
 
-bool PropertyTree::validate(std::vector<std::string>& errors, const std::string& path) const
+void PropertyTree::validate() const
 {
-  bool ok = true;
   // run custom validators
   for (const auto& vfn : validators_)
-  {
-    if (!vfn(*this, errors, path))
-      ok = false;
-  }
+    vfn(*this);
+
   // recurse children
   for (const auto& kv : children_)
   {
-    const std::string nextPath = path.empty() ? kv.first : path + "." + kv.first;
-    if (!kv.second.validate(errors, nextPath))
-      ok = false;
+    try
+    {
+      kv.second.validate();
+    }
+    catch (...)
+    {
+      std::throw_with_nested(std::runtime_error("Validation failed for property: " + kv.first));
+    }
   }
-  return ok;
 }
 
 /// Add a custom validator for this node
@@ -184,22 +185,18 @@ YAML::Node PropertyTree::toYAML() const
   return value_;
 }
 
-bool validateRequired(const PropertyTree& node, std::vector<std::string>& errors, const std::string& path)
+void validateRequired(const PropertyTree& node)
 {
   auto req_attr = node.getAttribute(property_attribute::REQUIRED);
   if (req_attr && req_attr->as<bool>())
   {
     // if leaf node with no value or null
     if (!node.getValue() || node.getValue().IsNull())
-    {
-      errors.push_back(path + ": required property missing or null");
-      return false;
-    }
+      std::throw_with_nested(std::runtime_error("Required property missing or null"));
   }
-  return true;
 }
 
-bool validateRange(const PropertyTree& node, std::vector<std::string>& errors, const std::string& path)
+void validateRange(const PropertyTree& node)
 {
   auto min_attr = node.getAttribute(property_attribute::MINIMUM);
   auto max_attr = node.getAttribute(property_attribute::MAXIMUM);
@@ -210,15 +207,13 @@ bool validateRange(const PropertyTree& node, std::vector<std::string>& errors, c
     const auto val = node.getValue().as<double>();
     if (val < minv || val > maxv)
     {
-      errors.push_back(path + ": value " + std::to_string(val) + " out of range [" + std::to_string(minv) + "," +
-                       std::to_string(maxv) + "]");
-      return false;
+      std::throw_with_nested(std::runtime_error("Property value " + std::to_string(val) + " out of range [" +
+                                                std::to_string(minv) + "," + std::to_string(maxv) + "]"));
     }
   }
-  return true;
 }
 
-bool validateEnum(const PropertyTree& node, std::vector<std::string>& errors, const std::string& path)
+void validateEnum(const PropertyTree& node)
 {
   auto enum_attr = node.getAttribute(property_attribute::ENUM);
   if (enum_attr.has_value() && enum_attr->IsSequence())
@@ -227,12 +222,10 @@ bool validateEnum(const PropertyTree& node, std::vector<std::string>& errors, co
     for (const auto& v : enum_attr.value())
     {
       if (v.as<std::string>() == val)
-        return true;
+        return;
     }
-    errors.push_back(path + ": value '" + val + "' not in enum list");
-    return false;
+    std::throw_with_nested(std::runtime_error("Property value '" + val + "' not in enum list"));
   }
-  return true;
 }
 
 }  // namespace tesseract_common

tesseract_common/src/property_tree_demo.cpp

@@ -1,6 +1,7 @@
 #include <iostream>
 #include <yaml-cpp/yaml.h>
 #include <tesseract_common/property_tree.h>
+#include <tesseract_common/utils.h>
 
 using namespace tesseract_common;
 
@@ -68,6 +69,7 @@ PropertyTree buildConfigSchema()
     auto& prop = outs.get("program");
     prop.setAttribute("type", property_type::STRING);
     prop.setAttribute("required", true);
+    prop.addValidator(validateRequired);
   }
   // format_result_as_input
   {
@@ -97,10 +99,19 @@ std::string str2 = R"(config:
                            outputs:
                              program: output_data)";
 
+std::string str3 = R"(config:
+                           conditional: true
+                           inputs:
+                             program: input_data
+                             environment: environment
+                             profiles: profiles
+                           outputs:
+                             programs: output_data)";
+
 int main()
 {
   // Load configuration from YAML
-  PropertyTree prop = PropertyTree::fromYAML(YAML::Load(str2));
+  PropertyTree prop = PropertyTree::fromYAML(YAML::Load(str3));
 
   // Parse schema from external file (config_schema.yaml)
   PropertyTree schema = buildConfigSchema();
@@ -109,14 +120,23 @@ int main()
   prop.mergeSchema(schema);
   std::cout << prop.toYAML() << "\n";
 
-  std::vector<std::string> errors;
-  if (!prop.validate(errors, "config"))
+  try
   {
-    std::cerr << "Validation errors:\n";
-    for (auto const& e : errors)
-      std::cerr << " - " << e << "\n";
+    prop.validate();
+  }
+  catch (const std::exception& e)
+  {
+    tesseract_common::printNestedException(e);
     return 1;
   }
+
+  // if (!prop.validate(errors, "config"))
+  // {
+  //   std::cerr << "Validation errors:\n";
+  //   for (auto const& e : errors)
+  //     std::cerr << " - " << e << "\n";
+  //   return 1;
+  // }
   bool cond = prop.get("config").get("conditional").getValue().as<bool>();
   std::cout << "conditional = " << std::boolalpha << cond << "\n";
   return 0;