feat: add support for conditional dependencies

cpp/include/resolvo.h

@@ -4,6 +4,7 @@
 #include "resolvo_internal.h"
 
 namespace resolvo {
+using cbindgen_private::ConditionalRequirement;
 using cbindgen_private::Problem;
 using cbindgen_private::Requirement;
 
@@ -24,6 +25,23 @@ inline Requirement requirement_union(VersionSetUnionId id) {
     return cbindgen_private::resolvo_requirement_union(id);
 }
 
+/**
+ * Specifies a conditional requirement (dependency) of a single version set.
+ * A solvable belonging to the version set satisfies the requirement if the condition is true.
+ */
+inline ConditionalRequirement conditional_requirement_single(VersionSetId id) {
+    return cbindgen_private::resolvo_conditional_requirement_single(id);
+}
+
+/**
+ * Specifies a conditional requirement (dependency) of the union (logical OR) of multiple version
+ * sets. A solvable belonging to any of the version sets contained in the union satisfies the
+ * requirement if the condition is true.
+ */
+inline ConditionalRequirement conditional_requirement_union(VersionSetUnionId id) {
+    return cbindgen_private::resolvo_conditional_requirement_union(id);
+}
+
 /**
  * Called to solve a package problem.
  *

cpp/src/lib.rs

@@ -31,6 +31,95 @@ impl From<SolvableId> for resolvo::SolvableId {
     }
 }
 
+/// A wrapper around an optional version set id.
+/// cbindgen:derive-eq
+/// cbindgen:derive-neq
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct FfiOptionVersionSetId {
+    pub is_some: bool,
+    pub value: VersionSetId,
+}
+
+impl From<Option<resolvo::VersionSetId>> for FfiOptionVersionSetId {
+    fn from(opt: Option<resolvo::VersionSetId>) -> Self {
+        match opt {
+            Some(v) => Self {
+                is_some: true,
+                value: v.into(),
+            },
+            None => Self {
+                is_some: false,
+                value: VersionSetId { id: 0 },
+            },
+        }
+    }
+}
+
+impl From<FfiOptionVersionSetId> for Option<resolvo::VersionSetId> {
+    fn from(ffi: FfiOptionVersionSetId) -> Self {
+        if ffi.is_some {
+            Some(ffi.value.into())
+        } else {
+            None
+        }
+    }
+}
+
+impl From<Option<VersionSetId>> for FfiOptionVersionSetId {
+    fn from(opt: Option<VersionSetId>) -> Self {
+        match opt {
+            Some(v) => Self {
+                is_some: true,
+                value: v,
+            },
+            None => Self {
+                is_some: false,
+                value: VersionSetId { id: 0 },
+            },
+        }
+    }
+}
+
+impl From<FfiOptionVersionSetId> for Option<VersionSetId> {
+    fn from(ffi: FfiOptionVersionSetId) -> Self {
+        if ffi.is_some {
+            Some(ffi.value)
+        } else {
+            None
+        }
+    }
+}
+
+/// Specifies a conditional requirement, where the requirement is only active when the condition is met.
+/// First VersionSetId is the condition, second is the requirement.
+/// cbindgen:derive-eq
+/// cbindgen:derive-neq
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ConditionalRequirement {
+    pub condition: FfiOptionVersionSetId,
+    pub requirement: Requirement,
+}
+
+impl From<resolvo::ConditionalRequirement> for ConditionalRequirement {
+    fn from(value: resolvo::ConditionalRequirement) -> Self {
+        Self {
+            condition: value.condition.into(),
+            requirement: value.requirement.into(),
+        }
+    }
+}
+
+impl From<ConditionalRequirement> for resolvo::ConditionalRequirement {
+    fn from(value: ConditionalRequirement) -> Self {
+        Self {
+            condition: value.condition.into(),
+            requirement: value.requirement.into(),
+        }
+    }
+}
+
 /// Specifies the dependency of a solvable on a set of version sets.
 /// cbindgen:derive-eq
 /// cbindgen:derive-neq
@@ -162,7 +251,7 @@ pub struct Dependencies {
     /// A pointer to the first element of a list of requirements. Requirements
     /// defines which packages should be installed alongside the depending
     /// package and the constraints applied to the package.
-    pub requirements: Vector<Requirement>,
+    pub requirements: Vector<ConditionalRequirement>,
 
     /// Defines additional constraints on packages that may or may not be part
     /// of the solution. Different from `requirements`, packages in this set
@@ -475,7 +564,7 @@ impl<'d> resolvo::DependencyProvider for &'d DependencyProvider {
 
 #[repr(C)]
 pub struct Problem<'a> {
-    pub requirements: Slice<'a, Requirement>,
+    pub requirements: Slice<'a, ConditionalRequirement>,
     pub constraints: Slice<'a, VersionSetId>,
     pub soft_requirements: Slice<'a, SolvableId>,
 }
@@ -525,6 +614,28 @@ pub extern "C" fn resolvo_solve(
     }
 }
 
+#[no_mangle]
+#[allow(unused)]
+pub extern "C" fn resolvo_conditional_requirement_single(
+    version_set_id: VersionSetId,
+) -> ConditionalRequirement {
+    ConditionalRequirement {
+        condition: Option::<VersionSetId>::None.into(),
+        requirement: Requirement::Single(version_set_id),
+    }
+}
+
+#[no_mangle]
+#[allow(unused)]
+pub extern "C" fn resolvo_conditional_requirement_union(
+    version_set_union_id: VersionSetUnionId,
+) -> ConditionalRequirement {
+    ConditionalRequirement {
+        condition: Option::<VersionSetId>::None.into(),
+        requirement: Requirement::Union(version_set_union_id),
+    }
+}
+
 #[no_mangle]
 #[allow(unused)]
 pub extern "C" fn resolvo_requirement_single(version_set_id: VersionSetId) -> Requirement {

cpp/tests/solve.cpp

@@ -48,16 +48,17 @@ struct PackageDatabase : public resolvo::DependencyProvider {
     /**
      * Allocates a new requirement for a single version set.
      */
-    resolvo::Requirement alloc_requirement(std::string_view package, uint32_t version_start,
-                                           uint32_t version_end) {
+    resolvo::ConditionalRequirement alloc_requirement(std::string_view package,
+                                                      uint32_t version_start,
+                                                      uint32_t version_end) {
         auto id = alloc_version_set(package, version_start, version_end);
-        return resolvo::requirement_single(id);
+        return resolvo::conditional_requirement_single(id);
     }
 
     /**
      * Allocates a new requirement for a version set union.
      */
-    resolvo::Requirement alloc_requirement_union(
+    resolvo::ConditionalRequirement alloc_requirement_union(
         std::initializer_list<std::tuple<std::string_view, uint32_t, uint32_t>> version_sets) {
         std::vector<resolvo::VersionSetId> version_set_union{version_sets.size()};
 
@@ -69,7 +70,7 @@ struct PackageDatabase : public resolvo::DependencyProvider {
 
         auto id = resolvo::VersionSetUnionId{static_cast<uint32_t>(version_set_unions.size())};
         version_set_unions.push_back(std::move(version_set_union));
-        return resolvo::requirement_union(id);
+        return resolvo::conditional_requirement_union(id);
     }
 
     /**
@@ -219,7 +220,8 @@ SCENARIO("Solve") {
     const auto d_1 = db.alloc_candidate("d", 1, {});
 
     // Construct a problem to be solved by the solver
-    resolvo::Vector<resolvo::Requirement> requirements = {db.alloc_requirement("a", 1, 3)};
+    resolvo::Vector<resolvo::ConditionalRequirement> requirements = {
+        db.alloc_requirement("a", 1, 3)};
     resolvo::Vector<resolvo::VersionSetId> constraints = {
         db.alloc_version_set("b", 1, 3),
         db.alloc_version_set("c", 1, 3),
@@ -263,7 +265,7 @@ SCENARIO("Solve Union") {
         "f", 1, {{db.alloc_requirement("b", 1, 10)}, {db.alloc_version_set("a", 10, 20)}});
 
     // Construct a problem to be solved by the solver
-    resolvo::Vector<resolvo::Requirement> requirements = {
+    resolvo::Vector<resolvo::ConditionalRequirement> requirements = {
         db.alloc_requirement_union({{"c", 1, 10}, {"d", 1, 10}}),
         db.alloc_requirement("e", 1, 10),
         db.alloc_requirement("f", 1, 10),