rename cib::conditional to cib::constexpr_condition

Author: lukevalenty

CMakeLists.txt

@@ -48,7 +48,8 @@ target_sources(
               include/cib/cib.hpp
               include/cib/config.hpp
               include/cib/detail/components.hpp
-              include/cib/detail/conditional.hpp
+              include/cib/detail/constexpr_conditional.hpp
+              include/cib/detail/runtime_conditional.hpp
               include/cib/detail/config_details.hpp
               include/cib/detail/config_item.hpp
               include/cib/detail/exports.hpp

docs/flows.adoc

@@ -61,7 +61,7 @@ dependencies.
 The `*` operator is used to explicitly add an action to the
 flow. Without the `*` operator an action is just a reference.
 A compile-time error will be triggered if an action is referenced without ever
-being explicitly added to the flow. If an action is added under a compile-time
+being explicitly added to the flow. If an action is added under a constexpr
 or runtime conditional, and the conditional is false, then it is as if the
 action was never added at all.
 

include/cib/config.hpp

@@ -2,9 +2,9 @@
 
 #include <cib/builder_meta.hpp>
 #include <cib/detail/components.hpp>
-#include <cib/detail/conditional.hpp>
 #include <cib/detail/config_details.hpp>
 #include <cib/detail/config_item.hpp>
+#include <cib/detail/constexpr_conditional.hpp>
 #include <cib/detail/exports.hpp>
 #include <cib/detail/extend.hpp>
 #include <cib/detail/runtime_conditional.hpp>
@@ -22,8 +22,8 @@ namespace cib {
  * @see cib::components
  * @see cib::extend
  * @see cib::exports
- * @see cib::conditional
- * @see cib::runtime_conditional
+ * @see cib::constexpr_condition
+ * @see cib::runtime_condition
  */
 template <typename... Configs>
 [[nodiscard]] CONSTEVAL auto config(Configs const &...configs) {
@@ -61,19 +61,11 @@ template <typename Service, typename... Args>
     return detail::extend<Service, Args...>{args...};
 }
 
-/**
- * Include configs based on predicate.
- *
- * If predicate evaluates to true, then the configs will be added to the
- * configuration. Otherwise the configs contained in this conditional
- * will not be added.
- */
-template <typename Predicate, typename... Configs>
-    requires std::is_default_constructible_v<Predicate>
-[[nodiscard]] CONSTEVAL auto conditional(Predicate const &,
-                                         Configs const &...configs) {
-    return detail::conditional<Predicate, Configs...>{configs...};
-}
+template <stdx::ct_string Name>
+constexpr auto constexpr_condition = []<typename P>(P) {
+    static_assert(std::is_default_constructible_v<P>);
+    return detail::constexpr_condition<Name, P>{};
+};
 
 template <stdx::ct_string Name>
 constexpr auto runtime_condition = []<typename P>(P) {

include/cib/detail/conditional.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <cib/detail/config_details.hpp>
+#include <cib/detail/config_item.hpp>
+#include <cib/detail/extend.hpp>
+
+#include <stdx/compiler.hpp>
+#include <stdx/ct_format.hpp>
+#include <stdx/tuple.hpp>
+#include <stdx/tuple_algorithms.hpp>
+
+namespace cib::detail {
+template <typename Cond, typename... Configs>
+struct constexpr_conditional : config_item {
+    detail::config<Configs...> body;
+
+    CONSTEVAL explicit constexpr_conditional(Configs const &...configs)
+        : body{configs...} {}
+
+    [[nodiscard]] constexpr auto extends_tuple() const {
+        if constexpr (Cond{}) {
+            return body.extends_tuple();
+        } else {
+            return stdx::tuple<>{};
+        }
+    }
+
+    [[nodiscard]] constexpr auto exports_tuple() const {
+        if constexpr (Cond{}) {
+            return body.exports_tuple();
+        } else {
+            return stdx::tuple<>{};
+        }
+    }
+};
+
+template <stdx::ct_string Name, typename... Ps> struct constexpr_condition {
+    constexpr static auto predicates = stdx::make_tuple(Ps{}...);
+
+    constexpr static auto ct_name = Name;
+
+    template <typename... Configs>
+    [[nodiscard]] CONSTEVAL auto operator()(Configs const &...configs) const {
+        return detail::constexpr_conditional<constexpr_condition<Name, Ps...>,
+                                             Configs...>{configs...};
+    }
+
+    explicit constexpr operator bool() const { return (Ps{}() and ...); }
+};
+
+} // namespace cib::detail

include/cib/detail/constexpr_conditional.hpp

@@ -100,9 +100,10 @@ TEST_CASE("configuration with multiple components, services, and features") {
 }
 
 template <auto V> struct SimpleConditionalComponent {
+    constexpr static auto when_v_is_42 =
+        cib::constexpr_condition<"when_v_is_42">([]() { return V == 42; });
 
-    constexpr static auto config = cib::config(cib::conditional(
-        []() { return V == 42; },
+    constexpr static auto config = cib::config(when_v_is_42(
         cib::extend<TestCallback<0>>([]() { is_callback_invoked<0> = true; })));
 };
 
@@ -112,7 +113,7 @@ template <int ConditionalValue> struct ConditionalTestProject {
         cib::components<SimpleConditionalComponent<ConditionalValue>>);
 };
 
-TEST_CASE("configuration with one conditional component") {
+TEST_CASE("configuration with one constexpr conditional component") {
     is_callback_invoked<0> = false;
 
     SECTION("invoke with argument match") {
@@ -133,10 +134,13 @@ TEST_CASE("configuration with one conditional component") {
 }
 
 template <int EnId, int Id> struct ConditionalComponent {
-    constexpr static auto config = cib::config(cib::conditional(
-        []() { return EnId == Id; }, cib::extend<TestCallback<Id>>([]() {
-            is_callback_invoked<Id> = true;
-        })));
+    constexpr static auto when_id_matches =
+        cib::constexpr_condition<"when_id_matches">(
+            []() { return EnId == Id; });
+
+    constexpr static auto config =
+        cib::config(when_id_matches(cib::extend<TestCallback<Id>>(
+            []() { is_callback_invoked<Id> = true; })));
 };
 
 template <int EnabledId> struct ConditionalConfig {
@@ -148,7 +152,7 @@ template <int EnabledId> struct ConditionalConfig {
                         ConditionalComponent<EnabledId, 2>>);
 };
 
-TEST_CASE("configuration with conditional features") {
+TEST_CASE("configuration with constexpr conditional features") {
     is_callback_invoked<0> = false;
     is_callback_invoked<1> = false;
     is_callback_invoked<2> = false;