fixup

Author: Levi-Armstrong

tesseract_common/CMakeLists.txt

@@ -96,6 +96,7 @@ add_library(
   src/profile.cpp
   src/property_tree.cpp
   src/resource_locator.cpp
+  src/schema_registration.cpp
   src/schema_registry.cpp
   src/stopwatch.cpp
   src/types.cpp

tesseract_common/include/tesseract_common/fwd.h

@@ -80,6 +80,12 @@ class Timer;
 // Profile Dictionary
 class Profile;
 class ProfileDictionary;
+
+// property_tree.h
+class PropertyTree;
+
+// schema_registry.h
+class SchemaRegistry;
 }  // namespace tesseract_common
 
 #endif  // TESSERACT_COMMON_TESSERACT_COMMON_FWD_H

tesseract_common/include/tesseract_common/property_tree.h

@@ -13,6 +13,21 @@ namespace tesseract_common
 {
 namespace property_type
 {
+/**
+ * @brief A utility for constructing the list type
+ * @param type The type assoicated with the list
+ * @return The string representation of the std::vector<type>, aka. type[]
+ */
+std::string createList(std::string_view type);
+
+/**
+ * @brief A utility for constructing the map type
+ * @param key_type The type assoicated with the map key
+ * @param value_type The type assoicated with the map value
+ * @return The string representation of the std::make<key_type, value_type>, aka. {key_type : value_type}
+ */
+std::string createMap(std::string_view key_type, std::string_view value_type);
+
 // Integral Types
 constexpr std::string_view BOOL{ "bool" };
 constexpr std::string_view CHAR{ "char" };
@@ -26,11 +41,11 @@ constexpr std::string_view DOUBLE{ "double" };
 
 // Eigen Types
 constexpr std::string_view EIGEN_ISOMETRY_3D{ "Eigen::Isometry3d" };
-constexpr std::string_view EIGEN_MATRIX_XD{ "Eigen::MatrixXd" };
+// constexpr std::string_view EIGEN_MATRIX_XD{ "Eigen::MatrixXd" };
 constexpr std::string_view EIGEN_VECTOR_XD{ "Eigen::VectorXd" };
-constexpr std::string_view EIGEN_MATRIX_2D{ "Eigen::Matrix2d" };
+// constexpr std::string_view EIGEN_MATRIX_2D{ "Eigen::Matrix2d" };
 constexpr std::string_view EIGEN_VECTOR_2D{ "Eigen::Vector2d" };
-constexpr std::string_view EIGEN_MATRIX_3D{ "Eigen::Matrix3d" };
+// constexpr std::string_view EIGEN_MATRIX_3D{ "Eigen::Matrix3d" };
 constexpr std::string_view EIGEN_VECTOR_3D{ "Eigen::Vector3d" };
 }  // namespace property_type
 
@@ -77,21 +92,22 @@ class PropertyTree
   PropertyTree() = default;
 
   /**
-   * @brief Merge schema metadata into this node.
-   *
-   * Copies attributes from the schema, applies defaults for non-required
-   * properties, registers schema validators, and recursively merges children.
-   * @param schema  PropertyTree containing schema definitions.
+   * @brief Given that *this* is purely a schema tree, merge in the
+   *        user’s YAML config to populate all values (and apply defaults).
+   * @param config  The user-supplied YAML::Node (possibly null).
+   * @param allow_extra_properties  If false, “extra” keys in config will be flagged.
    */
-  void mergeSchema(const PropertyTree& schema);
+  void mergeConfig(const YAML::Node& config, bool allow_extra_properties = false);
 
   /**
    * @brief Validate the tree using registered validators.
    *
    * Recursively invokes all validators on this node and its children.
    * Throws on the first error encountered.
+   *
+   * @param allow_extra_properties Indicate if extra properties are allowed
    */
-  void validate() const;
+  void validate(bool allow_extra_properties = false) const;
 
   /**
    * @brief Register a custom validator for this node.
@@ -139,6 +155,12 @@ class PropertyTree
    */
   bool isNull() const;
 
+  /**
+   * @brief Check if property is a container of child properties
+   * @return True if container, otherwise false
+   */
+  bool isContainer() const;
+
   /**
    * @brief List all immediate child keys.
    * @return Vector of child key strings.
@@ -204,11 +226,19 @@ class PropertyTree
 
 private:
   YAML::Node value_;                             /**< Value stored at this node */
+  YAML::Node follow_;                            /**< Follow stored at this node */
   std::map<std::string, YAML::Node> attributes_; /**< Metadata attributes */
   std::map<std::string, PropertyTree> children_; /**< Nested child nodes */
   std::vector<ValidatorFn> validators_;          /**< Validators to invoke */
 };
 
+/**
+ * @brief Check if type is a sequence
+ * @param type The type to check
+ * @return If it is a sequence the underlying type is returned
+ */
+std::optional<std::string> isSequenceType(std::string_view type);
+
 /**
  * @brief Validator: ensure 'required' attribute is present and non-null.
  * @param node  Node to validate.
@@ -217,18 +247,86 @@ class PropertyTree
 void validateRequired(const PropertyTree& node);
 
 /**
- * @brief Validator: enforce 'minimum'/'maximum' range constraints.
+ * @brief Validator: enforce that node's value is in 'enum' list.
  * @param node  Node to validate.
- * @throws runtime_error if out of range.
+ * @throws runtime_error if not found.
+ */
+void validateEnum(const PropertyTree& node);
+
+/**
+ * @brief Validtor: ensure node value is of type YAML::NodeType::Map
+ * @param node Node to validate.
+ * @throws runtime_error if not correct type.
  */
-void validateRange(const PropertyTree& node);
+void validateMap(const PropertyTree& node);
 
 /**
- * @brief Validator: enforce that node's value is in 'enum' list.
+ * @brief Validtor: ensure node value is of type YAML::NodeType::Sequence
+ * @param node Node to validate.
+ * @throws runtime_error if not correct type.
+ */
+void validateSequence(const PropertyTree& node);
+
+void validateCustomType(const PropertyTree& node);
+
+/**
+ * @brief Validate that the node’s value can be interpreted as the provided type.
+ * @param node  PropertyTree node whose value to validate.
+ * @throws std::runtime_error or YAML::BadConversion if the value is not a valid type.
+ */
+template <typename T>
+void validateTypeCast(const PropertyTree& node)
+{
+  try
+  {
+    node.getValue().as<T>();
+  }
+  catch (const std::exception& e)
+  {
+    std::throw_with_nested(e);
+  }
+}
+
+/**
+ * @brief Validator: type cast and enforce 'minimum'/'maximum' range constraints.
  * @param node  Node to validate.
- * @throws runtime_error if not found.
+ * @throws runtime_error if out of range.
  */
-void validateEnum(const PropertyTree& node);
+template <typename T>
+void validateTypeCastWithRange(const PropertyTree& node)
+{
+  // Get value
+  const T val = [&]() {
+    try
+    {
+      return node.getValue().as<T>();
+    }
+    catch (const std::exception& e)
+    {
+      std::throw_with_nested(e);
+    }
+  }();
+
+  // If minimum attribute exist, validate
+  auto min_attr = node.getAttribute(property_attribute::MINIMUM);
+  if (min_attr)
+  {
+    const auto minv = min_attr->as<T>();
+    if (val < minv)
+      std::throw_with_nested(std::runtime_error("Property value " + std::to_string(val) + " is less than minimum " +
+                                                std::to_string(minv)));
+  }
+
+  // If maximum attribute exist, validate
+  auto max_attr = node.getAttribute(property_attribute::MAXIMUM);
+  if (max_attr)
+  {
+    const auto maxv = max_attr->as<T>();
+    if (val > maxv)
+      std::throw_with_nested(std::runtime_error("Property value " + std::to_string(val) + " is greater than maximum " +
+                                                std::to_string(maxv)));
+  }
+}
 
 }  // namespace tesseract_common
 

tesseract_common/include/tesseract_common/schema_registration.h

@@ -0,0 +1,33 @@
+#ifndef TESSERACT_COMMON_SCHEMA_REGISTRATION_H
+#define TESSERACT_COMMON_SCHEMA_REGISTRATION_H
+
+#include <string>
+#include <functional>
+
+namespace tesseract_common
+{
+class PropertyTree;
+
+struct SchemaRegistrar
+{
+  SchemaRegistrar(const std::string& key, const std::string& path);
+
+  SchemaRegistrar(const std::string& key, const std::function<PropertyTree()>& fn);
+};
+
+}  // namespace tesseract_common
+
+/// Macro to register either a file‐based schema or a function‐built schema
+#define TESSERACT_REGISTER_SCHEMA(KEY, SCHEMA_SOURCE)                                                                  \
+  namespace                                                                                                            \
+  {                                                                                                                    \
+  /* now a const POD, linter is happy */                                                                               \
+  static const int _reg_##KEY = []() -> int {                                                                          \
+    using namespace tesseract_common;                                                                                  \
+    /* calls the appropriate SchemaRegistrar constructor */                                                            \
+    SchemaRegistrar(#KEY, SCHEMA_SOURCE);                                                                              \
+    return 0;                                                                                                          \
+  }();                                                                                                                 \
+  }
+
+#endif  // TESSERACT_COMMON_SCHEMA_REGISTRATION_H