[wpiutil] Change Struct to allow non-constexpr implementation (#5992)

This required changing the constant values (e.g. kSize) into functions
(e.g. GetSize()).

Fixed implementations of ForEachNested to be inline (as these are actually
templates).

Also added a ntcore Struct test.

wpimath/src/main/native/include/frc/geometry/struct/Pose2dStruct.h

@@ -11,16 +11,22 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Pose2d> {
-  static constexpr std::string_view kTypeString = "struct:Pose2d";
-  static constexpr size_t kSize = wpi::Struct<frc::Translation2d>::kSize +
-                                  wpi::Struct<frc::Rotation2d>::kSize;
-  static constexpr std::string_view kSchema =
-      "Translation2d translation;Rotation2d rotation";
+  static constexpr std::string_view GetTypeString() { return "struct:Pose2d"; }
+  static constexpr size_t GetSize() {
+    return wpi::GetStructSize<frc::Translation2d>() +
+           wpi::GetStructSize<frc::Rotation2d>();
+  }
+  static constexpr std::string_view GetSchema() {
+    return "Translation2d translation;Rotation2d rotation";
+  }
 
-  static frc::Pose2d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data, const frc::Pose2d& value);
+  static frc::Pose2d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Pose2d& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Translation2d>(fn);
+    wpi::ForEachStructSchema<frc::Rotation2d>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::Pose2d>);

wpimath/src/main/native/include/frc/geometry/struct/Pose3dStruct.h

@@ -11,16 +11,22 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Pose3d> {
-  static constexpr std::string_view kTypeString = "struct:Pose3d";
-  static constexpr size_t kSize = wpi::Struct<frc::Translation3d>::kSize +
-                                  wpi::Struct<frc::Rotation3d>::kSize;
-  static constexpr std::string_view kSchema =
-      "Translation3d translation;Rotation3d rotation";
+  static constexpr std::string_view GetTypeString() { return "struct:Pose3d"; }
+  static constexpr size_t GetSize() {
+    return wpi::GetStructSize<frc::Translation3d>() +
+           wpi::GetStructSize<frc::Rotation3d>();
+  }
+  static constexpr std::string_view GetSchema() {
+    return "Translation3d translation;Rotation3d rotation";
+  }
 
-  static frc::Pose3d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data, const frc::Pose3d& value);
+  static frc::Pose3d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Pose3d& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Translation3d>(fn);
+    wpi::ForEachStructSchema<frc::Rotation3d>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::Pose3d>);

wpimath/src/main/native/include/frc/geometry/struct/QuaternionStruct.h

@@ -11,12 +11,14 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Quaternion> {
-  static constexpr std::string_view kTypeString = "struct:Quaternion";
-  static constexpr size_t kSize = 32;
-  static constexpr std::string_view kSchema =
-      "double w;double x;double y;double z";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:Quaternion";
+  }
+  static constexpr size_t GetSize() { return 32; }
+  static constexpr std::string_view GetSchema() {
+    return "double w;double x;double y;double z";
+  }
 
-  static frc::Quaternion Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::Quaternion& value);
+  static frc::Quaternion Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Quaternion& value);
 };

wpimath/src/main/native/include/frc/geometry/struct/Rotation2dStruct.h

@@ -11,11 +11,12 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Rotation2d> {
-  static constexpr std::string_view kTypeString = "struct:Rotation2d";
-  static constexpr size_t kSize = 8;
-  static constexpr std::string_view kSchema = "double value";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:Rotation2d";
+  }
+  static constexpr size_t GetSize() { return 8; }
+  static constexpr std::string_view GetSchema() { return "double value"; }
 
-  static frc::Rotation2d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::Rotation2d& value);
+  static frc::Rotation2d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Rotation2d& value);
 };

wpimath/src/main/native/include/frc/geometry/struct/Rotation3dStruct.h

@@ -11,15 +11,20 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Rotation3d> {
-  static constexpr std::string_view kTypeString = "struct:Rotation3d";
-  static constexpr size_t kSize = wpi::Struct<frc::Quaternion>::kSize;
-  static constexpr std::string_view kSchema = "Quaternion q";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:Rotation3d";
+  }
+  static constexpr size_t GetSize() {
+    return wpi::GetStructSize<frc::Quaternion>();
+  }
+  static constexpr std::string_view GetSchema() { return "Quaternion q"; }
 
-  static frc::Rotation3d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::Rotation3d& value);
+  static frc::Rotation3d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Rotation3d& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Quaternion>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::Rotation3d>);

wpimath/src/main/native/include/frc/geometry/struct/Transform2dStruct.h

@@ -11,17 +11,24 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Transform2d> {
-  static constexpr std::string_view kTypeString = "struct:Transform2d";
-  static constexpr size_t kSize = wpi::Struct<frc::Translation2d>::kSize +
-                                  wpi::Struct<frc::Rotation2d>::kSize;
-  static constexpr std::string_view kSchema =
-      "Translation2d translation;Rotation2d rotation";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:Transform2d";
+  }
+  static constexpr size_t GetSize() {
+    return wpi::GetStructSize<frc::Translation2d>() +
+           wpi::GetStructSize<frc::Rotation2d>();
+  }
+  static constexpr std::string_view GetSchema() {
+    return "Translation2d translation;Rotation2d rotation";
+  }
 
-  static frc::Transform2d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::Transform2d& value);
+  static frc::Transform2d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Transform2d& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Translation2d>(fn);
+    wpi::ForEachStructSchema<frc::Rotation2d>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::Transform2d>);

wpimath/src/main/native/include/frc/geometry/struct/Transform3dStruct.h

@@ -11,17 +11,24 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Transform3d> {
-  static constexpr std::string_view kTypeString = "struct:Transform3d";
-  static constexpr size_t kSize = wpi::Struct<frc::Translation3d>::kSize +
-                                  wpi::Struct<frc::Rotation3d>::kSize;
-  static constexpr std::string_view kSchema =
-      "Translation3d translation;Rotation3d rotation";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:Transform3d";
+  }
+  static constexpr size_t GetSize() {
+    return wpi::GetStructSize<frc::Translation3d>() +
+           wpi::GetStructSize<frc::Rotation3d>();
+  }
+  static constexpr std::string_view GetSchema() {
+    return "Translation3d translation;Rotation3d rotation";
+  }
 
-  static frc::Transform3d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::Transform3d& value);
+  static frc::Transform3d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Transform3d& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Translation3d>(fn);
+    wpi::ForEachStructSchema<frc::Rotation3d>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::Transform3d>);

wpimath/src/main/native/include/frc/geometry/struct/Translation2dStruct.h

@@ -11,11 +11,12 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Translation2d> {
-  static constexpr std::string_view kTypeString = "struct:Translation2d";
-  static constexpr size_t kSize = 16;
-  static constexpr std::string_view kSchema = "double x;double y";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:Translation2d";
+  }
+  static constexpr size_t GetSize() { return 16; }
+  static constexpr std::string_view GetSchema() { return "double x;double y"; }
 
-  static frc::Translation2d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::Translation2d& value);
+  static frc::Translation2d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Translation2d& value);
 };

wpimath/src/main/native/include/frc/geometry/struct/Translation3dStruct.h

@@ -11,11 +11,14 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Translation3d> {
-  static constexpr std::string_view kTypeString = "struct:Translation3d";
-  static constexpr size_t kSize = 24;
-  static constexpr std::string_view kSchema = "double x;double y;double z";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:Translation3d";
+  }
+  static constexpr size_t GetSize() { return 24; }
+  static constexpr std::string_view GetSchema() {
+    return "double x;double y;double z";
+  }
 
-  static frc::Translation3d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::Translation3d& value);
+  static frc::Translation3d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Translation3d& value);
 };

wpimath/src/main/native/include/frc/geometry/struct/Twist2dStruct.h

@@ -11,11 +11,12 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Twist2d> {
-  static constexpr std::string_view kTypeString = "struct:Twist2d";
-  static constexpr size_t kSize = 24;
-  static constexpr std::string_view kSchema =
-      "double dx;double dy;double dtheta";
+  static constexpr std::string_view GetTypeString() { return "struct:Twist2d"; }
+  static constexpr size_t GetSize() { return 24; }
+  static constexpr std::string_view GetSchema() {
+    return "double dx;double dy;double dtheta";
+  }
 
-  static frc::Twist2d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data, const frc::Twist2d& value);
+  static frc::Twist2d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Twist2d& value);
 };

wpimath/src/main/native/include/frc/geometry/struct/Twist3dStruct.h

@@ -11,11 +11,12 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::Twist3d> {
-  static constexpr std::string_view kTypeString = "struct:Twist3d";
-  static constexpr size_t kSize = 48;
-  static constexpr std::string_view kSchema =
-      "double dx;double dy;double dz;double rx;double ry;double rz";
+  static constexpr std::string_view GetTypeString() { return "struct:Twist3d"; }
+  static constexpr size_t GetSize() { return 48; }
+  static constexpr std::string_view GetSchema() {
+    return "double dx;double dy;double dz;double rx;double ry;double rz";
+  }
 
-  static frc::Twist3d Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data, const frc::Twist3d& value);
+  static frc::Twist3d Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::Twist3d& value);
 };

wpimath/src/main/native/include/frc/kinematics/struct/ChassisSpeedsStruct.h

@@ -11,12 +11,14 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::ChassisSpeeds> {
-  static constexpr std::string_view kTypeString = "struct:ChassisSpeeds";
-  static constexpr size_t kSize = 24;
-  static constexpr std::string_view kSchema =
-      "double vx;double vy;double omega";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:ChassisSpeeds";
+  }
+  static constexpr size_t GetSize() { return 24; }
+  static constexpr std::string_view GetSchema() {
+    return "double vx;double vy;double omega";
+  }
 
-  static frc::ChassisSpeeds Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
-                   const frc::ChassisSpeeds& value);
+  static frc::ChassisSpeeds Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data, const frc::ChassisSpeeds& value);
 };

wpimath/src/main/native/include/frc/kinematics/struct/DifferentialDriveKinematicsStruct.h

@@ -11,13 +11,13 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::DifferentialDriveKinematics> {
-  static constexpr std::string_view kTypeString =
-      "struct:DifferentialDriveKinematics";
-  static constexpr size_t kSize = 8;
-  static constexpr std::string_view kSchema = "double track_width";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:DifferentialDriveKinematics";
+  }
+  static constexpr size_t GetSize() { return 8; }
+  static constexpr std::string_view GetSchema() { return "double track_width"; }
 
-  static frc::DifferentialDriveKinematics Unpack(
-      std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
+  static frc::DifferentialDriveKinematics Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data,
                    const frc::DifferentialDriveKinematics& value);
 };

wpimath/src/main/native/include/frc/kinematics/struct/DifferentialDriveWheelSpeedsStruct.h

@@ -11,13 +11,16 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::DifferentialDriveWheelSpeeds> {
-  static constexpr std::string_view kTypeString =
-      "struct:DifferentialDriveWheelSpeeds";
-  static constexpr size_t kSize = 16;
-  static constexpr std::string_view kSchema = "double left;double right";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:DifferentialDriveWheelSpeeds";
+  }
+  static constexpr size_t GetSize() { return 16; }
+  static constexpr std::string_view GetSchema() {
+    return "double left;double right";
+  }
 
   static frc::DifferentialDriveWheelSpeeds Unpack(
-      std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
+      std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data,
                    const frc::DifferentialDriveWheelSpeeds& value);
 };

wpimath/src/main/native/include/frc/kinematics/struct/MecanumDriveKinematicsStruct.h

@@ -11,19 +11,24 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::MecanumDriveKinematics> {
-  static constexpr std::string_view kTypeString =
-      "struct:MecanumDriveKinematics";
-  static constexpr size_t kSize = 4 * wpi::Struct<frc::Translation2d>::kSize;
-  static constexpr std::string_view kSchema =
-      "Translation2d front_left;Translation2d front_right;Translation2d "
-      "rear_left;Translation2d rear_right";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:MecanumDriveKinematics";
+  }
+  static constexpr size_t GetSize() {
+    return 4 * wpi::GetStructSize<frc::Translation2d>();
+  }
+  static constexpr std::string_view GetSchema() {
+    return "Translation2d front_left;Translation2d front_right;Translation2d "
+           "rear_left;Translation2d rear_right";
+  }
 
-  static frc::MecanumDriveKinematics Unpack(
-      std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
+  static frc::MecanumDriveKinematics Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data,
                    const frc::MecanumDriveKinematics& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Translation2d>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::MecanumDriveKinematics>);

wpimath/src/main/native/include/frc/kinematics/struct/MecanumDriveWheelPositionsStruct.h

@@ -11,14 +11,16 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::MecanumDriveWheelPositions> {
-  static constexpr std::string_view kTypeString =
-      "struct:MecanumDriveWheelPositions";
-  static constexpr size_t kSize = 32;
-  static constexpr std::string_view kSchema =
-      "double front_left;double front_right;double rear_left;double rear_right";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:MecanumDriveWheelPositions";
+  }
+  static constexpr size_t GetSize() { return 32; }
+  static constexpr std::string_view GetSchema() {
+    return "double front_left;double front_right;double rear_left;double "
+           "rear_right";
+  }
 
-  static frc::MecanumDriveWheelPositions Unpack(
-      std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
+  static frc::MecanumDriveWheelPositions Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data,
                    const frc::MecanumDriveWheelPositions& value);
 };

wpimath/src/main/native/include/frc/kinematics/struct/MecanumDriveWheelSpeedsStruct.h

@@ -11,14 +11,16 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::MecanumDriveWheelSpeeds> {
-  static constexpr std::string_view kTypeString =
-      "struct:MecanumDriveWheelSpeeds";
-  static constexpr size_t kSize = 32;
-  static constexpr std::string_view kSchema =
-      "double front_left;double front_right;double rear_left;double rear_right";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:MecanumDriveWheelSpeeds";
+  }
+  static constexpr size_t GetSize() { return 32; }
+  static constexpr std::string_view GetSchema() {
+    return "double front_left;double front_right;double rear_left;"
+           "double rear_right";
+  }
 
-  static frc::MecanumDriveWheelSpeeds Unpack(
-      std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
+  static frc::MecanumDriveWheelSpeeds Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data,
                    const frc::MecanumDriveWheelSpeeds& value);
 };

wpimath/src/main/native/include/frc/kinematics/struct/SwerveModulePositionStruct.h

@@ -11,16 +11,23 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::SwerveModulePosition> {
-  static constexpr std::string_view kTypeString = "struct:SwerveModulePosition";
-  static constexpr size_t kSize = 8 + wpi::Struct<frc::Rotation2d>::kSize;
-  static constexpr std::string_view kSchema =
-      "double distance;Rotation2d angle";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:SwerveModulePosition";
+  }
+  static constexpr size_t GetSize() {
+    return 8 + wpi::GetStructSize<frc::Rotation2d>();
+  }
+  static constexpr std::string_view GetSchema() {
+    return "double distance;Rotation2d angle";
+  }
 
-  static frc::SwerveModulePosition Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
+  static frc::SwerveModulePosition Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data,
                    const frc::SwerveModulePosition& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Rotation2d>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::SwerveModulePosition>);

wpimath/src/main/native/include/frc/kinematics/struct/SwerveModuleStateStruct.h

@@ -11,15 +11,23 @@
 
 template <>
 struct WPILIB_DLLEXPORT wpi::Struct<frc::SwerveModuleState> {
-  static constexpr std::string_view kTypeString = "struct:SwerveModuleState";
-  static constexpr size_t kSize = 8 + wpi::Struct<frc::Rotation2d>::kSize;
-  static constexpr std::string_view kSchema = "double speed;Rotation2d angle";
+  static constexpr std::string_view GetTypeString() {
+    return "struct:SwerveModuleState";
+  }
+  static constexpr size_t GetSize() {
+    return 8 + wpi::GetStructSize<frc::Rotation2d>();
+  }
+  static constexpr std::string_view GetSchema() {
+    return "double speed;Rotation2d angle";
+  }
 
-  static frc::SwerveModuleState Unpack(std::span<const uint8_t, kSize> data);
-  static void Pack(std::span<uint8_t, kSize> data,
+  static frc::SwerveModuleState Unpack(std::span<const uint8_t> data);
+  static void Pack(std::span<uint8_t> data,
                    const frc::SwerveModuleState& value);
   static void ForEachNested(
-      std::invocable<std::string_view, std::string_view> auto fn);
+      std::invocable<std::string_view, std::string_view> auto fn) {
+    wpi::ForEachStructSchema<frc::Rotation2d>(fn);
+  }
 };
 
 static_assert(wpi::HasNestedStruct<frc::SwerveModuleState>);