apache · pnoltes · Apr 16, 2026 · Mar 31, 2026 · Mar 31, 2026 · Apr 1, 2026
diff --git a/CHANGES.md b/CHANGES.md
@@ -85,10 +85,12 @@ limitations under the License.
   The old manifest attribute names are also no longer defined in `celix_constants.h`.
 - Using jar to packaging bundles is no longer support. Jar was used to ensure the MANIFEST.MF was the first
   entry in a bundle zip file, but MANIFEST.MF is no longer used (replaced by MANIFEST.json).
+- It is no longer to set required or optional dependencies via `celix_dmServiceDependency_setRequired` or `setRequired`. This is now possible by using the new `celix_dmServiceDependency_setMinimalCardinality` or `setMinimalCardinality` function.
 
 ## New Features
 
 - Type support for value in celix Properties, including support for arrays.
+- Support for minimal cardinality of service dependencies. Setting a minimal cardinality will determine the amount of services that are required before a service dependency is available. 
 
 # Noteworthy Changes for 2.4.0 (2023-09-27)
 

diff --git a/bundles/components_ready_check/gtest/src/InactiveComponentBundle.cc b/bundles/components_ready_check/gtest/src/InactiveComponentBundle.cc
@@ -34,7 +34,7 @@ class InactiveComponentBundleActivator {
         auto& cmp = ctx->getDependencyManager()->createComponent<CondComponent>();
         cmp.createServiceDependency<celix_condition>(CELIX_CONDITION_SERVICE_NAME)
                 .setFilter("(condition.id=does-not-exists)")
-                .setRequired(true);
+                .setMinimalCardinality(1);
         cmp.build();
     }
 

diff --git a/bundles/cxx_remote_services/admin/src/RemoteServiceAdminActivator.cc b/bundles/cxx_remote_services/admin/src/RemoteServiceAdminActivator.cc
@@ -32,15 +32,12 @@ class AdminActivator {
 
         auto& cmp = ctx->getDependencyManager()->createComponent(admin);
         cmp.createServiceDependency<celix::rsa::EndpointDescription>()
-                .setRequired(false)
                 .setStrategy(celix::dm::DependencyUpdateStrategy::locking)
                 .setCallbacks(&celix::rsa::RemoteServiceAdmin::addEndpoint, &celix::rsa::RemoteServiceAdmin::removeEndpoint);
         cmp.createServiceDependency<celix::rsa::IImportServiceFactory>()
-                .setRequired(false)
                 .setStrategy(celix::dm::DependencyUpdateStrategy::locking)
                 .setCallbacks(&celix::rsa::RemoteServiceAdmin::addImportedServiceFactory, &celix::rsa::RemoteServiceAdmin::removeImportedServiceFactory);
         cmp.createServiceDependency<celix::rsa::IExportServiceFactory>()
-                .setRequired(false)
                 .setStrategy(celix::dm::DependencyUpdateStrategy::locking)
                 .setCallbacks(&celix::rsa::RemoteServiceAdmin::addExportedServiceFactory, &celix::rsa::RemoteServiceAdmin::removeExportedServiceFactory);
         cmp.build();

diff --git a/bundles/cxx_remote_services/integration/src/CalculatorConsumer.cc b/bundles/cxx_remote_services/integration/src/CalculatorConsumer.cc
@@ -55,7 +55,7 @@ class CalculatorConsumerActivator {
     explicit CalculatorConsumerActivator(const std::shared_ptr<celix::BundleContext>& ctx) {
         auto& cmp = ctx->getDependencyManager()->createComponent(std::make_shared<CalculatorConsumer>());
         cmp.createServiceDependency<ICalculator>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setCallbacks(&CalculatorConsumer::setCalculator);
         cmp.createProvidedService<celix::IShellCommand>()
                 .addProperty(celix::IShellCommand::COMMAND_NAME, "calc");

diff --git a/bundles/cxx_remote_services/integration/src/CalculatorProvider.cc b/bundles/cxx_remote_services/integration/src/CalculatorProvider.cc
@@ -91,10 +91,10 @@ class CalculatorProviderActivator {
     explicit CalculatorProviderActivator(const std::shared_ptr<celix::BundleContext>& ctx) {
         auto& cmp = ctx->getDependencyManager()->createComponent(std::make_shared<CalculatorImpl>());
         cmp.createServiceDependency<celix::PromiseFactory>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setCallbacks(&CalculatorImpl::setFactory);
         cmp.createServiceDependency<celix::PushStreamProvider>()
-            .setRequired(true)
+            .setMinimalCardinality(1)
             .setCallbacks(&CalculatorImpl::setPushStreamProvider);
         cmp.createProvidedService<ICalculator>()
                 .addProperty("service.exported.interfaces", celix::typeName<ICalculator>())

diff --git a/bundles/cxx_remote_services/integration/src/TestExportImportRemoteServiceFactory.cc b/bundles/cxx_remote_services/integration/src/TestExportImportRemoteServiceFactory.cc
@@ -340,11 +340,11 @@ class CalculatorImportServiceFactory final : public celix::rsa::IImportServiceFa
 
         auto& cmp = ctx->getDependencyManager()->createComponent(std::make_unique<ImportedCalculator>(logHelper, c2pChannelId, p2cChannelId));
         cmp.createServiceDependency<celix::PromiseFactory>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setStrategy(DependencyUpdateStrategy::suspend)
                 .setCallbacks(&ImportedCalculator::setPromiseFactory);
         cmp.createServiceDependency<celix::PushStreamProvider>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setStrategy(DependencyUpdateStrategy::suspend)
                 .setCallbacks(&ImportedCalculator::setPushStreamProvider);
 
@@ -560,12 +560,12 @@ class CalculatorExportServiceFactory final : public celix::rsa::IExportServiceFa
             std::make_unique<ExportedCalculator>(logHelper, c2pChannelId, p2cChannelId));
 
         cmp.createServiceDependency<celix::PromiseFactory>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setStrategy(DependencyUpdateStrategy::suspend)
                 .setCallbacks(&ExportedCalculator::setPromiseFactory);
 
         cmp.createServiceDependency<ICalculator>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setStrategy(DependencyUpdateStrategy::suspend)
                 .setFilter(std::string{"("}.append(celix::SERVICE_ID).append("=").append(svcId).append(")"))
                 .setCallbacks(&ExportedCalculator::setICalculator);

diff --git a/bundles/event_admin/event_admin/src/celix_event_admin_activator.c b/bundles/event_admin/event_admin/src/celix_event_admin_activator.c
@@ -122,7 +122,7 @@ celix_status_t celix_eventAdminActivator_start(celix_event_admin_activator_t *ac
         if (status != CELIX_SUCCESS) {
             return status;
         }
-        celix_dmServiceDependency_setRequired(eventAdminDep, true);
+        celix_dmServiceDependency_setMinimalCardinality(eventAdminDep, 1);
         celix_dmServiceDependency_setStrategy(eventAdminDep, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
         celix_dm_service_dependency_callback_options_t opts2 = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS;
         opts2.set = celix_eventAdapter_setEventAdminService;

diff --git a/bundles/remote_services/remote_service_admin_shm_v2/rsa_shm/src/rsa_shm_activator.c b/bundles/remote_services/remote_service_admin_shm_v2/rsa_shm/src/rsa_shm_activator.c
@@ -46,7 +46,7 @@ celix_status_t celix_rsaShmActivator_addRpcFactorySvcDependency(celix_dm_compone
     if (status != CELIX_SUCCESS) {
         return status;
     }
-    celix_dmServiceDependency_setRequired(rpcFactoryDep, true);
+    celix_dmServiceDependency_setMinimalCardinality(rpcFactoryDep, 1);
     celix_dmServiceDependency_setStrategy(rpcFactoryDep, DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND);
     celix_dm_service_dependency_callback_options_t opts = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS;
     opts.addWithProps = celix_rsaShm_addRpcFactorySvc;

diff --git a/documents/components.md b/documents/components.md
@@ -476,14 +476,16 @@ Remarks for the C example:
 5. Configures for which service name the service dependency will track services for. Optionally it is also possible
    to fine tune the tracked service by providing a service version range and/or service filter.
 6. Configures the update strategy for the service dependency to suspend-strategy.
-7. Configures the service dependency as a required service dependency.
+7. Configures the service dependency as a required service dependency by setting the minimalCardinality to at least `1`.
+   Setting the minimalCardinality determines how many services are required for the service dependency to be available.
 8. Creates an empty service dependency callback options struct. This struct can be used to configure different
    service dependency callbacks.
 9. Configures the `set` service dependency callback to `componentWithServiceDependency_setHighestRankingShellCommand`
 10. Configures the dependency manager to use the callbacks configures in opts.
 11. Adds the DM service dependency object to the DM component object.
 12. Configures the update strategy for the service dependency to locking-strategy.
-13. Configures the service dependency as an optional service dependency.
+13. Configures the service dependency as an optional service dependency by setting the minimalCardinality to `0`. By
+    default, minimalCardinality is set to `0`.
 14. Configures the `addWithProps` service dependency callback to `componentWithServiceDependency_addShellCommand`.
 
 ```C
@@ -564,7 +566,7 @@ static celix_status_t componentWithServiceDependencyActivator_start(component_wi
     celix_dm_service_dependency_t* dep1 = celix_dmServiceDependency_create(); // <-----------------------------------<4>
     celix_dmServiceDependency_setService(dep1, CELIX_SHELL_COMMAND_SERVICE_NAME, NULL, NULL); // <-------------------<5>
     celix_dmServiceDependency_setStrategy(dep1, DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND); // <------------------------<6>
-    celix_dmServiceDependency_setRequired(dep1, true); // <----------------------------------------------------------<7>
+    celix_dmServiceDependency_setMinimalCardinality(dep1, 1); // <---------------------------------------------------<7>
     celix_dm_service_dependency_callback_options_t opts1 = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS; // <--<8>
     opts1.set = (void*)componentWithServiceDependency_setHighestRankingShellCommand; // <----------------------------<9>
     celix_dmServiceDependency_setCallbacksWithOptions(dep1, &opts1); // <-------------------------------------------<10>
@@ -574,7 +576,7 @@ static celix_status_t componentWithServiceDependencyActivator_start(component_wi
     celix_dm_service_dependency_t* dep2 = celix_dmServiceDependency_create();
     celix_dmServiceDependency_setService(dep2, CELIX_SHELL_COMMAND_SERVICE_NAME, NULL, NULL);
     celix_dmServiceDependency_setStrategy(dep2, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);  // <----------------------<12>
-    celix_dmServiceDependency_setRequired(dep2, false); // <--------------------------------------------------------<13>
+    celix_dmServiceDependency_setMinimalCardinality(dep2, 0); // <--------------------------------------------------<13>
     celix_dm_service_dependency_callback_options_t opts2 = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS;
     opts2.addWithProps = (void*)componentWithServiceDependency_addShellCommand;  // <-------------------------------<14>
     opts2.removeWithProps = (void*)componentWithServiceDependency_removeShellCommand;
@@ -622,7 +624,8 @@ Remarks for the C++ example:
    service dependency, component or DM is build. Note that the `celix::dm::Component::createServiceDependency` method
    is called without provided a service name, the service name will be inferred using the `celix::typeName`.
 5. Configures the service dependency set callback.
-6. Configures the service dependency as a required service dependency.
+6. Configures the service dependency as a required service dependency by setting the minimalCardinality to at least `1`.
+   Setting the minimalCardinality determines how many services are required for the service dependency to be available.
 7. Configures the update strategy for the service dependency to suspend-strategy.
 8. Creates another new DM service dependency object and in this case also explicitly provides the service name
    to use (`CELIX_SHELL_COMMAND_SERVICE_NAME`).
@@ -672,12 +675,12 @@ public:
 
         cmp.createServiceDependency<celix::IShellCommand>() // <-----------------------------------------------------<4>
                 .setCallbacks(&Cmp::setHighestRankingShellCommand) // <----------------------------------------------<5>
-                .setRequired(true) // <------------------------------------------------------------------------------<6>
+                .setMinimalCardinality(1) // <-----------------------------------------------------------------------<6>
                 .setStrategy(DependencyUpdateStrategy::suspend); // <------------------------------------------------<7>
 
         cmp.createServiceDependency<celix_shell_command_t>(CELIX_SHELL_COMMAND_SERVICE_NAME) // <--------------------<8>
                 .setCallbacks(&Cmp::addCShellCmd, &Cmp::removeCShellCmd) 
-                .setRequired(false)
+                .setMinimalCardinality(0)
                 .setStrategy(DependencyUpdateStrategy::locking);
 
         cmp.build(); // <--------------------------------------------------------------------------------------------<9>

diff --git a/examples/celix-examples/dependency_manager_example_cxx/baz/src/BazActivator.cc b/examples/celix-examples/dependency_manager_example_cxx/baz/src/BazActivator.cc
@@ -28,13 +28,12 @@ class BazActivator {
                 .setCallbacks(nullptr, &Baz::start, &Baz::stop, nullptr);
 
         cmp.createServiceDependency<IAnotherExample>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setStrategy(DependencyUpdateStrategy::locking)
                 .setVersionRange(IANOTHER_EXAMPLE_CONSUMER_RANGE)
                 .setCallbacks(&Baz::addAnotherExample, &Baz::removeAnotherExample);
 
         cmp.createCServiceDependency<example_t>(EXAMPLE_NAME)
-                .setRequired(false)
                 .setStrategy(DependencyUpdateStrategy::locking)
                 .setVersionRange(EXAMPLE_CONSUMER_RANGE)
                 .setCallbacks(&Baz::addExample, &Baz::removeExample);

diff --git a/examples/celix-examples/dependency_manager_example_cxx/foo/src/FooActivator.cc b/examples/celix-examples/dependency_manager_example_cxx/foo/src/FooActivator.cc
@@ -29,12 +29,11 @@ class FooActivator {
                 .setCallbacks(nullptr, &Foo::start, &Foo::stop, nullptr);
 
         cmp.createServiceDependency<IAnotherExample>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setVersionRange(IANOTHER_EXAMPLE_CONSUMER_RANGE)
                 .setCallbacks(&Foo::setAnotherExample);
 
         cmp.createCServiceDependency<example_t>(EXAMPLE_NAME)
-                .setRequired(false)
                 .setVersionRange(EXAMPLE_CONSUMER_RANGE)
                 .setCallbacks(&Foo::setExample);
     }

diff --git a/examples/celix-examples/dm_example/phase2a/src/phase2a_activator.c b/examples/celix-examples/dm_example/phase2a/src/phase2a_activator.c
@@ -56,7 +56,7 @@ static celix_status_t activator_start(struct phase2a_activator_struct *act, celi
         celix_dmServiceDependency_setService(dep, PHASE1_NAME, PHASE1_RANGE_ALL, NULL);
         celix_dmServiceDependency_setCallback(dep, (void*)phase2a_setPhase1);
         celix_dmServiceDependency_setStrategy(dep, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
-        celix_dmServiceDependency_setRequired(dep, true);
+        celix_dmServiceDependency_setMinimalCardinality(dep, 1);
         celix_dmComponent_addServiceDependency(cmp, dep);
 
         celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);

diff --git a/examples/celix-examples/dm_example/phase2b/src/phase2b_activator.c b/examples/celix-examples/dm_example/phase2b/src/phase2b_activator.c
@@ -56,7 +56,7 @@ static celix_status_t activator_start(struct phase2b_activator_struct *act, celi
         celix_dm_service_dependency_t *dep = celix_dmServiceDependency_create();
         celix_dmServiceDependency_setService(dep, PHASE1_NAME, PHASE1_RANGE_EXACT, NULL);
         celix_dmServiceDependency_setCallback(dep, (void*)phase2b_setPhase1);
-        celix_dmServiceDependency_setRequired(dep, true);
+        celix_dmServiceDependency_setMinimalCardinality(dep, 1);
         celix_dmServiceDependency_setStrategy(dep, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
         celix_dmComponent_addServiceDependency(cmp, dep);
 

diff --git a/examples/celix-examples/dm_example/phase3/src/phase3_activator.c b/examples/celix-examples/dm_example/phase3/src/phase3_activator.c
@@ -47,7 +47,7 @@ static celix_status_t activator_start(struct phase3_activator_struct *act, celix
         opts.add = (void*)phase3_addPhase2;
         opts.remove = (void*)phase3_removePhase2;
         celix_dmServiceDependency_setCallbacksWithOptions(dep, &opts);
-        celix_dmServiceDependency_setRequired(dep, true);
+        celix_dmServiceDependency_setMinimalCardinality(dep, 1);
         celix_dmComponent_addServiceDependency(cmp, dep);
 
         celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx);

diff --git a/examples/celix-examples/dm_example_cxx/phase2/src/Phase2aActivator.cc b/examples/celix-examples/dm_example_cxx/phase2/src/Phase2aActivator.cc
@@ -36,15 +36,14 @@ class Phase2aActivator {
                 .addInterface<IPhase2>(IPHASE2_VERSION, props);
 
         cmp.createServiceDependency<IPhase1>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setCallbacks(&Phase2Cmp::setPhase1);
 
         cmp.createServiceDependency<srv::info::IName>()
                 .setVersionRange("[1.0.0,2)")
                 .setCallbacks(&Phase2Cmp::setName);
 
         cmp.createCServiceDependency<celix_log_service_t>(CELIX_LOG_SERVICE_NAME)
-                .setRequired(false)
                 .setCallbacks(&Phase2Cmp::setLogService);
     }
 };

diff --git a/examples/celix-examples/dm_example_cxx/phase2/src/Phase2bActivator.cc b/examples/celix-examples/dm_example_cxx/phase2/src/Phase2bActivator.cc
@@ -32,11 +32,10 @@ class Phase2bActivator {
                 .addInterface<IPhase2>(IPHASE2_VERSION, props);
 
         cmp.createServiceDependency<IPhase1>()
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setCallbacks(&Phase2Cmp::setPhase1);
 
         cmp.createCServiceDependency<celix_log_service_t>(CELIX_LOG_SERVICE_NAME)
-                .setRequired(false)
                 .setCallbacks(&Phase2Cmp::setLogService);
     }
 };

diff --git a/examples/celix-examples/dm_example_cxx/phase3/src/Phase3Activator.cc b/examples/celix-examples/dm_example_cxx/phase3/src/Phase3Activator.cc
@@ -26,7 +26,6 @@ using namespace celix::dm;
 
 Phase3Activator::Phase3Activator(std::shared_ptr<DependencyManager> mng) : Phase3BaseActivator{mng} {
     cmp.createServiceDependency<IPhase2>()
-             .setRequired(false)
              .setFilter("(&(name=phase2a)(non-existing=*))")
              .setCallbacks(&Phase3Cmp::setPhase2a);
 }

diff --git a/examples/celix-examples/dm_example_cxx/phase3/src/Phase3BaseActivator.cc b/examples/celix-examples/dm_example_cxx/phase3/src/Phase3BaseActivator.cc
@@ -26,6 +26,6 @@ Phase3BaseActivator::Phase3BaseActivator(std::shared_ptr<DependencyManager> mng)
     cmp.setCallbacks(nullptr, &Phase3Cmp::start, &Phase3Cmp::stop, nullptr);
 
     cmp.createServiceDependency<IPhase2>()
-            .setRequired(true)
+            .setMinimalCardinality(1)
             .setCallbacks(&Phase3Cmp::addPhase2, &Phase3Cmp::removePhase2);
 }
diff --git a/examples/celix-examples/readme_c_examples/src/component_with_service_dependency_activator.c b/examples/celix-examples/readme_c_examples/src/component_with_service_dependency_activator.c
@@ -94,7 +94,7 @@ static celix_status_t componentWithServiceDependencyActivator_start(component_wi
     celix_dm_service_dependency_t* dep1 = celix_dmServiceDependency_create(); // <-----------------------------------<4>
     celix_dmServiceDependency_setService(dep1, CELIX_SHELL_COMMAND_SERVICE_NAME, NULL, NULL); // <-------------------<5>
     celix_dmServiceDependency_setStrategy(dep1, DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND); // <------------------------<6>
-    celix_dmServiceDependency_setRequired(dep1, true); // <----------------------------------------------------------<7>
+    celix_dmServiceDependency_setMinimalCardinality(dep1, 1); // <----------------------------------------------------------<7>
     celix_dm_service_dependency_callback_options_t opts1 = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS; // <--<8>
     opts1.set = (void*)componentWithServiceDependency_setHighestRankingShellCommand; // <----------------------------<9>
     celix_dmServiceDependency_setCallbacksWithOptions(dep1, &opts1); // <-------------------------------------------<10>
@@ -104,7 +104,7 @@ static celix_status_t componentWithServiceDependencyActivator_start(component_wi
     celix_dm_service_dependency_t* dep2 = celix_dmServiceDependency_create();
     celix_dmServiceDependency_setService(dep2, CELIX_SHELL_COMMAND_SERVICE_NAME, NULL, NULL);
     celix_dmServiceDependency_setStrategy(dep2, DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);  // <----------------------<12>
-    celix_dmServiceDependency_setRequired(dep2, false); // <--------------------------------------------------------<13>
+    celix_dmServiceDependency_setMinimalCardinality(dep2, 0); // <--------------------------------------------------------<13>
     celix_dm_service_dependency_callback_options_t opts2 = CELIX_EMPTY_DM_SERVICE_DEPENDENCY_CALLBACK_OPTIONS;
     opts2.addWithProps = (void*)componentWithServiceDependency_addShellCommand;  // <-------------------------------<14>
     opts2.removeWithProps = (void*)componentWithServiceDependency_removeShellCommand;

diff --git a/examples/celix-examples/readme_cxx_examples/src/ComponentWithServiceDependencyActivator.cc b/examples/celix-examples/readme_cxx_examples/src/ComponentWithServiceDependencyActivator.cc
@@ -60,12 +60,11 @@ class ComponentWithServiceDependencyActivator {
 
         cmp.createServiceDependency<celix::IShellCommand>()
                 .setCallbacks(&Cmp::setHighestRankingShellCommand)
-                .setRequired(true)
+                .setMinimalCardinality(1)
                 .setStrategy(DependencyUpdateStrategy::suspend);
 
         cmp.createServiceDependency<celix_shell_command_t>(CELIX_SHELL_COMMAND_SERVICE_NAME)
                 .setCallbacks(&Cmp::addCShellCmd, &Cmp::removeCShellCmd)
-                .setRequired(false)
                 .setStrategy(DependencyUpdateStrategy::locking);
 
         cmp.build(); // <--------------------------------------------------------------------------------------------<8>