Add struct constructors and schema handling to LogValue and update NetworkTablesReceiver and WPILogWriter for schema publishing

Author: SticksDev

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

@@ -58,12 +58,26 @@ LogValue::LogValue(const std::vector<uint8_t>& value, bool isStruct)
 LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString)
   : m_type(LogType::kStruct), m_value(data), m_typeString(typeString) {}
 
+// Struct constructor with type string and schema
+LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
+                   std::span<const uint8_t> schema)
+  : m_type(LogType::kStruct), m_value(data), m_typeString(typeString),
+    m_schema(schema.begin(), schema.end()) {}
+
 // Struct array constructor
 LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString, bool isArray)
   : m_type(isArray ? LogType::kStructArray : LogType::kStruct),
     m_value(data),
     m_typeString(typeString) {}
 
+// Struct array constructor with schema
+LogValue::LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
+                   std::span<const uint8_t> schema, bool isArray)
+  : m_type(isArray ? LogType::kStructArray : LogType::kStruct),
+    m_value(data),
+    m_typeString(typeString),
+    m_schema(schema.begin(), schema.end()) {}
+
 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

@@ -171,10 +171,21 @@ void NetworkTablesReceiver::PublishValue(std::string_view key, const LogValue& v
 
     case LogType::kStruct:
     case LogType::kStructArray: {
-      // For structs, publish as raw with type string metadata
+      // For structs, publish as RawTopic with type string metadata.
+      // NT4 clients like AdvantageScope will use the type string and schema to deserialize.
       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);
+        }
+
+        // Create RawTopic publisher with type string
         auto topic = m_inst.GetRawTopic(keyStr);
-        std::string typeStr = value.GetTypeString();
         m_publishers[keyStr] = topic.Publish(typeStr);
         pubIt = m_publishers.find(keyStr);
       }

src/main/native/cpp/receiver/WPILogWriter.cpp

@@ -112,10 +112,15 @@ int WPILogWriter::GetOrCreateEntry(std::string_view key, const LogValue& value)
     case LogType::kRaw:
       entryId = m_log->Start(keyStr, "raw");
       break;
-    case LogType::kStruct:
+    case LogType::kStruct: {
+      // For structs, use "struct:TypeName" format (e.g., "struct:Pose2d")
+      std::string typeStr = "struct:" + value.GetTypeString();
+      entryId = m_log->Start(keyStr, typeStr);
+      break;
+    }
     case LogType::kStructArray: {
-      // For structs, use the type string
-      std::string typeStr = value.GetTypeString();
+      // For struct arrays, use "struct:TypeName[]" format (e.g., "struct:Pose2d[]")
+      std::string typeStr = "struct:" + value.GetTypeString() + "[]";
       entryId = m_log->Start(keyStr, typeStr);
       break;
     }

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

@@ -8,6 +8,8 @@
 #include <variant>
 #include <vector>
 
+#include <wpi/struct/Struct.h>
+
 namespace telemetrykit {
 
 /**
@@ -75,9 +77,17 @@ class LogValue {
   // Constructor for struct data with type string (MUST come before bool constructor)
   LogValue(const std::vector<uint8_t>& data, std::string_view typeString);
 
+  // Constructor for struct data with type string and schema
+  LogValue(const std::vector<uint8_t>& data, std::string_view typeString,
+           std::span<const uint8_t> schema);
+
   // 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 raw binary data (no default parameter to avoid ambiguity)
   LogValue(const std::vector<uint8_t>& value, bool isStruct);
 
@@ -151,14 +161,22 @@ class LogValue {
   LogType m_type;
   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)
+
+ 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; }
 };
 
 /**
  * Helper function to create a LogValue from a WPILib struct.
  *
  * Example:
  *   frc::Pose2d pose{...};
- *   LogValue value = LogValue::FromStruct(pose);
+ *   LogValue value = MakeStructValue(pose);
  */
 template<typename T>
 LogValue MakeStructValue(const T& structValue) {
@@ -169,8 +187,11 @@ LogValue MakeStructValue(const T& structValue) {
   std::vector<uint8_t> buffer(descriptor.GetSize());
   descriptor.Pack(buffer, structValue);
 
-  // Create LogValue with type string
-  return LogValue(buffer, std::string(descriptor.GetTypeName()));
+  // Get schema bytes
+  auto schemaBytes = wpi::GetStructSchemaBytes<T>();
+
+  // Create LogValue with type string and schema
+  return LogValue(buffer, std::string(descriptor.GetTypeName()), schemaBytes);
 }
 
 /**
@@ -188,8 +209,11 @@ LogValue MakeStructArrayValue(std::span<const T> structArray) {
     descriptor.Pack(slice, structArray[i]);
   }
 
-  // Create LogValue with type string and array flag
-  return LogValue(buffer, std::string(descriptor.GetTypeName()), true);
+  // 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);
 }
 
 }  // namespace telemetrykit