[ntcore] NetworkTables 4 (#3217)

ntcore/src/main/native/cpp/LoggerImpl.h

@@ -2,76 +2,36 @@
 // 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.
 
-#ifndef NTCORE_LOGGERIMPL_H_
-#define NTCORE_LOGGERIMPL_H_
+#pragma once
 
 #include <utility>
+#include <vector>
 
-#include <wpi/CallbackManager.h>
+#include <wpi/SafeThread.h>
+#include <wpi/Synchronization.h>
+#include <wpi/mutex.h>
 
 #include "Handle.h"
+#include "HandleMap.h"
+#include "ntcore_c.h"
 #include "ntcore_cpp.h"
 
 namespace nt {
 
-namespace impl {
-
-struct LoggerListenerData : public wpi::CallbackListenerData<
-                                std::function<void(const LogMessage& msg)>> {
-  LoggerListenerData() = default;
-  LoggerListenerData(std::function<void(const LogMessage& msg)> callback_,
-                     unsigned int min_level_, unsigned int max_level_)
-      : CallbackListenerData(callback_),
-        min_level(min_level_),
-        max_level(max_level_) {}
-  LoggerListenerData(unsigned int poller_uid_, unsigned int min_level_,
-                     unsigned int max_level_)
-      : CallbackListenerData(poller_uid_),
-        min_level(min_level_),
-        max_level(max_level_) {}
-
-  unsigned int min_level;
-  unsigned int max_level;
-};
-
-class LoggerThread
-    : public wpi::CallbackThread<LoggerThread, LogMessage, LoggerListenerData> {
- public:
-  LoggerThread(std::function<void()> on_start, std::function<void()> on_exit,
-               int inst)
-      : CallbackThread(std::move(on_start), std::move(on_exit)), m_inst(inst) {}
-
-  bool Matches(const LoggerListenerData& listener, const LogMessage& data) {
-    return data.level >= listener.min_level && data.level <= listener.max_level;
-  }
-
-  void SetListener(LogMessage* data, unsigned int listener_uid) {
-    data->logger = Handle(m_inst, listener_uid, Handle::kLogger).handle();
-  }
-
-  void DoCallback(std::function<void(const LogMessage& msg)> callback,
-                  const LogMessage& data) {
-    callback(data);
-  }
-
-  int m_inst;
-};
-
-}  // namespace impl
-
-class LoggerImpl : public wpi::CallbackManager<LoggerImpl, impl::LoggerThread> {
-  friend class LoggerTest;
-  friend class wpi::CallbackManager<LoggerImpl, impl::LoggerThread>;
-
+class LoggerImpl {
  public:
   explicit LoggerImpl(int inst);
+  ~LoggerImpl();
 
-  void Start();
+  NT_Logger Add(std::function<void(const LogMessage& msg)> callback,
+                unsigned int minLevel, unsigned int maxLevel);
 
-  unsigned int Add(std::function<void(const LogMessage& msg)> callback,
-                   unsigned int min_level, unsigned int max_level);
-  unsigned int AddPolled(unsigned int poller_uid, unsigned int min_level,
-                         unsigned int max_level);
+  NT_LoggerPoller CreatePoller();
+  void DestroyPoller(NT_LoggerPoller pollerHandle);
+  NT_Logger AddPolled(NT_LoggerPoller pollerHandle, unsigned int minLevel,
+                      unsigned int maxLevel);
+  std::vector<LogMessage> ReadQueue(NT_LoggerPoller pollerHandle);
+  void Remove(NT_Logger listenerHandle);
 
   unsigned int GetMinLevel();
 
@@ -80,8 +40,37 @@ class LoggerImpl : public wpi::CallbackManager<LoggerImpl, impl::LoggerThread> {
 
  private:
   int m_inst;
+  mutable wpi::mutex m_mutex;
+
+  struct PollerData {
+    static constexpr auto kType = Handle::kLoggerPoller;
+
+    explicit PollerData(NT_LoggerPoller handle) : handle{handle} {}
+
+    wpi::SignalObject<NT_LoggerPoller> handle;
+    std::vector<LogMessage> queue;
+  };
+  HandleMap<PollerData, 8> m_pollers;
+
+  struct ListenerData {
+    static constexpr auto kType = Handle::kLogger;
+
+    ListenerData(NT_Logger handle, PollerData* poller, unsigned int minLevel,
+                 unsigned int maxLevel)
+        : handle{handle},
+          poller{poller},
+          minLevel{minLevel},
+          maxLevel{maxLevel} {}
+
+    wpi::SignalObject<NT_Logger> handle;
+    PollerData* poller;
+    unsigned int minLevel;
+    unsigned int maxLevel;
+  };
+  HandleMap<ListenerData, 8> m_listeners;
+
+  class Thread;
+  wpi::SafeThreadOwner<Thread> m_thread;
 };
 
 }  // namespace nt
-
-#endif  // NTCORE_LOGGERIMPL_H_