[ntcore] Unify listeners (#4536)

This combines all 4 NT listener APIs (topic, value, connection, and
logging) into a single unified listener API.

glass/src/libnt/native/cpp/NTField2D.cpp

@@ -117,58 +117,55 @@ NTField2DModel::NTField2DModel(nt::NetworkTableInstance inst,
                  {{nt::PubSubOption::SendAll(true),
                    nt::PubSubOption::Periodic(0.05)}}},
       m_nameTopic{inst.GetTopic(fmt::format("{}/.name", path))},
-      m_topicListener{inst},
-      m_valueListener{inst} {
-  m_topicListener.Add(m_tableSub, NT_TOPIC_NOTIFY_PUBLISH |
-                                      NT_TOPIC_NOTIFY_UNPUBLISH |
-                                      NT_TOPIC_NOTIFY_IMMEDIATE);
-  m_valueListener.Add(m_tableSub,
-                      NT_VALUE_NOTIFY_IMMEDIATE | NT_VALUE_NOTIFY_LOCAL);
+      m_poller{inst} {
+  m_poller.AddListener(m_tableSub, nt::EventFlags::kTopic |
+                                       nt::EventFlags::kValueAll |
+                                       nt::EventFlags::kImmediate);
 }
 
 NTField2DModel::~NTField2DModel() = default;
 
 void NTField2DModel::Update() {
-  // handle publish/unpublish
-  for (auto&& event : m_topicListener.ReadQueue()) {
-    auto name = wpi::drop_front(event.info.name, m_path.size());
-    if (name.empty() || name[0] == '.') {
-      continue;
-    }
-    auto [it, match] = Find(event.info.name);
-    if (event.flags & NT_TOPIC_NOTIFY_UNPUBLISH) {
-      if (match) {
-        m_objects.erase(it);
+  for (auto&& event : m_poller.ReadQueue()) {
+    if (auto info = event.GetTopicInfo()) {
+      // handle publish/unpublish
+      auto name = wpi::drop_front(info->name, m_path.size());
+      if (name.empty() || name[0] == '.') {
+        continue;
       }
-      continue;
-    } else if (event.flags & NT_TOPIC_NOTIFY_PUBLISH) {
-      if (!match) {
-        it = m_objects.emplace(
-            it, std::make_unique<ObjectModel>(
-                    event.info.name, nt::DoubleArrayTopic{event.info.topic}));
+      auto [it, match] = Find(info->name);
+      if (event.flags & nt::EventFlags::kUnpublish) {
+        if (match) {
+          m_objects.erase(it);
+        }
+        continue;
+      } else if (event.flags & nt::EventFlags::kPublish) {
+        if (!match) {
+          it = m_objects.emplace(
+              it, std::make_unique<ObjectModel>(
+                      info->name, nt::DoubleArrayTopic{info->topic}));
+        }
+      } else if (!match) {
+        continue;
+      }
+    } else if (auto valueData = event.GetValueEventData()) {
+      // update values
+      // .name
+      if (valueData->topic == m_nameTopic.GetHandle()) {
+        if (valueData->value && valueData->value.IsString()) {
+          m_nameValue = valueData->value.GetString();
+        }
+        continue;
       }
-    } else if (!match) {
-      continue;
-    }
-  }
 
-  // update values
-  for (auto&& event : m_valueListener.ReadQueue()) {
-    // .name
-    if (event.topic == m_nameTopic.GetHandle()) {
-      if (event.value && event.value.IsString()) {
-        m_nameValue = event.value.GetString();
+      auto it =
+          std::find_if(m_objects.begin(), m_objects.end(), [&](const auto& e) {
+            return e->GetTopic().GetHandle() == valueData->topic;
+          });
+      if (it != m_objects.end()) {
+        (*it)->NTUpdate(valueData->value);
+        continue;
       }
-      continue;
-    }
-
-    auto it =
-        std::find_if(m_objects.begin(), m_objects.end(), [&](const auto& e) {
-          return e->GetTopic().GetHandle() == event.topic;
-        });
-    if (it != m_objects.end()) {
-      (*it)->NTUpdate(event.value);
-      continue;
     }
   }
 }

glass/src/libnt/native/cpp/NTMechanism2D.cpp

@@ -41,8 +41,7 @@ class NTMechanismGroupImpl final {
   const char* GetName() const { return m_name.c_str(); }
   void ForEachObject(wpi::function_ref<void(MechanismObjectModel& model)> func);
 
-  void NTUpdate(const nt::TopicNotification& event, std::string_view name);
-  void NTUpdate(const nt::ValueNotification& event, std::string_view name);
+  void NTUpdate(const nt::Event& event, std::string_view name);
 
  protected:
   nt::NetworkTableInstance m_inst;
@@ -74,8 +73,7 @@ class NTMechanismObjectModel final : public MechanismObjectModel {
   frc::Rotation2d GetAngle() const final { return m_angleValue; }
   units::meter_t GetLength() const final { return m_lengthValue; }
 
-  bool NTUpdate(const nt::TopicNotification& event, std::string_view name);
-  void NTUpdate(const nt::ValueNotification& event, std::string_view name);
+  bool NTUpdate(const nt::Event& event, std::string_view name);
 
  private:
   NTMechanismGroupImpl m_group;
@@ -102,7 +100,7 @@ void NTMechanismGroupImpl::ForEachObject(
   }
 }
 
-void NTMechanismGroupImpl::NTUpdate(const nt::TopicNotification& event,
+void NTMechanismGroupImpl::NTUpdate(const nt::Event& event,
                                     std::string_view name) {
   if (name.empty()) {
     return;
@@ -118,83 +116,69 @@ void NTMechanismGroupImpl::NTUpdate(const nt::TopicNotification& event,
       [](const auto& e, std::string_view name) { return e->GetName() < name; });
   bool match = it != m_objects.end() && (*it)->GetName() == name;
 
-  if (event.flags & NT_TOPIC_NOTIFY_PUBLISH) {
-    if (!match) {
-      it = m_objects.emplace(
-          it, std::make_unique<NTMechanismObjectModel>(
-                  m_inst, fmt::format("{}/{}", m_path, name), name));
-      match = true;
+  if (event.GetTopicInfo()) {
+    if (event.flags & nt::EventFlags::kPublish) {
+      if (!match) {
+        it = m_objects.emplace(
+            it, std::make_unique<NTMechanismObjectModel>(
+                    m_inst, fmt::format("{}/{}", m_path, name), name));
+        match = true;
+      }
     }
-  }
 
-  if (match) {
-    if ((*it)->NTUpdate(event, childName)) {
-      m_objects.erase(it);
+    if (match) {
+      if ((*it)->NTUpdate(event, childName)) {
+        m_objects.erase(it);
+      }
+    }
+  } else if (event.GetValueEventData()) {
+    if (match) {
+      (*it)->NTUpdate(event, childName);
     }
   }
 }
 
-void NTMechanismGroupImpl::NTUpdate(const nt::ValueNotification& event,
-                                    std::string_view name) {
-  if (name.empty()) {
-    return;
-  }
-  std::string_view childName;
-  std::tie(name, childName) = wpi::split(name, '/');
-  if (childName.empty()) {
-    return;
-  }
-
-  auto it = std::lower_bound(
-      m_objects.begin(), m_objects.end(), name,
-      [](const auto& e, std::string_view name) { return e->GetName() < name; });
-  if (it != m_objects.end() && (*it)->GetName() == name) {
-    (*it)->NTUpdate(event, childName);
-  }
-}
-
-bool NTMechanismObjectModel::NTUpdate(const nt::TopicNotification& event,
+bool NTMechanismObjectModel::NTUpdate(const nt::Event& event,
                                       std::string_view childName) {
-  if (event.info.topic == m_typeTopic.GetHandle()) {
-    if (event.flags & NT_TOPIC_NOTIFY_UNPUBLISH) {
-      return true;
+  if (auto info = event.GetTopicInfo()) {
+    if (info->topic == m_typeTopic.GetHandle()) {
+      if (event.flags & nt::EventFlags::kUnpublish) {
+        return true;
+      }
+    } else if (info->topic != m_colorTopic.GetHandle() &&
+               info->topic != m_weightTopic.GetHandle() &&
+               info->topic != m_angleTopic.GetHandle() &&
+               info->topic != m_lengthTopic.GetHandle()) {
+      m_group.NTUpdate(event, childName);
+    }
+  } else if (auto valueData = event.GetValueEventData()) {
+    if (valueData->topic == m_typeTopic.GetHandle()) {
+      if (valueData->value && valueData->value.IsString()) {
+        m_typeValue = valueData->value.GetString();
+      }
+    } else if (valueData->topic == m_colorTopic.GetHandle()) {
+      if (valueData->value && valueData->value.IsString()) {
+        ConvertColor(valueData->value.GetString(), &m_colorValue);
+      }
+    } else if (valueData->topic == m_weightTopic.GetHandle()) {
+      if (valueData->value && valueData->value.IsDouble()) {
+        m_weightValue = valueData->value.GetDouble();
+      }
+    } else if (valueData->topic == m_angleTopic.GetHandle()) {
+      if (valueData->value && valueData->value.IsDouble()) {
+        m_angleValue = units::degree_t{valueData->value.GetDouble()};
+      }
+    } else if (valueData->topic == m_lengthTopic.GetHandle()) {
+      if (valueData->value && valueData->value.IsDouble()) {
+        m_lengthValue = units::meter_t{valueData->value.GetDouble()};
+      }
+    } else {
+      m_group.NTUpdate(event, childName);
     }
-  } else if (event.info.topic != m_colorTopic.GetHandle() &&
-             event.info.topic != m_weightTopic.GetHandle() &&
-             event.info.topic != m_angleTopic.GetHandle() &&
-             event.info.topic != m_lengthTopic.GetHandle()) {
-    m_group.NTUpdate(event, childName);
   }
   return false;
 }
 
-void NTMechanismObjectModel::NTUpdate(const nt::ValueNotification& event,
-                                      std::string_view childName) {
-  if (event.topic == m_typeTopic.GetHandle()) {
-    if (event.value && event.value.IsString()) {
-      m_typeValue = event.value.GetString();
-    }
-  } else if (event.topic == m_colorTopic.GetHandle()) {
-    if (event.value && event.value.IsString()) {
-      ConvertColor(event.value.GetString(), &m_colorValue);
-    }
-  } else if (event.topic == m_weightTopic.GetHandle()) {
-    if (event.value && event.value.IsDouble()) {
-      m_weightValue = event.value.GetDouble();
-    }
-  } else if (event.topic == m_angleTopic.GetHandle()) {
-    if (event.value && event.value.IsDouble()) {
-      m_angleValue = units::degree_t{event.value.GetDouble()};
-    }
-  } else if (event.topic == m_lengthTopic.GetHandle()) {
-    if (event.value && event.value.IsDouble()) {
-      m_lengthValue = units::meter_t{event.value.GetDouble()};
-    }
-  } else {
-    m_group.NTUpdate(event, childName);
-  }
-}
-
 class NTMechanism2DModel::RootModel final : public MechanismRootModel {
  public:
   RootModel(nt::NetworkTableInstance inst, std::string_view path,
@@ -209,8 +193,7 @@ class NTMechanism2DModel::RootModel final : public MechanismRootModel {
     m_group.ForEachObject(func);
   }
 
-  bool NTUpdate(const nt::TopicNotification& event, std::string_view childName);
-  void NTUpdate(const nt::ValueNotification& event, std::string_view childName);
+  bool NTUpdate(const nt::Event& event, std::string_view childName);
 
   frc::Translation2d GetPosition() const override { return m_pos; };
 
@@ -221,36 +204,35 @@ class NTMechanism2DModel::RootModel final : public MechanismRootModel {
   frc::Translation2d m_pos;
 };
 
-bool NTMechanism2DModel::RootModel::NTUpdate(const nt::TopicNotification& event,
+bool NTMechanism2DModel::RootModel::NTUpdate(const nt::Event& event,
                                              std::string_view childName) {
-  if (event.info.topic == m_xTopic.GetHandle() ||
-      event.info.topic == m_yTopic.GetHandle()) {
-    if (event.flags & NT_TOPIC_NOTIFY_UNPUBLISH) {
-      return true;
+  if (auto info = event.GetTopicInfo()) {
+    if (info->topic == m_xTopic.GetHandle() ||
+        info->topic == m_yTopic.GetHandle()) {
+      if (event.flags & nt::EventFlags::kUnpublish) {
+        return true;
+      }
+    } else {
+      m_group.NTUpdate(event, childName);
+    }
+  } else if (auto valueData = event.GetValueEventData()) {
+    if (valueData->topic == m_xTopic.GetHandle()) {
+      if (valueData->value && valueData->value.IsDouble()) {
+        m_pos = frc::Translation2d{units::meter_t{valueData->value.GetDouble()},
+                                   m_pos.Y()};
+      }
+    } else if (valueData->topic == m_yTopic.GetHandle()) {
+      if (valueData->value && valueData->value.IsDouble()) {
+        m_pos = frc::Translation2d{
+            m_pos.X(), units::meter_t{valueData->value.GetDouble()}};
+      }
+    } else {
+      m_group.NTUpdate(event, childName);
     }
-  } else {
-    m_group.NTUpdate(event, childName);
   }
   return false;
 }
 
-void NTMechanism2DModel::RootModel::NTUpdate(const nt::ValueNotification& event,
-                                             std::string_view childName) {
-  if (event.topic == m_xTopic.GetHandle()) {
-    if (event.value && event.value.IsDouble()) {
-      m_pos = frc::Translation2d{units::meter_t{event.value.GetDouble()},
-                                 m_pos.Y()};
-    }
-  } else if (event.topic == m_yTopic.GetHandle()) {
-    if (event.value && event.value.IsDouble()) {
-      m_pos = frc::Translation2d{m_pos.X(),
-                                 units::meter_t{event.value.GetDouble()}};
-    }
-  } else {
-    m_group.NTUpdate(event, childName);
-  }
-}
-
 NTMechanism2DModel::NTMechanism2DModel(std::string_view path)
     : NTMechanism2DModel{nt::NetworkTableInstance::GetDefault(), path} {}
 
@@ -265,75 +247,72 @@ NTMechanism2DModel::NTMechanism2DModel(nt::NetworkTableInstance inst,
       m_nameTopic{m_inst.GetTopic(fmt::format("{}/.name", path))},
       m_dimensionsTopic{m_inst.GetTopic(fmt::format("{}/dims", path))},
       m_bgColorTopic{m_inst.GetTopic(fmt::format("{}/backgroundColor", path))},
-      m_topicListener{m_inst},
-      m_valueListener{m_inst},
+      m_poller{m_inst},
       m_dimensionsValue{1_m, 1_m} {
-  m_topicListener.Add(m_tableSub, NT_TOPIC_NOTIFY_PUBLISH |
-                                      NT_TOPIC_NOTIFY_UNPUBLISH |
-                                      NT_TOPIC_NOTIFY_IMMEDIATE);
-  m_valueListener.Add(m_tableSub,
-                      NT_VALUE_NOTIFY_IMMEDIATE | NT_VALUE_NOTIFY_LOCAL);
+  m_poller.AddListener(m_tableSub, nt::EventFlags::kTopic |
+                                       nt::EventFlags::kValueAll |
+                                       nt::EventFlags::kImmediate);
 }
 
 NTMechanism2DModel::~NTMechanism2DModel() = default;
 
 void NTMechanism2DModel::Update() {
-  for (auto&& event : m_topicListener.ReadQueue()) {
-    auto name = wpi::drop_front(event.info.name, m_path.size());
-    if (name.empty() || name[0] == '.') {
-      continue;
-    }
-    std::string_view childName;
-    std::tie(name, childName) = wpi::split(name, '/');
-    if (childName.empty()) {
-      continue;
-    }
-
-    auto it = std::lower_bound(m_roots.begin(), m_roots.end(), name,
-                               [](const auto& e, std::string_view name) {
-                                 return e->GetName() < name;
-                               });
-    bool match = it != m_roots.end() && (*it)->GetName() == name;
-
-    if (event.flags & NT_TOPIC_NOTIFY_PUBLISH) {
-      if (!match) {
-        it = m_roots.emplace(
-            it, std::make_unique<RootModel>(
-                    m_inst, fmt::format("{}{}", m_path, name), name));
-        match = true;
+  for (auto&& event : m_poller.ReadQueue()) {
+    if (auto info = event.GetTopicInfo()) {
+      auto name = wpi::drop_front(info->name, m_path.size());
+      if (name.empty() || name[0] == '.') {
+        continue;
       }
-    }
-    if (match) {
-      if ((*it)->NTUpdate(event, childName)) {
-        m_roots.erase(it);
+      std::string_view childName;
+      std::tie(name, childName) = wpi::split(name, '/');
+      if (childName.empty()) {
+        continue;
       }
-    }
-  }
 
-  for (auto&& event : m_valueListener.ReadQueue()) {
-    // .name
-    if (event.topic == m_nameTopic.GetHandle()) {
-      if (event.value && event.value.IsString()) {
-        m_nameValue = event.value.GetString();
-      }
-      continue;
-    }
+      auto it = std::lower_bound(m_roots.begin(), m_roots.end(), name,
+                                 [](const auto& e, std::string_view name) {
+                                   return e->GetName() < name;
+                                 });
+      bool match = it != m_roots.end() && (*it)->GetName() == name;
 
-    // dims
-    if (event.topic == m_dimensionsTopic.GetHandle()) {
-      if (event.value && event.value.IsDoubleArray()) {
-        auto arr = event.value.GetDoubleArray();
-        if (arr.size() == 2) {
-          m_dimensionsValue = frc::Translation2d{units::meter_t{arr[0]},
-                                                 units::meter_t{arr[1]}};
+      if (event.flags & nt::EventFlags::kPublish) {
+        if (!match) {
+          it = m_roots.emplace(
+              it, std::make_unique<RootModel>(
+                      m_inst, fmt::format("{}{}", m_path, name), name));
+          match = true;
         }
       }
-    }
+      if (match) {
+        if ((*it)->NTUpdate(event, childName)) {
+          m_roots.erase(it);
+        }
+      }
+    } else if (auto valueData = event.GetValueEventData()) {
+      // .name
+      if (valueData->topic == m_nameTopic.GetHandle()) {
+        if (valueData->value && valueData->value.IsString()) {
+          m_nameValue = valueData->value.GetString();
+        }
+        continue;
+      }
 
-    // backgroundColor
-    if (event.topic == m_bgColorTopic.GetHandle()) {
-      if (event.value && event.value.IsString()) {
-        ConvertColor(event.value.GetString(), &m_bgColorValue);
+      // dims
+      if (valueData->topic == m_dimensionsTopic.GetHandle()) {
+        if (valueData->value && valueData->value.IsDoubleArray()) {
+          auto arr = valueData->value.GetDoubleArray();
+          if (arr.size() == 2) {
+            m_dimensionsValue = frc::Translation2d{units::meter_t{arr[0]},
+                                                   units::meter_t{arr[1]}};
+          }
+        }
+      }
+
+      // backgroundColor
+      if (valueData->topic == m_bgColorTopic.GetHandle()) {
+        if (valueData->value && valueData->value.IsString()) {
+          ConvertColor(valueData->value.GetString(), &m_bgColorValue);
+        }
       }
     }
   }

glass/src/libnt/native/cpp/NetworkTables.cpp

@@ -110,15 +110,10 @@ NetworkTablesModel::NetworkTablesModel()
     : NetworkTablesModel{nt::NetworkTableInstance::GetDefault()} {}
 
 NetworkTablesModel::NetworkTablesModel(nt::NetworkTableInstance inst)
-    : m_inst{inst},
-      m_subscriber{inst, {{"", "$"}}},
-      m_topicPoller{inst},
-      m_valuePoller{inst} {
-  m_topicPoller.Add(m_subscriber,
-                    NT_TOPIC_NOTIFY_IMMEDIATE | NT_TOPIC_NOTIFY_PROPERTIES |
-                        NT_TOPIC_NOTIFY_PUBLISH | NT_TOPIC_NOTIFY_UNPUBLISH);
-  m_valuePoller.Add(m_subscriber,
-                    NT_VALUE_NOTIFY_IMMEDIATE | NT_VALUE_NOTIFY_LOCAL);
+    : m_inst{inst}, m_poller{inst} {
+  m_poller.AddListener({{"", "$"}}, nt::EventFlags::kTopic |
+                                        nt::EventFlags::kValueAll |
+                                        nt::EventFlags::kImmediate);
 }
 
 NetworkTablesModel::Entry::~Entry() {
@@ -426,56 +421,57 @@ void NetworkTablesModel::ValueSource::UpdateFromValue(
 
 void NetworkTablesModel::Update() {
   bool updateTree = false;
-  for (auto&& event : m_topicPoller.ReadQueue()) {
-    auto& entry = m_entries[event.info.topic];
-    if (event.flags & NT_TOPIC_NOTIFY_PUBLISH) {
-      if (!entry) {
-        entry = std::make_unique<Entry>();
-        m_sortedEntries.emplace_back(entry.get());
+  for (auto&& event : m_poller.ReadQueue()) {
+    if (auto info = event.GetTopicInfo()) {
+      auto& entry = m_entries[info->topic];
+      if (event.flags & nt::EventFlags::kPublish) {
+        if (!entry) {
+          entry = std::make_unique<Entry>();
+          m_sortedEntries.emplace_back(entry.get());
+          updateTree = true;
+        }
+      }
+      if (event.flags & nt::EventFlags::kUnpublish) {
+        auto it = std::find(m_sortedEntries.begin(), m_sortedEntries.end(),
+                            entry.get());
+        // will be removed completely below
+        if (it != m_sortedEntries.end()) {
+          *it = nullptr;
+        }
+        m_entries.erase(info->topic);
+        updateTree = true;
+        continue;
+      }
+      if (event.flags & nt::EventFlags::kProperties) {
         updateTree = true;
       }
-    }
-    if (event.flags & NT_TOPIC_NOTIFY_UNPUBLISH) {
-      auto it = std::find(m_sortedEntries.begin(), m_sortedEntries.end(),
-                          entry.get());
-      // will be removed completely below
-      if (it != m_sortedEntries.end()) {
-        *it = nullptr;
+      if (entry) {
+        entry->UpdateTopic(std::move(event));
       }
-      m_entries.erase(event.info.topic);
-      updateTree = true;
-      continue;
-    }
-    if (event.flags & NT_TOPIC_NOTIFY_PROPERTIES) {
-      updateTree = true;
-    }
-    if (entry) {
-      entry->UpdateTopic(std::move(event));
-    }
-  }
-  for (auto&& event : m_valuePoller.ReadQueue()) {
-    auto& entry = m_entries[event.topic];
-    if (entry) {
-      entry->UpdateFromValue(std::move(event.value), entry->info.name,
-                             entry->info.type_str);
-      if (wpi::starts_with(entry->info.name, '$') && entry->value.IsRaw() &&
-          entry->info.type_str == "msgpack") {
-        // meta topic handling
-        if (entry->info.name == "$clients") {
-          UpdateClients(entry->value.GetRaw());
-        } else if (entry->info.name == "$serverpub") {
-          m_server.UpdatePublishers(entry->value.GetRaw());
-        } else if (entry->info.name == "$serversub") {
-          m_server.UpdateSubscribers(entry->value.GetRaw());
-        } else if (wpi::starts_with(entry->info.name, "$clientpub$")) {
-          auto it = m_clients.find(wpi::drop_front(entry->info.name, 11));
-          if (it != m_clients.end()) {
-            it->second.UpdatePublishers(entry->value.GetRaw());
-          }
-        } else if (wpi::starts_with(entry->info.name, "$clientsub$")) {
-          auto it = m_clients.find(wpi::drop_front(entry->info.name, 11));
-          if (it != m_clients.end()) {
-            it->second.UpdateSubscribers(entry->value.GetRaw());
+    } else if (auto valueData = event.GetValueEventData()) {
+      auto& entry = m_entries[valueData->topic];
+      if (entry) {
+        entry->UpdateFromValue(std::move(valueData->value), entry->info.name,
+                               entry->info.type_str);
+        if (wpi::starts_with(entry->info.name, '$') && entry->value.IsRaw() &&
+            entry->info.type_str == "msgpack") {
+          // meta topic handling
+          if (entry->info.name == "$clients") {
+            UpdateClients(entry->value.GetRaw());
+          } else if (entry->info.name == "$serverpub") {
+            m_server.UpdatePublishers(entry->value.GetRaw());
+          } else if (entry->info.name == "$serversub") {
+            m_server.UpdateSubscribers(entry->value.GetRaw());
+          } else if (wpi::starts_with(entry->info.name, "$clientpub$")) {
+            auto it = m_clients.find(wpi::drop_front(entry->info.name, 11));
+            if (it != m_clients.end()) {
+              it->second.UpdatePublishers(entry->value.GetRaw());
+            }
+          } else if (wpi::starts_with(entry->info.name, "$clientsub$")) {
+            auto it = m_clients.find(wpi::drop_front(entry->info.name, 11));
+            if (it != m_clients.end()) {
+              it->second.UpdateSubscribers(entry->value.GetRaw());
+            }
           }
         }
       }

glass/src/libnt/native/cpp/NetworkTablesProvider.cpp

@@ -23,13 +23,10 @@ NetworkTablesProvider::NetworkTablesProvider(Storage& storage,
                                              nt::NetworkTableInstance inst)
     : Provider{storage.GetChild("windows")},
       m_inst{inst},
-      m_topicPoller{inst},
-      m_valuePoller{inst},
+      m_poller{inst},
       m_typeCache{storage.GetChild("types")} {
   storage.SetCustomApply([this] {
-    m_topicListener = m_topicPoller.Add({{""}}, NT_TOPIC_NOTIFY_PUBLISH |
-                                                    NT_TOPIC_NOTIFY_UNPUBLISH |
-                                                    NT_TOPIC_NOTIFY_IMMEDIATE);
+    m_listener = m_poller.AddListener({{""}}, nt::EventFlags::kTopic);
     for (auto&& childIt : m_storage.GetChildren()) {
       auto id = childIt.key();
       auto typePtr = m_typeCache.FindValue(id);
@@ -51,8 +48,8 @@ NetworkTablesProvider::NetworkTablesProvider(Storage& storage,
     }
   });
   storage.SetCustomClear([this, &storage] {
-    m_topicPoller.Remove(m_topicListener);
-    m_topicListener = 0;
+    m_poller.RemoveListener(m_listener);
+    m_listener = 0;
     for (auto&& modelEntry : m_modelEntries) {
       modelEntry->model.reset();
     }
@@ -102,59 +99,60 @@ void NetworkTablesProvider::DisplayMenu() {
 void NetworkTablesProvider::Update() {
   Provider::Update();
 
-  // add/remove entries from NT changes
-  for (auto&& event : m_topicPoller.ReadQueue()) {
-    // look for .type fields
-    if (!wpi::ends_with(event.info.name, "/.type") ||
-        event.info.type != NT_STRING || event.info.type_str != "string") {
-      continue;
-    }
-
-    if (event.flags & NT_TOPIC_NOTIFY_UNPUBLISH) {
-      auto it = m_topicMap.find(event.info.topic);
-      if (it != m_topicMap.end()) {
-        m_valuePoller.Remove(it->second.listener);
-        m_topicMap.erase(it);
+  for (auto&& event : m_poller.ReadQueue()) {
+    if (auto info = event.GetTopicInfo()) {
+      // add/remove entries from NT changes
+      // look for .type fields
+      if (!wpi::ends_with(info->name, "/.type") || info->type != NT_STRING ||
+          info->type_str != "string") {
+        continue;
       }
 
-      auto it2 = std::find_if(
-          m_viewEntries.begin(), m_viewEntries.end(), [&](const auto& elem) {
-            return static_cast<Entry*>(elem->modelEntry)
-                       ->typeTopic.GetHandle() == event.info.topic;
-          });
-      if (it2 != m_viewEntries.end()) {
-        m_viewEntries.erase(it2);
+      if (event.flags & nt::EventFlags::kUnpublish) {
+        auto it = m_topicMap.find(info->topic);
+        if (it != m_topicMap.end()) {
+          m_poller.RemoveListener(it->second.listener);
+          m_topicMap.erase(it);
+        }
+
+        auto it2 = std::find_if(
+            m_viewEntries.begin(), m_viewEntries.end(), [&](const auto& elem) {
+              return static_cast<Entry*>(elem->modelEntry)
+                         ->typeTopic.GetHandle() == info->topic;
+            });
+        if (it2 != m_viewEntries.end()) {
+          m_viewEntries.erase(it2);
+        }
+      } else if (event.flags & nt::EventFlags::kPublish) {
+        // subscribe to it; use a subscriber so we only get string values
+        SubListener sublistener;
+        sublistener.subscriber = nt::StringTopic{info->topic}.Subscribe("");
+        sublistener.listener = m_poller.AddListener(
+            sublistener.subscriber,
+            nt::EventFlags::kValueAll | nt::EventFlags::kImmediate);
+        m_topicMap.try_emplace(info->topic, std::move(sublistener));
       }
-    } else if (event.flags & NT_TOPIC_NOTIFY_PUBLISH) {
-      // subscribe to it
-      SubListener sublistener;
-      sublistener.subscriber = nt::StringTopic{event.info.topic}.Subscribe("");
-      sublistener.listener =
-          m_valuePoller.Add(sublistener.subscriber,
-                            NT_VALUE_NOTIFY_LOCAL | NT_VALUE_NOTIFY_IMMEDIATE);
-      m_topicMap.try_emplace(event.info.topic, std::move(sublistener));
+    } else if (auto valueData = event.GetValueEventData()) {
+      // handle actual .type strings
+      if (!valueData->value.IsString()) {
+        continue;
+      }
+
+      // only handle ones where we have a builder
+      auto builderIt = m_typeMap.find(valueData->value.GetString());
+      if (builderIt == m_typeMap.end()) {
+        continue;
+      }
+
+      auto topicName = nt::GetTopicName(valueData->topic);
+      auto tableName = wpi::drop_back(topicName, 6);
+
+      GetOrCreateView(builderIt->second, nt::Topic{valueData->topic},
+                      tableName);
+      // cache the type
+      m_typeCache.SetString(tableName, valueData->value.GetString());
     }
   }
-
-  // handle actual .type strings
-  for (auto&& event : m_valuePoller.ReadQueue()) {
-    if (!event.value.IsString()) {
-      continue;
-    }
-
-    // only handle ones where we have a builder
-    auto builderIt = m_typeMap.find(event.value.GetString());
-    if (builderIt == m_typeMap.end()) {
-      continue;
-    }
-
-    auto topicName = nt::GetTopicName(event.topic);
-    auto tableName = wpi::drop_back(topicName, 6);
-
-    GetOrCreateView(builderIt->second, nt::Topic{event.topic}, tableName);
-    // cache the type
-    m_typeCache.SetString(tableName, event.value.GetString());
-  }
 }
 
 void NetworkTablesProvider::Register(std::string_view typeName,