rename cib::conditional to cib::constexpr_condition

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/constexpr_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

test/cib/nexus.cpp

@@ -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;