[wpiutil] Rewrite Sendable in the style of Struct and Protobuf

styleguide/spotbugs-exclude.xml

@@ -30,6 +30,10 @@
   <Match>
     <Bug pattern="EI_EXPOSE_REP2" />
   </Match>
+  <Match>
+    <Bug pattern="EI_EXPOSE_STATIC_REP2" />
+    <Class name="edu.wpi.first.wpilibj.telemetry.Telemetry" />
+  </Match>
   <Match>
     <Bug pattern="FL_FLOATS_AS_LOOP_COUNTERS" />
   </Match>

wpilibc/src/main/native/cpp/AnalogInput.cpp

@@ -10,8 +10,7 @@
 #include <hal/HALBase.h>
 #include <hal/Ports.h>
 #include <wpi/StackTrace.h>
-#include <wpi/sendable/SendableBuilder.h>
-#include <wpi/sendable/SendableRegistry.h>
+#include <wpi/sendable2/SendableTable.h>
 
 #include "frc/Errors.h"
 #include "frc/SensorUtil.h"
@@ -33,8 +32,6 @@ AnalogInput::AnalogInput(int channel) {
   FRC_CheckErrorStatus(status, "Channel {}", channel);
 
   HAL_Report(HALUsageReporting::kResourceType_AnalogChannel, channel + 1);
-
-  wpi::SendableRegistry::AddLW(this, "AnalogInput", channel);
 }
 
 AnalogInput::~AnalogInput() {
@@ -194,8 +191,7 @@ void AnalogInput::SetSimDevice(HAL_SimDeviceHandle device) {
   HAL_SetAnalogInputSimDevice(m_port, device);
 }
 
-void AnalogInput::InitSendable(wpi::SendableBuilder& builder) {
-  builder.SetSmartDashboardType("Analog Input");
-  builder.AddDoubleProperty(
-      "Value", [=, this] { return GetAverageVoltage(); }, nullptr);
+void wpi2::Sendable<AnalogInput>::Init(frc::AnalogInput* obj,
+                                       SendableTable& table) {
+  table.PublishDouble("Value", [obj] { return obj->GetAverageVoltage(); });
 }

wpilibc/src/main/native/cpp/AnalogTrigger.cpp

@@ -9,7 +9,7 @@
 #include <hal/AnalogTrigger.h>
 #include <hal/FRCUsageReporting.h>
 #include <wpi/NullDeleter.h>
-#include <wpi/sendable/SendableRegistry.h>
+#include <wpi/sendable2/SendableTable.h>
 
 #include "frc/AnalogInput.h"
 #include "frc/DutyCycle.h"
@@ -20,7 +20,6 @@ using namespace frc;
 AnalogTrigger::AnalogTrigger(int channel)
     : AnalogTrigger(new AnalogInput(channel)) {
   m_ownsAnalog = true;
-  wpi::SendableRegistry::AddChild(this, m_analogInput);
 }
 
 AnalogTrigger::AnalogTrigger(AnalogInput* input) {
@@ -31,7 +30,6 @@ AnalogTrigger::AnalogTrigger(AnalogInput* input) {
   int index = GetIndex();
 
   HAL_Report(HALUsageReporting::kResourceType_AnalogTrigger, index + 1);
-  wpi::SendableRegistry::AddLW(this, "AnalogTrigger", index);
 }
 
 AnalogTrigger::AnalogTrigger(DutyCycle* input) {
@@ -42,7 +40,6 @@ AnalogTrigger::AnalogTrigger(DutyCycle* input) {
   int index = GetIndex();
 
   HAL_Report(HALUsageReporting::kResourceType_AnalogTrigger, index + 1);
-  wpi::SendableRegistry::AddLW(this, "AnalogTrigger", index);
 }
 
 AnalogTrigger::~AnalogTrigger() {
@@ -112,12 +109,6 @@ std::shared_ptr<AnalogTriggerOutput> AnalogTrigger::CreateOutput(
       new AnalogTriggerOutput(*this, type));
 }
 
-void AnalogTrigger::InitSendable(wpi::SendableBuilder& builder) {
-  if (m_ownsAnalog) {
-    m_analogInput->InitSendable(builder);
-  }
-}
-
 int AnalogTrigger::GetSourceChannel() const {
   if (m_analogInput) {
     return m_analogInput->GetChannel();
@@ -127,3 +118,10 @@ int AnalogTrigger::GetSourceChannel() const {
     return -1;
   }
 }
+
+void wpi2::Sendable<AnalogTrigger>::Init(frc::AnalogTrigger* obj,
+                                         SendableTable& table) {
+  if (obj->m_ownsAnalog) {
+    Sendable<AnalogInput>::Init(obj->m_analogInput, table);
+  }
+}

wpilibc/src/main/native/cpp/telemetry/Telemetry.cpp

@@ -0,0 +1,191 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/telemetry/Telemetry.h"
+
+#include <wpi/json.h>
+#include <wpi/sendable2/SendableTable.h>
+
+using namespace frc;
+
+wpi2::SendableTable& Telemetry::GetTableHolder() {
+  static wpi2::SendableTable instance{nullptr};  // FIXME
+  return instance;
+}
+
+void Telemetry::SetTable(wpi2::SendableTable table) {
+  GetTableHolder() = std::move(table);
+}
+
+wpi2::SendableTable Telemetry::GetTable() {
+  return GetTableHolder();
+}
+
+void Telemetry::SetBoolean(std::string_view name, bool value) {
+  GetTableHolder().SetBoolean(name, value);
+}
+
+void Telemetry::SetInteger(std::string_view name, int64_t value) {
+  GetTableHolder().SetInteger(name, value);
+}
+
+void Telemetry::SetFloat(std::string_view name, float value) {
+  GetTableHolder().SetFloat(name, value);
+}
+
+void Telemetry::SetDouble(std::string_view name, double value) {
+  GetTableHolder().SetDouble(name, value);
+}
+
+void Telemetry::SetString(std::string_view name, std::string_view value) {
+  GetTableHolder().SetString(name, value);
+}
+
+void Telemetry::SetRaw(std::string_view name, std::string_view typeString,
+                       std::span<const uint8_t> value) {
+  GetTableHolder().SetRaw(name, typeString, value);
+}
+
+void Telemetry::PublishBoolean(std::string_view name,
+                               std::function<bool()> supplier) {
+  GetTableHolder().PublishBoolean(name, std::move(supplier));
+}
+
+void Telemetry::PublishInteger(std::string_view name,
+                               std::function<int64_t()> supplier) {
+  GetTableHolder().PublishInteger(name, std::move(supplier));
+}
+
+void Telemetry::PublishFloat(std::string_view name,
+                             std::function<float()> supplier) {
+  GetTableHolder().PublishFloat(name, std::move(supplier));
+}
+
+void Telemetry::PublishDouble(std::string_view name,
+                              std::function<double()> supplier) {
+  GetTableHolder().PublishDouble(name, std::move(supplier));
+}
+
+void Telemetry::PublishString(std::string_view name,
+                              std::function<std::string()> supplier) {
+  GetTableHolder().PublishString(name, std::move(supplier));
+}
+
+void Telemetry::PublishRaw(std::string_view name, std::string_view typeString,
+                           std::function<std::vector<uint8_t>()> supplier) {
+  GetTableHolder().PublishRaw(name, typeString, std::move(supplier));
+}
+
+void Telemetry::PublishRawSmall(
+    std::string_view name, std::string_view typeString,
+    std::function<std::span<uint8_t>(wpi::SmallVectorImpl<uint8_t>& buf)>
+        supplier) {
+  GetTableHolder().PublishRawSmall(name, typeString, std::move(supplier));
+}
+
+std::function<void(bool)> Telemetry::AddBooleanPublisher(
+    std::string_view name) {
+  return GetTableHolder().AddBooleanPublisher(name);
+}
+
+std::function<void(int64_t)> Telemetry::AddIntegerPublisher(
+    std::string_view name) {
+  return GetTableHolder().AddIntegerPublisher(name);
+}
+
+std::function<void(float)> Telemetry::AddFloatPublisher(std::string_view name) {
+  return GetTableHolder().AddFloatPublisher(name);
+}
+
+std::function<void(double)> Telemetry::AddDoublePublisher(
+    std::string_view name) {
+  return GetTableHolder().AddDoublePublisher(name);
+}
+
+std::function<void(std::string_view)> Telemetry::AddStringPublisher(
+    std::string_view name) {
+  return GetTableHolder().AddStringPublisher(name);
+}
+
+std::function<void(std::span<const uint8_t>)> Telemetry::AddRawPublisher(
+    std::string_view name, std::string_view typeString) {
+  return GetTableHolder().AddRawPublisher(name, typeString);
+}
+
+void Telemetry::SubscribeBoolean(std::string_view name,
+                                 std::function<void(bool)> consumer) {
+  GetTableHolder().SubscribeBoolean(name, std::move(consumer));
+}
+
+void Telemetry::SubscribeInteger(std::string_view name,
+                                 std::function<void(int64_t)> consumer) {
+  GetTableHolder().SubscribeInteger(name, std::move(consumer));
+}
+
+void Telemetry::SubscribeFloat(std::string_view name,
+                               std::function<void(float)> consumer) {
+  GetTableHolder().SubscribeFloat(name, std::move(consumer));
+}
+
+void Telemetry::SubscribeDouble(std::string_view name,
+                                std::function<void(double)> consumer) {
+  GetTableHolder().SubscribeDouble(name, std::move(consumer));
+}
+
+void Telemetry::SubscribeString(
+    std::string_view name, std::function<void(std::string_view)> consumer) {
+  GetTableHolder().SubscribeString(name, std::move(consumer));
+}
+
+void Telemetry::SubscribeRaw(
+    std::string_view name, std::string_view typeString,
+    std::function<void(std::span<const uint8_t>)> consumer) {
+  GetTableHolder().SubscribeRaw(name, typeString, std::move(consumer));
+}
+
+wpi2::SendableTable Telemetry::GetChild(std::string_view name) {
+  return GetTableHolder().GetChild(name);
+}
+
+void Telemetry::SetPublishOptions(std::string_view name,
+                                  const wpi2::SendableOptions& options) {
+  GetTableHolder().SetPublishOptions(name, options);
+}
+
+void Telemetry::SetSubscribeOptions(std::string_view name,
+                                    const wpi2::SendableOptions& options) {
+  GetTableHolder().SetSubscribeOptions(name, options);
+}
+
+wpi::json Telemetry::GetProperty(std::string_view name,
+                                 std::string_view propName) {
+  return GetTableHolder().GetProperty(name, propName);
+}
+
+void Telemetry::SetProperty(std::string_view name, std::string_view propName,
+                            const wpi::json& value) {
+  GetTableHolder().SetProperty(name, propName, value);
+}
+
+void Telemetry::DeleteProperty(std::string_view name,
+                               std::string_view propName) {
+  GetTableHolder().DeleteProperty(name, propName);
+}
+
+wpi::json Telemetry::GetProperties(std::string_view name) {
+  return GetTableHolder().GetProperties(name);
+}
+
+bool Telemetry::SetProperties(std::string_view name,
+                              const wpi::json& properties) {
+  return GetTableHolder().SetProperties(name, properties);
+}
+
+void Telemetry::Remove(std::string_view name) {
+  GetTableHolder().Remove(name);
+}
+
+void Telemetry::Clear() {
+  GetTableHolder().Clear();
+}

wpilibc/src/main/native/include/frc/AnalogInput.h

@@ -7,8 +7,8 @@
 #include <stdint.h>
 
 #include <hal/Types.h>
-#include <wpi/sendable/Sendable.h>
-#include <wpi/sendable/SendableHelper.h>
+#include <wpi/sendable2/Sendable.h>
+#include <wpi/MoveTracker.h>
 
 namespace frc {
 
@@ -27,8 +27,7 @@ class DMASample;
  * are divided by the number of samples to retain the resolution, but get more
  * stable values.
  */
-class AnalogInput : public wpi::Sendable,
-                    public wpi::SendableHelper<AnalogInput> {
+class AnalogInput : public wpi::MoveTrackerBase {
   friend class AnalogTrigger;
   friend class AnalogGyro;
   friend class DMA;
@@ -280,12 +279,23 @@ class AnalogInput : public wpi::Sendable,
    */
   void SetSimDevice(HAL_SimDeviceHandle device);
 
-  void InitSendable(wpi::SendableBuilder& builder) override;
-
  private:
   int m_channel;
   hal::Handle<HAL_AnalogInputHandle> m_port;
   int64_t m_accumulatorOffset;
 };
 
 }  // namespace frc
+
+namespace wpi2 {
+
+template<>
+struct Sendable<frc::AnalogInput> {
+  static constexpr std::string_view GetTypeString() { return "Analog Input"; }
+  static void Init(frc::AnalogInput* obj, SendableTable& table);
+  static void Close(frc::AnalogInput* obj, SendableTable& table) {}
+};
+
+static_assert(SendableSerializable<frc::AnalogInput>);
+
+}  // namespace wpi2

wpilibc/src/main/native/include/frc/AnalogTrigger.h

@@ -7,8 +7,8 @@
 #include <memory>
 
 #include <hal/Types.h>
-#include <wpi/sendable/Sendable.h>
-#include <wpi/sendable/SendableHelper.h>
+#include <wpi/sendable2/Sendable.h>
+#include <wpi/MoveTracker.h>
 
 #include "frc/AnalogTriggerOutput.h"
 
@@ -17,9 +17,9 @@ namespace frc {
 class AnalogInput;
 class DutyCycle;
 
-class AnalogTrigger : public wpi::Sendable,
-                      public wpi::SendableHelper<AnalogTrigger> {
+class AnalogTrigger : public wpi::MoveTrackerBase {
   friend class AnalogTriggerOutput;
+  friend struct wpi2::Sendable<frc::AnalogTrigger>;
 
  public:
   /**
@@ -148,8 +148,6 @@ class AnalogTrigger : public wpi::Sendable,
   std::shared_ptr<AnalogTriggerOutput> CreateOutput(
       AnalogTriggerType type) const;
 
-  void InitSendable(wpi::SendableBuilder& builder) override;
-
  private:
   int GetSourceChannel() const;
 
@@ -160,3 +158,16 @@ class AnalogTrigger : public wpi::Sendable,
 };
 
 }  // namespace frc
+
+namespace wpi2 {
+
+template <>
+struct Sendable<frc::AnalogTrigger> {
+  static constexpr std::string_view GetTypeString() { return "Analog Input"; }
+  static void Init(frc::AnalogTrigger* obj, SendableTable& table);
+  static void Close(frc::AnalogTrigger* obj, SendableTable& table) {}
+};
+
+static_assert(SendableSerializable<frc::AnalogTrigger>);
+
+}  // namespace wpi2