Add struct constructors and schema handling to LogValue and NetworkTablesReceiver for nested schemas

Author: SticksDev

.vscode/settings.json

@@ -6,5 +6,8 @@
     "**/.settings": true,
     "**/.factorypath": true
   },
-  "C_Cpp.default.configurationProvider": "vscode-wpilib"
+  "C_Cpp.default.configurationProvider": "vscode-wpilib",
+  "files.associations": {
+    "vector": "cpp"
+  }
 }

src/main/native/cpp/core/LogValue.cpp

@@ -64,6 +64,13 @@ LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString
   : m_type(LogType::kStruct), m_value(data), m_typeString(typeString),
     m_schema(schema.begin(), schema.end()) {}
 
+// Struct constructor with all schemas (including nested)
+LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
+                   std::span<const uint8_t> schema,
+                   const std::unordered_map<std::string, std::vector<uint8_t>>& nestedSchemas)
+  : m_type(LogType::kStruct), m_value(data), m_typeString(typeString),
+    m_schema(schema.begin(), schema.end()), m_nestedSchemas(nestedSchemas) {}
+
 // Struct array constructor
 LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString, bool isArray)
   : m_type(isArray ? LogType::kStructArray : LogType::kStruct),
@@ -78,6 +85,17 @@ LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString
     m_typeString(typeString),
     m_schema(schema.begin(), schema.end()) {}
 
+// Struct array constructor with all schemas (including nested)
+LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
+                   std::span<const uint8_t> schema,
+                   const std::unordered_map<std::string, std::vector<uint8_t>>& nestedSchemas,
+                   bool isArray)
+  : m_type(isArray ? LogType::kStructArray : LogType::kStruct),
+    m_value(data),
+    m_typeString(typeString),
+    m_schema(schema.begin(), schema.end()),
+    m_nestedSchemas(nestedSchemas) {}
+
 std::string LogValue::GetTypeString() const {
   // For structs, return the custom type string
   if (m_type == LogType::kStruct || m_type == LogType::kStructArray) {

src/main/native/cpp/receiver/NetworkTablesReceiver.cpp

@@ -176,12 +176,14 @@ void NetworkTablesReceiver::PublishValue(std::string_view key, const LogValue& v
       if (pubIt == m_publishers.end()) {
         std::string typeStr = value.GetTypeString();  // e.g., "Pose2d", "SwerveModuleState"
 
-        // Publish struct schema to NetworkTables if we have it
-        auto schema = value.GetSchema();
-        if (!schema.empty()) {
-          // Use "struct:TypeName" format for schema registration
-          std::string fullTypeStr = "struct:" + typeStr;
-          m_inst.AddSchema(typeStr, fullTypeStr, schema);
+        // Publish all struct schemas (including nested ones like Translation2d in Pose2d)
+        const auto& allSchemas = value.GetAllSchemas();
+        for (const auto& [schemaName, schemaBytes] : allSchemas) {
+          // Only publish each schema once
+          if (m_publishedSchemas.find(schemaName) == m_publishedSchemas.end()) {
+            m_inst.AddSchema(schemaName, "structschema", schemaBytes);
+            m_publishedSchemas.insert(schemaName);
+          }
         }
 
         // Create RawTopic publisher with type string

src/main/native/include/telemetrykit/core/LogValue.h

@@ -5,6 +5,7 @@
 #include <optional>
 #include <span>
 #include <string>
+#include <unordered_map>
 #include <variant>
 #include <vector>
 
@@ -81,13 +82,24 @@ class LogValue {
   LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
            std::span<const uint8_t> schema);
 
+  // Constructor for struct data with all schemas (including nested)
+  LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
+           std::span<const uint8_t> schema,
+           const std::unordered_map<std::string, std::vector<uint8_t>>& nestedSchemas);
+
   // Constructor for struct arrays
   LogValue(const std::vector<uint8_t>& data, std::string_view typeString, bool isArray);
 
   // Constructor for struct arrays with schema
   LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
            std::span<const uint8_t> schema, bool isArray);
 
+  // Constructor for struct arrays with all schemas (including nested)
+  LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
+           std::span<const uint8_t> schema,
+           const std::unordered_map<std::string, std::vector<uint8_t>>& nestedSchemas,
+           bool isArray);
+
   // Constructor for raw binary data (no default parameter to avoid ambiguity)
   LogValue(const std::vector<uint8_t>& value, bool isStruct);
 
@@ -162,13 +174,22 @@ class LogValue {
   ValueVariant m_value;
   std::string m_typeString;  // For struct types (e.g., "Pose2d")
   std::vector<uint8_t> m_schema;  // For struct schema bytes (NT4 schema publishing)
+  std::unordered_map<std::string, std::vector<uint8_t>> m_nestedSchemas;  // Nested struct schemas
 
  public:
   /**
    * Get the schema bytes for struct types.
    * Returns empty span for non-struct types.
    */
   std::span<const uint8_t> GetSchema() const { return m_schema; }
+
+  /**
+   * Get all nested schemas (including the main schema).
+   * Returns map of typeName -> schema bytes.
+   */
+  const std::unordered_map<std::string, std::vector<uint8_t>>& GetAllSchemas() const {
+    return m_nestedSchemas;
+  }
 };
 
 /**
@@ -190,8 +211,14 @@ LogValue MakeStructValue(const T& structValue) {
   // Get schema bytes
   auto schemaBytes = wpi::GetStructSchemaBytes<T>();
 
-  // Create LogValue with type string and schema
-  return LogValue(buffer, std::string(descriptor.GetTypeName()), schemaBytes);
+  // Collect all schemas (including nested structs like Translation2d in Pose2d)
+  std::unordered_map<std::string, std::vector<uint8_t>> allSchemas;
+  wpi::ForEachStructSchema<T>([&allSchemas](std::string_view name, std::string_view schema) {
+    allSchemas[std::string(name)] = std::vector<uint8_t>(schema.begin(), schema.end());
+  });
+
+  // Create LogValue with type string, schema, and all nested schemas
+  return LogValue(buffer, std::string(descriptor.GetTypeName()), schemaBytes, allSchemas);
 }
 
 /**
@@ -212,8 +239,14 @@ LogValue MakeStructArrayValue(std::span<const T> structArray) {
   // Get schema bytes
   auto schemaBytes = wpi::GetStructSchemaBytes<T>();
 
-  // Create LogValue with type string, schema, and array flag
-  return LogValue(buffer, std::string(descriptor.GetTypeName()), schemaBytes, true);
+  // Collect all schemas (including nested structs)
+  std::unordered_map<std::string, std::vector<uint8_t>> allSchemas;
+  wpi::ForEachStructSchema<T>([&allSchemas](std::string_view name, std::string_view schema) {
+    allSchemas[std::string(name)] = std::vector<uint8_t>(schema.begin(), schema.end());
+  });
+
+  // Create LogValue with type string, schema, all nested schemas, and array flag
+  return LogValue(buffer, std::string(descriptor.GetTypeName()), schemaBytes, allSchemas, true);
 }
 
 }  // namespace telemetrykit

src/main/native/include/telemetrykit/receiver/NetworkTablesReceiver.h

@@ -4,6 +4,7 @@
 #include <string>
 #include <string_view>
 #include <unordered_map>
+#include <unordered_set>
 #include <variant>
 
 #include <networktables/BooleanArrayTopic.h>
@@ -87,6 +88,7 @@ class NetworkTablesReceiver : public LogDataReceiver {
   nt::NetworkTableInstance m_inst;
   std::unordered_map<std::string, PublisherVariant> m_publishers;
   std::unordered_map<std::string, LogValue> m_lastValues;  // For change detection
+  std::unordered_set<std::string> m_publishedSchemas;  // Track published schemas to avoid duplicates
 };
 
 }  // namespace telemetrykit