DependencyProvider methods now takes mutable reference

x-hgg-x · x-hgg-x · commit df7540c7c310 · 2024-11-08T20:20:07.000+01:00
diff --git a/benches/large_case.rs b/benches/large_case.rs
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: MPL-2.0
+use std::collections::HashMap;
 use std::time::Duration;
 
 use criterion::*;
@@ -12,12 +13,23 @@ fn bench<'a, P: Package + Deserialize<'a>, VS: VersionSet + Deserialize<'a>>(
 ) where
     <VS as VersionSet>::V: Deserialize<'a>,
 {
-    let dependency_provider: OfflineDependencyProvider<P, VS> = ron::de::from_str(case).unwrap();
+    let mut dependency_provider: OfflineDependencyProvider<P, VS> =
+        ron::de::from_str(case).unwrap();
+
+    let dependencies = dependency_provider
+        .packages()
+        .map(|p| {
+            (
+                p.clone(),
+                dependency_provider.versions(p).unwrap().cloned().collect(),
+            )
+        })
+        .collect::<HashMap<_, Vec<_>>>();
 
     b.iter(|| {
-        for p in dependency_provider.packages() {
-            for n in dependency_provider.versions(p).unwrap() {
-                let _ = resolve(&dependency_provider, p.clone(), n.clone());
+        for (p, versions) in &dependencies {
+            for n in versions {
+                let _ = resolve(&mut dependency_provider, p.clone(), n.clone());
             }
         }
     });
diff --git a/benches/sudoku.rs b/benches/sudoku.rs
@@ -121,7 +121,7 @@ fn solve(board: Vec<(SudokuPackage, Ranges<u8>)>) -> SelectedDependencies<DP> {
     let mut dependency_provider = DP::new();
     encode_constraints(&mut dependency_provider);
     dependency_provider.add_dependencies(SudokuPackage::Root, 1, board);
-    match resolve(&dependency_provider, SudokuPackage::Root, 1) {
+    match resolve(&mut dependency_provider, SudokuPackage::Root, 1) {
         Ok(sol) => sol,
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
             derivation_tree.collapse_no_versions();
diff --git a/examples/branching_error_reporting.rs b/examples/branching_error_reporting.rs
@@ -54,7 +54,7 @@ fn main() {
     dependency_provider.add_dependencies("y", (2, 0, 0), []);
 
     // Run the algorithm.
-    match resolve(&dependency_provider, "root", (1, 0, 0)) {
+    match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
             derivation_tree.collapse_no_versions();
diff --git a/examples/caching_dependency_provider.rs b/examples/caching_dependency_provider.rs
@@ -25,7 +25,7 @@ impl<DP: DependencyProvider> CachingDependencyProvider<DP> {
 impl<DP: DependencyProvider<M = String>> DependencyProvider for CachingDependencyProvider<DP> {
     // Caches dependencies if they were already queried
     fn get_dependencies(
-        &self,
+        &mut self,
         package: &DP::P,
         version: &DP::V,
     ) -> Result<Dependencies<DP::P, DP::VS, DP::M>, DP::Err> {
@@ -51,13 +51,17 @@ impl<DP: DependencyProvider<M = String>> DependencyProvider for CachingDependenc
         }
     }
 
-    fn choose_version(&self, package: &DP::P, ranges: &DP::VS) -> Result<Option<DP::V>, DP::Err> {
+    fn choose_version(
+        &mut self,
+        package: &DP::P,
+        ranges: &DP::VS,
+    ) -> Result<Option<DP::V>, DP::Err> {
         self.remote_dependencies.choose_version(package, ranges)
     }
 
     type Priority = DP::Priority;
 
-    fn prioritize(&self, package: &DP::P, ranges: &DP::VS) -> Self::Priority {
+    fn prioritize(&mut self, package: &DP::P, ranges: &DP::VS) -> Self::Priority {
         self.remote_dependencies.prioritize(package, ranges)
     }
 
@@ -76,9 +80,9 @@ fn main() {
     // Add dependencies as needed. Here only root package is added.
     remote_dependencies_provider.add_dependencies("root", 1u32, Vec::new());
 
-    let caching_dependencies_provider =
+    let mut caching_dependencies_provider =
         CachingDependencyProvider::new(remote_dependencies_provider);
 
-    let solution = resolve(&caching_dependencies_provider, "root", 1u32);
+    let solution = resolve(&mut caching_dependencies_provider, "root", 1u32);
     println!("Solution: {:?}", solution);
 }
diff --git a/examples/doc_interface.rs b/examples/doc_interface.rs
@@ -19,6 +19,6 @@ fn main() {
     dependency_provider.add_dependencies("icons", 1u32, []);
 
     // Run the algorithm.
-    let solution = resolve(&dependency_provider, "root", 1u32);
+    let solution = resolve(&mut dependency_provider, "root", 1u32);
     println!("Solution: {:?}", solution);
 }
diff --git a/examples/doc_interface_error.rs b/examples/doc_interface_error.rs
@@ -71,7 +71,7 @@ fn main() {
     dependency_provider.add_dependencies("intl", (5, 0, 0), []);
 
     // Run the algorithm.
-    match resolve(&dependency_provider, "root", (1, 0, 0)) {
+    match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
             derivation_tree.collapse_no_versions();
diff --git a/examples/doc_interface_semantic.rs b/examples/doc_interface_semantic.rs
@@ -62,7 +62,7 @@ fn main() {
     dependency_provider.add_dependencies("icons", (2, 0, 0), []);
 
     // Run the algorithm.
-    match resolve(&dependency_provider, "root", (1, 0, 0)) {
+    match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
             derivation_tree.collapse_no_versions();
diff --git a/examples/linear_error_reporting.rs b/examples/linear_error_reporting.rs
@@ -36,7 +36,7 @@ fn main() {
     dependency_provider.add_dependencies("baz", (3, 0, 0), []);
 
     // Run the algorithm.
-    match resolve(&dependency_provider, "root", (1, 0, 0)) {
+    match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
             derivation_tree.collapse_no_versions();
diff --git a/examples/unsat_root_message_no_version.rs b/examples/unsat_root_message_no_version.rs
@@ -217,7 +217,7 @@ fn main() {
     );
 
     // Run the algorithm
-    match resolve(&dependency_provider, Package::Root, (0, 0, 0)) {
+    match resolve(&mut dependency_provider, Package::Root, (0, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(derivation_tree)) => {
             eprintln!("No solution.\n");
diff --git a/src/internal/partial_solution.rs b/src/internal/partial_solution.rs
@@ -259,7 +259,7 @@ impl<DP: DependencyProvider> PartialSolution<DP> {
 
     pub(crate) fn pick_highest_priority_pkg(
         &mut self,
-        prioritizer: impl Fn(&DP::P, &DP::VS) -> DP::Priority,
+        mut prioritizer: impl FnMut(&DP::P, &DP::VS) -> DP::Priority,
     ) -> Option<DP::P> {
         let check_all = self.changed_this_decision_level
             == self.current_decision_level.0.saturating_sub(1) as usize;
diff --git a/src/internal/small_map.rs b/src/internal/small_map.rs
@@ -105,9 +105,12 @@ impl<K: PartialEq + Eq + Hash, V> SmallMap<K, V> {
     ///
     /// This is an optimization over the following, where we only need a reference to `t1`. It
     /// avoids cloning and then drop the ranges in each `prior_cause` call.
-    /// ```ignore
+    /// ```
+    /// # use pubgrub::Map;
+    /// # let package_terms = Map::from_iter([(1, 1)]);
+    /// # let package = 1;
     /// let mut package_terms = package_terms.clone();
-    //  let t1 = package_terms.remove(package).unwrap();
+    /// let t1 = package_terms.remove(&package).unwrap();
     /// ```
     pub(crate) fn split_one(&self, key: &K) -> Option<(&V, Self)>
     where
diff --git a/src/lib.rs b/src/lib.rs
@@ -56,7 +56,7 @@
 //! dependency_provider.add_dependencies("icons", 1u32, []);
 //!
 //! // Run the algorithm.
-//! let solution = resolve(&dependency_provider, "root", 1u32).unwrap();
+//! let solution = resolve(&mut dependency_provider, "root", 1u32).unwrap();
 //! ```
 //!
 //! # DependencyProvider trait
@@ -81,17 +81,17 @@
 //! type SemVS = Ranges<SemanticVersion>;
 //!
 //! impl DependencyProvider for MyDependencyProvider {
-//!     fn choose_version(&self, package: &String, range: &SemVS) -> Result<Option<SemanticVersion>, Infallible> {
+//!     fn choose_version(&mut self, package: &String, range: &SemVS) -> Result<Option<SemanticVersion>, Infallible> {
 //!         unimplemented!()
 //!     }
 //!
 //!     type Priority = usize;
-//!     fn prioritize(&self, package: &String, range: &SemVS) -> Self::Priority {
+//!     fn prioritize(&mut self, package: &String, range: &SemVS) -> Self::Priority {
 //!         unimplemented!()
 //!     }
 //!
 //!     fn get_dependencies(
-//!         &self,
+//!         &mut self,
 //!         package: &String,
 //!         version: &SemanticVersion,
 //!     ) -> Result<Dependencies<String, SemVS, Self::M>, Infallible> {
@@ -176,11 +176,11 @@
 //! #
 //! # type NumVS = Ranges<u32>;
 //! #
-//! # let dependency_provider = OfflineDependencyProvider::<&str, NumVS>::new();
+//! # let mut dependency_provider = OfflineDependencyProvider::<&str, NumVS>::new();
 //! # let root_package = "root";
 //! # let root_version = 1u32;
 //! #
-//! match resolve(&dependency_provider, root_package, root_version) {
+//! match resolve(&mut dependency_provider, root_package, root_version) {
 //!     Ok(solution) => println!("{:?}", solution),
 //!     Err(PubGrubError::NoSolution(mut derivation_tree)) => {
 //!         derivation_tree.collapse_no_versions();
diff --git a/src/solver.rs b/src/solver.rs
@@ -40,10 +40,10 @@
 //! # type NumVS = Ranges<u32>;
 //! #
 //! # fn try_main() -> Result<(), PubGrubError<OfflineDependencyProvider<&'static str, NumVS>>> {
-//! #     let dependency_provider = OfflineDependencyProvider::<&str, NumVS>::new();
+//! #     let mut dependency_provider = OfflineDependencyProvider::<&str, NumVS>::new();
 //! #     let package = "root";
 //! #     let version = 1u32;
-//! let solution = resolve(&dependency_provider, package, version)?;
+//! let solution = resolve(&mut dependency_provider, package, version)?;
 //! #     Ok(())
 //! # }
 //! # fn main() {
@@ -73,7 +73,7 @@ use crate::{DependencyConstraints, Map, Package, PubGrubError, SelectedDependenc
 /// Main function of the library.
 /// Finds a set of packages satisfying dependency bounds for a given package + version pair.
 pub fn resolve<DP: DependencyProvider>(
-    dependency_provider: &DP,
+    dependency_provider: &mut DP,
     package: DP::P,
     version: impl Into<DP::V>,
 ) -> Result<SelectedDependencies<DP>, PubGrubError<DP>> {
@@ -240,7 +240,7 @@ pub trait DependencyProvider {
     ///
     /// Note: the resolver may call this even when the range has not changed,
     /// if it is more efficient for the resolvers internal data structures.
-    fn prioritize(&self, package: &Self::P, range: &Self::VS) -> Self::Priority;
+    fn prioritize(&mut self, package: &Self::P, range: &Self::VS) -> Self::Priority;
     /// The type returned from `prioritize`. The resolver does not care what type this is
     /// as long as it can pick a largest one and clone it.
     ///
@@ -257,7 +257,7 @@ pub trait DependencyProvider {
     /// packages, it needs to know what version of that package to use. The most common pattern
     /// is to select the largest version that the range contains.
     fn choose_version(
-        &self,
+        &mut self,
         package: &Self::P,
         range: &Self::VS,
     ) -> Result<Option<Self::V>, Self::Err>;
@@ -266,7 +266,7 @@ pub trait DependencyProvider {
     /// Return [Dependencies::Unavailable] if its dependencies are unavailable.
     #[allow(clippy::type_complexity)]
     fn get_dependencies(
-        &self,
+        &mut self,
         package: &Self::P,
         version: &Self::V,
     ) -> Result<Dependencies<Self::P, Self::VS, Self::M>, Self::Err>;
@@ -276,7 +276,7 @@ pub trait DependencyProvider {
     /// This is helpful if you want to add some form of early termination like a timeout,
     /// or you want to add some form of user feedback if things are taking a while.
     /// If not provided the resolver will run as long as needed.
-    fn should_cancel(&self) -> Result<(), Self::Err> {
+    fn should_cancel(&mut self) -> Result<(), Self::Err> {
         Ok(())
     }
 }
@@ -361,15 +361,15 @@ impl<P: Package, VS: VersionSet> DependencyProvider for OfflineDependencyProvide
 
     type Err = Infallible;
 
-    fn choose_version(&self, package: &P, range: &VS) -> Result<Option<VS::V>, Infallible> {
+    fn choose_version(&mut self, package: &P, range: &VS) -> Result<Option<VS::V>, Infallible> {
         Ok(self
             .dependencies
             .get(package)
             .and_then(|versions| versions.keys().rev().find(|v| range.contains(v)).cloned()))
     }
 
     type Priority = Reverse<usize>;
-    fn prioritize(&self, package: &P, range: &VS) -> Self::Priority {
+    fn prioritize(&mut self, package: &P, range: &VS) -> Self::Priority {
         Reverse(
             self.dependencies
                 .get(package)
@@ -379,7 +379,7 @@ impl<P: Package, VS: VersionSet> DependencyProvider for OfflineDependencyProvide
     }
 
     fn get_dependencies(
-        &self,
+        &mut self,
         package: &P,
         version: &VS::V,
     ) -> Result<Dependencies<P, VS, Self::M>, Infallible> {
diff --git a/tests/examples.rs b/tests/examples.rs
@@ -39,7 +39,7 @@ fn no_conflict() {
     dependency_provider.add_dependencies("bar", (2, 0, 0), []);
 
     // Run the algorithm.
-    let computed_solution = resolve(&dependency_provider, "root", (1, 0, 0)).unwrap();
+    let computed_solution = resolve(&mut dependency_provider, "root", (1, 0, 0)).unwrap();
 
     // Solution.
     let mut expected_solution = Map::default();
@@ -75,7 +75,7 @@ fn avoiding_conflict_during_decision_making() {
     dependency_provider.add_dependencies("bar", (2, 0, 0), []);
 
     // Run the algorithm.
-    let computed_solution = resolve(&dependency_provider, "root", (1, 0, 0)).unwrap();
+    let computed_solution = resolve(&mut dependency_provider, "root", (1, 0, 0)).unwrap();
 
     // Solution.
     let mut expected_solution = Map::default();
@@ -110,7 +110,7 @@ fn conflict_resolution() {
     );
 
     // Run the algorithm.
-    let computed_solution = resolve(&dependency_provider, "root", (1, 0, 0)).unwrap();
+    let computed_solution = resolve(&mut dependency_provider, "root", (1, 0, 0)).unwrap();
 
     // Solution.
     let mut expected_solution = Map::default();
@@ -168,7 +168,7 @@ fn conflict_with_partial_satisfier() {
     dependency_provider.add_dependencies("target", (1, 0, 0), []);
 
     // Run the algorithm.
-    let computed_solution = resolve(&dependency_provider, "root", (1, 0, 0)).unwrap();
+    let computed_solution = resolve(&mut dependency_provider, "root", (1, 0, 0)).unwrap();
 
     // Solution.
     let mut expected_solution = Map::default();
@@ -207,7 +207,7 @@ fn double_choices() {
     expected_solution.insert("d", 0u32);
 
     // Run the algorithm.
-    let computed_solution = resolve(&dependency_provider, "a", 0u32).unwrap();
+    let computed_solution = resolve(&mut dependency_provider, "a", 0u32).unwrap();
     assert_eq!(expected_solution, computed_solution);
 }
 
@@ -231,7 +231,7 @@ fn confusing_with_lots_of_holes() {
     dependency_provider.add_dependencies("baz", 1u32, vec![]);
 
     let Err(PubGrubError::NoSolution(mut derivation_tree)) =
-        resolve(&dependency_provider, "root", 1u32)
+        resolve(&mut dependency_provider, "root", 1u32)
     else {
         unreachable!()
     };
diff --git a/tests/proptest.rs b/tests/proptest.rs
diff --git a/tests/sat_dependency_provider.rs b/tests/sat_dependency_provider.rs
diff --git a/tests/tests.rs b/tests/tests.rs

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,6 @@ fn main() {`
`19`	`19`	`dependency_provider.add_dependencies("icons", 1u32, []);`
`20`	`20`
`21`	`21`	`// Run the algorithm.`
`22`		`- let solution = resolve(&dependency_provider, "root", 1u32);`
	`22`	`+ let solution = resolve(&mut dependency_provider, "root", 1u32);`
`23`	`23`	`println!("Solution: {:?}", solution);`
`24`	`24`	`}`