chore: replace "interface" with "facet"

1 files changed, 216 insertions, 0 deletions

diff --git a/kernel/kapi/devices/facet_registry.cpp b/kernel/kapi/devices/facet_registry.cpp
new file mode 100644
index 00000000..4aeebfc1
--- /dev/null
+++ b/kernel/kapi/devices/facet_registry.cpp
@@ -0,0 +1,216 @@
+#include <kapi/devices/facet_registry.hpp>
+
+#include <kapi/devices.hpp>
+#include <kapi/system.hpp>
+#include <kapi/test_support/devices.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/result.hpp>
+#include <kstd/string.hpp>
+#include <kstd/system_error.hpp>
+#include <kstd/vector.hpp>
+
+#include <algorithm>
+#include <optional>
+#include <string_view>
+#include <utility>
+
+namespace kapi::devices
+{
+
+  namespace
+  {
+    constinit auto static registry = std::optional<facet_registry>{};
+  }
+
+  auto facet_registry::init() -> void
+  {
+    if (registry.has_value())
+    {
+      system::panic("[kernel] Device facet registry has already been initialized.");
+    }
+
+    registry.emplace();
+  }
+
+  auto facet_registry::get() -> facet_registry &
+  {
+    if (!registry)
+    {
+      system::panic("[kernel] Device facet registry has not been initialized.");
+    }
+
+    return *registry;
+  }
+
+  auto facet_registry::do_publish(kstd::shared_ptr<device> device, kstd::string name, kapi::capabilities::facet_id id,
+                                  void * facet) -> kstd::result<void>
+  {
+    // TODO: lock registry
+
+    erase_if(m_entries, [id](auto e) { return e.id() == id && !e.device(); });
+
+    if (!device || !facet || name.empty())
+    {
+      return kstd::failure(make_error_code(kstd::errc::invalid_argument));
+    }
+
+    auto already_published = std::ranges::any_of(
+        m_entries, [&](auto const & entry) { return entry.id() == id && entry.device().get() == device.get(); });
+
+    if (already_published)
+    {
+      return kstd::failure(make_error_code(kstd::errc::file_exists));
+    }
+
+    auto & published = m_entries.emplace_back(device, std::move(name), id, facet);
+
+    do_notify_published(id, published);
+
+    return kstd::success();
+  }
+
+  auto facet_registry::do_notify_published(kapi::capabilities::facet_id id, entry const & published) -> void
+  {
+    std::ranges::for_each(m_observers, [&](auto observer) {
+      if (auto locked_observer = observer.lock())
+      {
+        locked_observer->on_facet_published(id, published);
+      }
+    });
+
+    std::ranges::for_each(m_static_observers, [&](auto observer) { observer->on_facet_published(id, published); });
+  }
+
+  auto facet_registry::do_notify_withdrawn(kapi::capabilities::facet_id id, device const & device) -> void
+  {
+    std::ranges::for_each(m_observers, [&](auto observer) {
+      if (auto locked_observer = observer.lock())
+      {
+        locked_observer->on_facet_withdrawn(id, const_cast<devices::device &>(device));
+      }
+    });
+
+    std::ranges::for_each(m_static_observers, [&](auto observer) {
+      observer->on_facet_withdrawn(id, const_cast<devices::device &>(device));
+    });
+  }
+
+  auto facet_registry::withdraw(device const & device, kapi::capabilities::facet_id id) -> void
+  {
+    // TODO: lock registry
+
+    auto did_remove = erase_if(m_entries, [&](auto e) {
+                        auto locked_device = e.device();
+                        return e.id() == id && locked_device && locked_device.get() == &device;
+                      }) != 0;
+
+    if (did_remove)
+    {
+      do_notify_withdrawn(id, device);
+    }
+  }
+
+  auto facet_registry::withdraw_all_for(device const & device) -> void
+  {
+    // TODO: lock registry
+
+    auto withdrawn_facets = kstd::vector<kapi::capabilities::facet_id>{};
+
+    erase_if(m_entries, [&](auto e) {
+      auto locked_device = e.device();
+      auto do_erase = locked_device && locked_device.get() == &device;
+      if (do_erase)
+      {
+        withdrawn_facets.push_back(e.id());
+      }
+      return do_erase;
+    });
+
+    std::ranges::for_each(withdrawn_facets, [&](auto facet) { do_notify_withdrawn(facet, device); });
+  }
+
+  auto facet_registry::all(kapi::capabilities::facet_id id) const -> kstd::vector<entry>
+  {
+    // TODO: lock registry
+
+    auto filtered = m_entries;
+    erase_if(filtered, [&](auto e) {
+      auto locked_device = e.device();
+      return !(e.id() == id && locked_device);
+    });
+    return filtered;
+  }
+
+  auto facet_registry::resolve(kapi::capabilities::facet_id id, std::string_view name) -> void *
+  {
+    // TODO: lock registry
+
+    auto found = std::ranges::find_if(m_entries, [&](auto e) { return e.name() == name && e.device(); });
+
+    if (found == m_entries.cend())
+    {
+      return nullptr;
+    }
+    else if (auto device = found->device())
+    {
+      return resolve(id, *device);
+    }
+
+    return nullptr;
+  }
+
+  auto facet_registry::resolve(kapi::capabilities::facet_id id, device & device) -> void *
+  {
+    // TODO: lock registry
+
+    if (auto by_device = device.facet(id))
+    {
+      return by_device;
+    }
+
+    auto found = std::ranges::find_if(m_entries, [&](auto e) {
+      auto locked_device = e.device();
+      return e.id() == id && locked_device && locked_device.get() == &device;
+    });
+
+    if (found == m_entries.cend())
+    {
+      return nullptr;
+    }
+
+    return found->untyped_facet();
+  }
+
+  auto facet_registry::subscribe(kstd::weak_ptr<facet_registry_observer> observer) -> void
+  {
+    // TODO: lock registry
+
+    erase_if(m_observers, [](auto const & observer) { return observer.expired(); });
+    m_observers.push_back(observer);
+  }
+
+  auto facet_registry::subscribe(facet_registry_observer & observer) -> void
+  {
+    // TODO: lock registry
+
+    m_static_observers.push_back(&observer);
+  }
+
+  auto facet_registry::unsubscribe(facet_registry_observer & observer) -> void
+  {
+    // TODO: lock registry
+
+    erase_if(m_observers, [&](auto const & subscribed) { return subscribed.lock().get() == &observer; });
+    erase(m_static_observers, &observer);
+  }
+
+}  // namespace kapi::devices
+
+namespace kapi::test_support::devices
+{
+  auto deinit_facet_registry() -> void
+  {
+    kapi::devices::registry.reset();
+  }
+}  // namespace kapi::test_support::devices