🎨 Decouple builder_meta

Problem:
- `cib` offers `builder_meta` as a convenient way to provide a service. But
  sometimes other libs depend on cib only to use that, when instead they could
  be providing a service easily by modelling a concept.

Solution:
- Change `builder_meta` to a concept; libraries that don't need cib otherwise
  need not use it.

Author: elbeno

docs/flows.adoc

@@ -389,7 +389,10 @@ what happens by default when we run the flow.
 template <stdx::ct_string Name = "">
 using builder = flow::graph<Name, flow::graph_builder<impl>>;
 template <stdx::ct_string Name = "">
-struct service : cib::builder_meta<builder<Name>, flow::FunctionPtr> {};
+struct service {
+  using builder_t = builder<Name>;
+  using interface_t = flow::FunctionPtr;
+};
 
 // declare a flow service
 struct MorningRoutine : public service<"MorningRoutine"> {};
@@ -411,7 +414,10 @@ But given a flow, other renderings are possible.
 template <stdx::ct_string Name = "">
 using viz_builder = flow::graph<Name, flow::graphviz_builder>;
 template <stdx::ct_string Name = "">
-struct viz_service : cib::builder_meta<builder<Name>, flow::VizFunctionPtr> {};
+struct viz_service {
+  using builder_t = builder<Name>;
+  using interface_t = flow::VizFunctionPtr;
+};
 ----
 
 Here, `viz_service` will produce a graphviz rendering of a flow using the

include/cib/builder_meta.hpp

@@ -1,32 +1,12 @@
 #pragma once
 
 namespace cib {
-/**
- * Describe a builder to cib.
- *
- * @tparam Builder
- *      The initial builder type cib should use when creating a builder.
- *      This is only the initial type, the Builder::add(...) function
- *      may return a different type and cib will track that correctly.
- *
- * @tparam Interface
- *      The type-erased interface services built with this builder
- *      will implement. For example, cib::callback allows many other
- *      callables to get executed when its service gets invoked. The
- *      type-erased interface for cib::callback is a function pointer.
- *
- * @see cib::built
- *
- * @example callback::service
- */
-template <typename Builder, typename Interface> struct builder_meta {
-    using builder_t = Builder;
-    using interface_t = Interface;
+template <typename T>
+concept builder_meta = requires {
+    typename T::builder_t;
+    typename T::interface_t;
 };
 
-template <typename BuilderMeta>
-using builder_t = typename BuilderMeta::builder_t;
-
-template <typename BuilderMeta>
-using interface_t = typename BuilderMeta::interface_t;
+template <builder_meta T> using builder_t = typename T::builder_t;
+template <builder_meta T> using interface_t = typename T::interface_t;
 } // namespace cib

include/cib/built.hpp

@@ -3,13 +3,5 @@
 #include <cib/builder_meta.hpp>
 
 namespace cib {
-/**
- * Pointer to a built service implementation.
- *
- * @tparam ServiceMeta
- *      Tag name of the service.
- *
- * @see cib::builder_meta
- */
-template <typename ServiceMeta> interface_t<ServiceMeta> service;
+template <builder_meta ServiceMeta> interface_t<ServiceMeta> service;
 } // namespace cib

include/cib/callback.hpp

@@ -105,7 +105,7 @@ template <int NumFuncs = 0, typename... ArgTypes> struct builder {
 /**
  * Extend this to create named callback services.
  *
- * Types that extend callback_meta can be used as unique names with
+ * Types that extend service can be used as unique names with
  * cib::exports and cib::extend.
  *
  * @tparam ArgTypes
@@ -116,8 +116,8 @@ template <int NumFuncs = 0, typename... ArgTypes> struct builder {
  * @see cib::exports
  * @see cib::extend
  */
-template <typename... ArgTypes>
-struct service
-    : public cib::builder_meta<builder<0, ArgTypes...>, void (*)(ArgTypes...)> {
+template <typename... ArgTypes> struct service {
+    using builder_t = builder<0, ArgTypes...>;
+    using interface_t = void (*)(ArgTypes...);
 };
 } // namespace callback

include/cib/config.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cib/builder_meta.hpp>
 #include <cib/detail/components.hpp>
 #include <cib/detail/config_details.hpp>
 #include <cib/detail/config_item.hpp>

include/flow/builder.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cib/builder_meta.hpp>
 #include <flow/common.hpp>
 #include <flow/graph_builder.hpp>
 #include <flow/impl.hpp>
@@ -11,6 +10,8 @@ namespace flow {
 template <stdx::ct_string Name = "">
 using builder = graph<Name, graph_builder<Name, impl>>;
 
-template <stdx::ct_string Name = "">
-struct service : cib::builder_meta<builder<Name>, FunctionPtr> {};
+template <stdx::ct_string Name = ""> struct service {
+    using builder_t = builder<Name>;
+    using interface_t = FunctionPtr;
+};
 } // namespace flow

include/msg/indexed_service.hpp

@@ -1,16 +1,16 @@
 #pragma once
 
-#include <cib/builder_meta.hpp>
 #include <msg/handler_interface.hpp>
 #include <msg/indexed_builder.hpp>
 
 #include <stdx/tuple.hpp>
 
 namespace msg {
 template <typename IndexSpec, typename MsgBase, typename... ExtraCallbackArgs>
-struct indexed_service
-    : cib::builder_meta<
-          indexed_builder<IndexSpec, stdx::tuple<>, MsgBase,
-                          ExtraCallbackArgs...>,
-          handler_interface<MsgBase, ExtraCallbackArgs...> const *> {};
+struct indexed_service {
+    using builder_t = indexed_builder<IndexSpec, stdx::tuple<>, MsgBase,
+                                      ExtraCallbackArgs...>;
+    using interface_t =
+        handler_interface<MsgBase, ExtraCallbackArgs...> const *;
+};
 } // namespace msg

include/msg/service.hpp

@@ -1,15 +1,15 @@
 #pragma once
 
-#include <cib/builder_meta.hpp>
 #include <msg/handler_builder.hpp>
 #include <msg/handler_interface.hpp>
 
 #include <stdx/tuple.hpp>
 
 namespace msg {
-template <typename MsgBase, typename... ExtraCallbackArgs>
-struct service
-    : cib::builder_meta<
-          handler_builder<stdx::tuple<>, MsgBase, ExtraCallbackArgs...>,
-          handler_interface<MsgBase, ExtraCallbackArgs...> const *> {};
+template <typename MsgBase, typename... ExtraCallbackArgs> struct service {
+    using builder_t =
+        handler_builder<stdx::tuple<>, MsgBase, ExtraCallbackArgs...>;
+    using interface_t =
+        handler_interface<MsgBase, ExtraCallbackArgs...> const *;
+};
 } // namespace msg

include/seq/builder.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cib/builder_meta.hpp>
 #include <flow/common.hpp>
 #include <flow/graph_builder.hpp>
 #include <seq/impl.hpp>
@@ -11,6 +10,8 @@ namespace seq {
 template <stdx::ct_string Name = "">
 using builder = flow::graph<Name, flow::graph_builder<Name, impl>>;
 
-template <stdx::ct_string Name = "">
-struct service : cib::builder_meta<builder<Name>, flow::FunctionPtr> {};
+template <stdx::ct_string Name = ""> struct service {
+    using builder_t = builder<Name>;
+    using interface_t = flow::FunctionPtr;
+};
 } // namespace seq

test/cib/builder_meta.cpp

@@ -8,13 +8,20 @@ namespace {
 struct TestBuilderTag;
 struct TestInterfaceTag;
 
-struct test_builder_meta
-    : public cib::builder_meta<TestBuilderTag, TestInterfaceTag> {};
+struct test_builder_meta {
+    using builder_t = TestBuilderTag;
+    using interface_t = TestInterfaceTag;
+};
 } // namespace
 
+TEST_CASE("builder_meta concept") {
+    static_assert(cib::builder_meta<test_builder_meta>);
+}
+
 TEST_CASE(
     "builder_meta builder and interface type traits return correct values") {
-    REQUIRE(std::is_same_v<TestBuilderTag, cib::builder_t<test_builder_meta>>);
-    REQUIRE(
+    static_assert(
+        std::is_same_v<TestBuilderTag, cib::builder_t<test_builder_meta>>);
+    static_assert(
         std::is_same_v<TestInterfaceTag, cib::interface_t<test_builder_meta>>);
 }