From 59f54d012c71e782966e9d083f1ee9459fd3fd70 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Sun, 26 Jul 2026 02:27:59 +0200
Subject: chore: replace "interface" with "facet"

---
 kernel/kapi/devices/driver.tests.cpp | 78 ++++++++++++++++++++++--------------
 1 file changed, 49 insertions(+), 29 deletions(-)

(limited to 'kernel/kapi/devices/driver.tests.cpp')

diff --git a/kernel/kapi/devices/driver.tests.cpp b/kernel/kapi/devices/driver.tests.cpp
index e65e48e0..560cc1bc 100644
--- a/kernel/kapi/devices/driver.tests.cpp
+++ b/kernel/kapi/devices/driver.tests.cpp
@@ -16,39 +16,49 @@ namespace
 {
   struct controller_identification
   {
-    constexpr auto static id = kapi::devices::interface_id{"stacking_test_controller_identification"};
+    constexpr auto static id = kapi::capabilities::facet_id{"stacking_test_controller_identification"};
     virtual ~controller_identification() = default;
     [[nodiscard]] virtual auto controller_name() const -> std::string_view = 0;
   };
 
   struct controller_driver_identification
   {
-    constexpr auto static id = kapi::devices::interface_id{"stacking_test_controller_driver_identification"};
+    constexpr auto static id = kapi::capabilities::facet_id{"stacking_test_controller_driver_identification"};
     virtual ~controller_driver_identification() = default;
     [[nodiscard]] virtual auto supported_names() const -> std::span<std::string_view const> = 0;
   };
 
-  struct controller_bus final : kapi::devices::bus, kapi::devices::bus_protocol
+  struct controller_protocol : kapi::devices::bus_protocol
   {
-    using kapi::devices::bus::bus;
+    constexpr auto static id = kapi::capabilities::facet_id{"stacking_test_controller_protocol"};
 
     auto enumerate(kapi::devices::bus &) -> void override {}
 
     [[nodiscard]] auto match(kapi::devices::device const & dev, kapi::devices::driver const & drv) const
         -> kstd::result<std::uint32_t> override
     {
-      auto const * ident = dev.as<controller_identification>();
-      auto const * claims = drv.as<controller_driver_identification>();
+      auto const * ident = dev.facet<controller_identification>();
+      auto const * claims = drv.facet<controller_driver_identification>();
       if (!ident || !claims || !std::ranges::contains(claims->supported_names(), ident->controller_name()))
       {
         return kstd::failure(kapi::devices::driver_match_errc::no_match);
       }
       return 0u;
     }
+  } constinit controller_protocol_instance{};
+
+  struct controller_bus final : kapi::devices::bus
+  {
+    using kapi::devices::bus::bus;
 
-    [[nodiscard]] auto protocol() -> kapi::devices::bus_protocol * override
+    [[nodiscard]] auto query_facet(kapi::capabilities::facet_id id) -> void * override
     {
-      return this;
+      if (id == controller_protocol::id || id == kapi::devices::bus_protocol::id)
+      {
+        return &controller_protocol_instance;
+      }
+
+      return kapi::devices::bus::query_facet(id);
     }
   };
 
@@ -64,26 +74,26 @@ namespace
     }
 
   protected:
-    auto query_interface(kapi::devices::interface_id interface) -> void * override
+    auto query_facet(kapi::capabilities::facet_id facet) -> void * override
     {
-      if (interface == controller_identification::id)
+      if (facet == controller_identification::id)
       {
         return static_cast<controller_identification *>(this);
       }
-      return kapi::devices::bus::query_interface(interface);
+      return kapi::devices::bus::query_facet(facet);
     }
   };
 
   struct leaf_identification
   {
-    constexpr auto static id = kapi::devices::interface_id{"stacking_test_leaf_identification"};
+    constexpr auto static id = kapi::capabilities::facet_id{"stacking_test_leaf_identification"};
     virtual ~leaf_identification() = default;
     [[nodiscard]] virtual auto leaf_name() const -> std::string_view = 0;
   };
 
   struct leaf_driver_identification
   {
-    constexpr auto static id = kapi::devices::interface_id{"stacking_test_leaf_driver_identification"};
+    constexpr auto static id = kapi::capabilities::facet_id{"stacking_test_leaf_driver_identification"};
     virtual ~leaf_driver_identification() = default;
     [[nodiscard]] virtual auto supported_names() const -> std::span<std::string_view const> = 0;
   };
@@ -100,19 +110,19 @@ namespace
     }
 
   protected:
-    auto query_interface(kapi::devices::interface_id interface) -> void * override
+    auto query_facet(kapi::capabilities::facet_id facet) -> void * override
     {
-      if (interface == leaf_identification::id)
+      if (facet == leaf_identification::id)
       {
         return static_cast<leaf_identification *>(this);
       }
-      return kapi::devices::device::query_interface(interface);
+      return kapi::devices::device::query_facet(facet);
     }
   };
 
-  struct leaf_bus final : kapi::devices::bus, kapi::devices::bus_protocol
+  struct leaf_protocol final : kapi::devices::bus_protocol
   {
-    using kapi::devices::bus::bus;
+    constexpr auto static id = kapi::capabilities::facet_id{"stacking_test_leaf_protocol"};
 
     auto enumerate(kapi::devices::bus & self) -> void override
     {
@@ -122,18 +132,28 @@ namespace
     [[nodiscard]] auto match(kapi::devices::device const & dev, kapi::devices::driver const & drv) const
         -> kstd::result<std::uint32_t> override
     {
-      auto const * ident = dev.as<leaf_identification>();
-      auto const * claims = drv.as<leaf_driver_identification>();
+      auto const * ident = dev.facet<leaf_identification>();
+      auto const * claims = drv.facet<leaf_driver_identification>();
       if (!ident || !claims || !std::ranges::contains(claims->supported_names(), ident->leaf_name()))
       {
         return kstd::failure(kapi::devices::driver_match_errc::no_match);
       }
       return 0u;
     }
+  } constinit leaf_protocol_instance{};
+
+  struct leaf_bus final : kapi::devices::bus
+  {
+    using kapi::devices::bus::bus;
 
-    [[nodiscard]] auto protocol() -> kapi::devices::bus_protocol * override
+    [[nodiscard]] auto query_facet(kapi::capabilities::facet_id id) -> void * override
     {
-      return this;
+      if (id == leaf_protocol::id || id == kapi::devices::bus_protocol::id)
+      {
+        return &leaf_protocol_instance;
+      }
+
+      return kapi::devices::bus::query_facet(id);
     }
   };
 
@@ -144,7 +164,7 @@ namespace
       auto self_as_bus = kstd::static_pointer_cast<kapi::devices::bus>(dev.shared_from_this());
       auto leaf = kstd::make_shared<leaf_bus>("stacking_test_leaf_bus");
       self_as_bus->add_child(leaf);
-      leaf->enumerate(*leaf);
+      leaf->facet<leaf_protocol>()->enumerate(*leaf);
 
       return kstd::success();
     }
@@ -163,14 +183,14 @@ namespace
     }
 
   protected:
-    auto query_interface(kapi::devices::interface_id interface) -> void * override
+    auto query_facet(kapi::capabilities::facet_id facet) -> void * override
     {
-      if (interface == controller_driver_identification::id)
+      if (facet == controller_driver_identification::id)
       {
         return static_cast<controller_driver_identification *>(this);
       }
 
-      return kapi::devices::driver::query_interface(interface);
+      return kapi::devices::driver::query_facet(facet);
     }
   };
 
@@ -195,14 +215,14 @@ namespace
     }
 
   protected:
-    auto query_interface(kapi::devices::interface_id interface) -> void * override
+    auto query_facet(kapi::capabilities::facet_id facet) -> void * override
     {
-      if (interface == leaf_driver_identification::id)
+      if (facet == leaf_driver_identification::id)
       {
         return static_cast<leaf_driver_identification *>(this);
       }
 
-      return kapi::devices::driver::query_interface(interface);
+      return kapi::devices::driver::query_facet(facet);
     }
   };
 }  // namespace
-- 
cgit v1.2.3