fixup

Author: Levi-Armstrong

tesseract_collision/core/src/contact_managers_plugin_factory.cpp

@@ -33,7 +33,7 @@ TESSERACT_COMMON_IGNORE_WARNINGS_POP
 #include <tesseract_collision/core/continuous_contact_manager.h>
 #include <tesseract_common/resource_locator.h>
 #include <tesseract_common/yaml_utils.h>
-#include <tesseract_common/yaml_extenstions.h>
+#include <tesseract_common/yaml_extensions.h>
 #include <tesseract_common/property_tree.h>
 #include <tesseract_collision/core/contact_managers_plugin_factory.h>
 #include <boost_plugin_loader/plugin_loader.hpp>

tesseract_common/CMakeLists.txt

@@ -101,6 +101,7 @@ add_library(
   src/stopwatch.cpp
   src/types.cpp
   src/timer.cpp
+  src/yaml_extensions.cpp
   src/yaml_utils.cpp)
 target_link_libraries(
   ${PROJECT_NAME}

tesseract_common/include/tesseract_common/property_tree.h

@@ -14,19 +14,27 @@ namespace tesseract_common
 namespace property_type
 {
 /**
- * @brief A utility for constructing the std::vector<type>
+ * @brief A utility for constructing the vector<type>
  * @param type The type assoicated with the list
- * @return The string representation of the std::vector<type>, aka. type[]
+ * @param length The length if fixed size
+ * @return The string representation of the vector<type>, aka. type[] and type[length] for fixed size
  */
-std::string createList(std::string_view type);
+std::string createList(std::string_view type, std::size_t length = 0);
 
 /**
- * @brief A utility for constructing the std::map<std::string, type>
+ * @brief A utility for constructing the map<std::string, type>
  * @param type The value type assoicated with the map
- * @return The string representation of the std::map<std::string, type>, aka. type{}
+ * @return The string representation of the map<std::string, type>, aka. {string,string}
  */
 std::string createMap(std::string_view type);
 
+/**
+ * @brief A utility for constructing the map<key, type>
+ * @param type The value type assoicated with the map
+ * @return The string representation of the map<key, type>, aka. {string, string} or {string[2], string}
+ */
+std::string createMap(std::string_view key, std::string_view type);
+
 // Integral Types
 constexpr std::string_view BOOL{ "bool" };
 constexpr std::string_view CHAR{ "char" };
@@ -272,16 +280,16 @@ class PropertyTree
 /**
  * @brief Check if type is a sequence
  * @param type The type to check
- * @return If it is a sequence, the underlying type is returned
+ * @return If it is a sequence, the underlying type is returned and size
  */
-std::optional<std::string> isSequenceType(std::string_view type);
+std::optional<std::pair<std::string, std::size_t>> isSequenceType(std::string_view type);
 
 /**
  * @brief Check if type is a map
  * @param type The type to check
- * @return If it is a map, the underlying type is returned
+ * @return If it is a map, the underlying pair<key,type> is returned
  */
-std::optional<std::string> isMapType(std::string_view type);
+std::optional<std::pair<std::string, std::string>> isMapType(std::string_view type);
 
 /**
  * @brief Validator: ensure 'required' attribute is present and non-null.
@@ -307,9 +315,10 @@ void validateMap(const PropertyTree& node);
 /**
  * @brief Validtor: ensure node value is of type YAML::NodeType::Sequence
  * @param node Node to validate.
+ * @param length The length if fixed size. If zero, it is considered dynamic size sequence
  * @throws runtime_error if not correct type.
  */
-void validateSequence(const PropertyTree& node);
+void validateSequence(const PropertyTree& node, std::size_t length = 0);
 
 /**
  * @brief Validator: ensure property is a container of child properties

tesseract_common/include/tesseract_common/schema_registration.h

@@ -17,12 +17,18 @@ struct SchemaRegistrar
 
 }  // namespace tesseract_common
 
+// first level: does the actual pasting
+#define _SCHEMA_REG_PASTE(a, b) a##b
+
+// second level: expands its arguments before passing to the first
+#define _SCHEMA_REG_MAKE_NAME(a, b) _SCHEMA_REG_PASTE(a, b)
+
 /// 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 {                                                                          \
+  static const int _SCHEMA_REG_MAKE_NAME(_schema_reg_, __COUNTER__) = []() -> int {                                    \
     using namespace tesseract_common;                                                                                  \
     /* calls the appropriate SchemaRegistrar constructor */                                                            \
     SchemaRegistrar(#KEY, SCHEMA_SOURCE);                                                                              \

tesseract_common/include/tesseract_common/yaml_extenstions.h renamed to tesseract_common/include/tesseract_common/yaml_extensions.h

@@ -1,5 +1,5 @@
 /**
- * @file yaml_extenstions.h
+ * @file yaml_extensions.h
  * @brief YAML Type conversions
  *
  * @author Levi Armstrong
@@ -982,6 +982,40 @@ struct convert<tesseract_common::PairsCollisionMarginData>
     }
     return true;
   }
+
+  static tesseract_common::PropertyTree schema()
+  {
+    using namespace tesseract_common;
+    using namespace property_attribute;
+    using namespace property_type;
+
+    // top‐level must be a map container
+    PropertyTree sch;
+    sch.setAttribute(TYPE, "tesseract_common::PairsCollisionMarginData");
+    sch.addValidator([](const PropertyTree& node) {
+      const YAML::Node& yn = node.getValue();
+      if (!yn.IsMap())
+        std::throw_with_nested(std::runtime_error("PairsCollisionMarginData, must be a map"));
+
+      for (auto it = yn.begin(); it != yn.end(); ++it)
+      {
+        Node key_node = it->first;
+        if (!key_node.IsSequence() || key_node.size() != 2)
+          std::throw_with_nested(std::runtime_error("PairsCollisionMarginData, key must be a sequenc of size 2"));
+
+        try
+        {
+          it->second.as<double>();
+        }
+        catch (const std::exception& e)
+        {
+          std::throw_with_nested(e);
+        }
+      }
+    });
+
+    return sch;
+  }
 };
 
 //================================== CollisionMarginPairData =================================
@@ -1000,6 +1034,19 @@ struct convert<tesseract_common::CollisionMarginPairData>
     rhs = tesseract_common::CollisionMarginPairData(data);
     return true;
   }
+
+  static tesseract_common::PropertyTree schema()
+  {
+    using namespace tesseract_common;
+    using namespace property_attribute;
+    using namespace property_type;
+
+    // top‐level must be a map container
+    PropertyTree sch;
+    sch.setAttribute(TYPE, "tesseract_common::PairsCollisionMarginData");
+
+    return sch;
+  }
 };
 
 //============================ AllowedCollisionEntries ============================
@@ -1044,6 +1091,40 @@ struct convert<tesseract_common::AllowedCollisionEntries>
     }
     return true;
   }
+
+  static tesseract_common::PropertyTree schema()
+  {
+    using namespace tesseract_common;
+    using namespace property_attribute;
+    using namespace property_type;
+
+    // top‐level must be a map container
+    PropertyTree sch;
+    sch.setAttribute(TYPE, "tesseract_common::AllowedCollisionEntries");
+    sch.addValidator([](const PropertyTree& node) {
+      const YAML::Node& yn = node.getValue();
+      if (!yn.IsMap())
+        std::throw_with_nested(std::runtime_error("AllowedCollisionEntries, must be a map"));
+
+      for (auto it = yn.begin(); it != yn.end(); ++it)
+      {
+        Node key_node = it->first;
+        if (!key_node.IsSequence() || key_node.size() != 2)
+          std::throw_with_nested(std::runtime_error("AllowedCollisionEntries, key must be a sequenc of size 2"));
+
+        try
+        {
+          it->second.as<std::string>();
+        }
+        catch (const std::exception& e)
+        {
+          std::throw_with_nested(e);
+        }
+      }
+    });
+
+    return sch;
+  }
 };
 
 //================================== AllowedCollisionMatrix =================================
@@ -1062,6 +1143,19 @@ struct convert<tesseract_common::AllowedCollisionMatrix>
     rhs = tesseract_common::AllowedCollisionMatrix(data);
     return true;
   }
+
+  static tesseract_common::PropertyTree schema()
+  {
+    using namespace tesseract_common;
+    using namespace property_attribute;
+    using namespace property_type;
+
+    // top‐level must be a map container
+    PropertyTree sch;
+    sch.setAttribute(TYPE, "tesseract_common::AllowedCollisionEntries");
+
+    return sch;
+  }
 };
 
 //============================== std::unordered_map =============================

tesseract_common/src/plugin_info.cpp

@@ -40,7 +40,7 @@ TESSERACT_COMMON_IGNORE_WARNINGS_POP
 #include <tesseract_common/utils.h>
 #include <tesseract_common/plugin_info.h>
 #include <tesseract_common/yaml_utils.h>
-#include <tesseract_common/yaml_extenstions.h>
+#include <tesseract_common/yaml_extensions.h>
 #include <tesseract_common/property_tree.h>
 
 namespace tesseract_common