Move datalog backend to datalog library

Author: PeterJohnson

wpiutil/src/main/native/cpp/datalog/DataLogTelemetryBackend.cpp renamed to datalog/src/main/native/cpp/DataLogTelemetryBackend.cpp

@@ -10,16 +10,16 @@
 #include <variant>
 
 #include <fmt/format.h>
+#include <wpi/mutex.h>
+#include <wpi/telemetry/TelemetryEntry.h>
 
-#include "wpi/mutex.h"
-#include "wpi/telemetry/TelemetryEntry.h"
-#include "wpi/DataLog.h"
+#include "wpi/datalog/DataLog.h"
 
-using namespace wpi;
+using namespace wpi::log;
 
-class DataLogTelemetryBackend::Entry : public TelemetryEntry {
+class DataLogTelemetryBackend::Entry : public wpi::TelemetryEntry {
  public:
-  Entry(wpi::log::DataLog& log, std::string_view prefix, std::string_view path)
+  Entry(DataLog& log, std::string_view prefix, std::string_view path)
       : m_log{log}, m_path{fmt::format("{}{}", prefix, path)} {}
 
   void KeepDuplicates() override { m_keepDuplicates = true; }
@@ -70,30 +70,24 @@ class DataLogTelemetryBackend::Entry : public TelemetryEntry {
     }
   }
 
-  void LogBoolean(bool value) override {
-    Log<wpi::log::BooleanLogEntry>(value);
-  }
+  void LogBoolean(bool value) override { Log<BooleanLogEntry>(value); }
 
-  void LogInt64(int64_t value) override {
-    Log<wpi::log::IntegerLogEntry>(value);
-  }
+  void LogInt64(int64_t value) override { Log<IntegerLogEntry>(value); }
 
-  void LogFloat(float value) override { Log<wpi::log::FloatLogEntry>(value); }
+  void LogFloat(float value) override { Log<FloatLogEntry>(value); }
 
-  void LogDouble(double value) override {
-    Log<wpi::log::DoubleLogEntry>(value);
-  }
+  void LogDouble(double value) override { Log<DoubleLogEntry>(value); }
 
   void LogString(std::string_view value, std::string_view typeString) override {
-    LogTypeString<wpi::log::StringLogEntry>(value, typeString);
+    LogTypeString<StringLogEntry>(value, typeString);
   }
 
   void LogBooleanArray(std::span<const bool> value) override {
-    Log<wpi::log::BooleanArrayLogEntry>(value);
+    Log<BooleanArrayLogEntry>(value);
   }
 
   void LogBooleanArray(std::span<const int> value) override {
-    Log<wpi::log::BooleanArrayLogEntry>(value);
+    Log<BooleanArrayLogEntry>(value);
   }
 
   void LogInt16Array(std::span<const int16_t> value) override {
@@ -105,54 +99,52 @@ class DataLogTelemetryBackend::Entry : public TelemetryEntry {
   }
 
   void LogInt64Array(std::span<const int64_t> value) override {
-    Log<wpi::log::IntegerArrayLogEntry>(value);
+    Log<IntegerArrayLogEntry>(value);
   }
 
   void LogFloatArray(std::span<const float> value) override {
-    Log<wpi::log::FloatArrayLogEntry>(value);
+    Log<FloatArrayLogEntry>(value);
   }
 
   void LogDoubleArray(std::span<const double> value) override {
-    Log<wpi::log::DoubleArrayLogEntry>(value);
+    Log<DoubleArrayLogEntry>(value);
   }
 
   void LogStringArray(std::span<const std::string> value) override {
-    Log<wpi::log::StringArrayLogEntry>(value);
+    Log<StringArrayLogEntry>(value);
   }
 
   void LogStringArray(std::span<const std::string_view> value) override {
-    Log<wpi::log::StringArrayLogEntry>(value);
+    Log<StringArrayLogEntry>(value);
   }
 
   void LogRaw(std::span<const uint8_t> value,
               std::string_view typeString) override {
-    LogTypeString<wpi::log::RawLogEntry>(value, typeString);
+    LogTypeString<RawLogEntry>(value, typeString);
   }
 
  private:
-  wpi::log::DataLog& m_log;
+  DataLog& m_log;
   std::string m_path;
   wpi::mutex m_mutex;
-  std::variant<std::monostate, wpi::log::BooleanLogEntry,
-               wpi::log::IntegerLogEntry, wpi::log::FloatLogEntry,
-               wpi::log::DoubleLogEntry, wpi::log::StringLogEntry,
-               wpi::log::BooleanArrayLogEntry, wpi::log::IntegerArrayLogEntry,
-               wpi::log::FloatArrayLogEntry, wpi::log::DoubleArrayLogEntry,
-               wpi::log::StringArrayLogEntry, wpi::log::RawLogEntry>
+  std::variant<std::monostate, BooleanLogEntry, IntegerLogEntry, FloatLogEntry,
+               DoubleLogEntry, StringLogEntry, BooleanArrayLogEntry,
+               IntegerArrayLogEntry, FloatArrayLogEntry, DoubleArrayLogEntry,
+               StringArrayLogEntry, RawLogEntry>
       m_entry;
   std::string m_typeString;
   std::atomic_bool m_keepDuplicates{false};
   wpi::StringMap<std::string> m_propertiesMap;
   std::string m_properties = "{}";
 };
 
-DataLogTelemetryBackend::DataLogTelemetryBackend(wpi::log::DataLog& log,
+DataLogTelemetryBackend::DataLogTelemetryBackend(DataLog& log,
                                                  std::string_view prefix)
     : m_log{log}, m_prefix{prefix} {}
 
 DataLogTelemetryBackend::~DataLogTelemetryBackend() = default;
 
-TelemetryEntry& DataLogTelemetryBackend::GetEntry(std::string_view path) {
+wpi::TelemetryEntry& DataLogTelemetryBackend::GetEntry(std::string_view path) {
   std::scoped_lock lock{m_mutex};
   return m_entries.try_emplace(path, m_log, m_prefix, path).first->second;
 }

wpiutil/src/main/native/include/wpi/datalog/DataLogTelemetryBackend.h renamed to datalog/src/main/native/include/wpi/datalog/DataLogTelemetryBackend.h

@@ -4,26 +4,24 @@
 
 #pragma once
 
-#include "wpi/mutex.h"
-#include "wpi/telemetry/TelemetryBackend.h"
-#include "wpi/StringMap.h"
+#include <wpi/mutex.h>
+#include <wpi/telemetry/TelemetryBackend.h>
+#include <wpi/StringMap.h>
 
-namespace wpi {
+namespace wpi::log {
 
-namespace log {
 class DataLog;
-}  // namespace log
 
 /** A telemetry backend that sends logged data to a DataLog. */
-class DataLogTelemetryBackend : public TelemetryBackend {
+class DataLogTelemetryBackend : public wpi::TelemetryBackend {
  public:
   /**
    * Construct.
    *
    * @param log datalog
    * @param prefix prefix to put in front of logged path in data log
    */
-  DataLogTelemetryBackend(wpi::log::DataLog& log, std::string_view prefix);
+  DataLogTelemetryBackend(DataLog& log, std::string_view prefix);
 
   ~DataLogTelemetryBackend() override;
 
@@ -33,7 +31,7 @@ class DataLogTelemetryBackend : public TelemetryBackend {
    * @param path full name
    * @return telemetry entry
    */
-  TelemetryEntry& GetEntry(std::string_view path) override;
+  wpi::TelemetryEntry& GetEntry(std::string_view path) override;
 
   /**
    * Returns whether there is a data schema already registered with the given
@@ -83,10 +81,10 @@ class DataLogTelemetryBackend : public TelemetryBackend {
  private:
   class Entry;
 
-  wpi::log::DataLog& m_log;
+  DataLog& m_log;
   std::string m_prefix;
   wpi::mutex m_mutex;
   wpi::StringMap<Entry> m_entries;
 };
 
-}  // namespace wpi
+}  // namespace wpi::log