Use u64 for version set type

Author: x-hgg-x

benches/bench.rs

@@ -29,7 +29,7 @@ fn bench(b: &mut Bencher, data: &str) {
         .first_key_value()
         .and_then(|(&p, vmap)| vmap.first_key_value().map(|(&v, _)| (p, v)))
     {
-        b.iter(|| pubgrub::resolve(&mut dependency_provider, p, v).unwrap());
+        b.iter(|| dependency_provider.resolve(p, v).unwrap());
     }
 }
 

benches/large_case.rs

@@ -6,20 +6,19 @@ use std::time::Duration;
 use criterion::*;
 use serde::de::Deserialize;
 
-use pubgrub::{resolve, Map, OfflineDependencyProvider, Range, SemanticVersion, VersionSet};
+use pubgrub::{Map, OfflineDependencyProvider, Range, VersionRanges};
 
 fn bench<
     'a,
     P: Debug + Display + Clone + Eq + Hash + Deserialize<'a>,
-    VS: VersionSet + Deserialize<'a>,
+    R: VersionRanges + Deserialize<'a>,
 >(
     b: &mut Bencher,
     case: &'a str,
 ) where
-    <VS as VersionSet>::V: Deserialize<'a>,
+    R::V: Deserialize<'a>,
 {
-    let mut dependency_provider: OfflineDependencyProvider<P, VS> =
-        ron::de::from_str(case).unwrap();
+    let mut dependency_provider: OfflineDependencyProvider<P, R> = ron::de::from_str(case).unwrap();
 
     let dependencies = dependency_provider
         .packages()
@@ -33,8 +32,8 @@ fn bench<
 
     b.iter(|| {
         for (p, versions) in &dependencies {
-            for n in versions {
-                let _ = resolve(&mut dependency_provider, p.clone(), n.clone());
+            for v in versions {
+                let _ = dependency_provider.resolve(p.clone(), v.clone());
             }
         }
     });
@@ -48,14 +47,10 @@ fn bench_nested(c: &mut Criterion) {
         let case = case.unwrap().path();
         let name = case.file_name().unwrap().to_string_lossy();
         let data = std::fs::read_to_string(&case).unwrap();
-        if name.ends_with("u16_NumberVersion.ron") || name.ends_with("u16_u32.ron") {
+        if name.ends_with("u16_NumberVersion.ron") {
             group.bench_function(name, |b| {
                 bench::<u16, Range<u32>>(b, &data);
             });
-        } else if name.ends_with("str_SemanticVersion.ron") {
-            group.bench_function(name, |b| {
-                bench::<&str, Range<SemanticVersion>>(b, &data);
-            });
         }
     }
 

benches/sudoku.rs

@@ -4,7 +4,7 @@
 use std::fmt;
 
 use pubgrub::{
-    resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Range, Reporter,
+    DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Range, Reporter,
     SelectedDependencies,
 };
 use version_ranges::Ranges;
@@ -121,11 +121,14 @@ 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(&mut dependency_provider, SudokuPackage::Root, 1) {
+    match dependency_provider.resolve(SudokuPackage::Root, 1) {
         Ok(sol) => sol,
         Err(PubGrubError::NoSolution(mut error)) => {
             error.derivation_tree.collapse_no_versions();
-            eprintln!("{}", DefaultStringReporter::report(&error));
+            eprintln!(
+                "{}",
+                DefaultStringReporter::report(&error, &dependency_provider)
+            );
             std::process::exit(1);
         }
         Err(err) => panic!("{:?}", err),

examples/branching_error_reporting.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use pubgrub::{
-    resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
+    DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
     SemanticVersion,
 };
 
@@ -10,15 +10,16 @@ type SemVS = Ranges<SemanticVersion>;
 // https://github.com/dart-lang/pub/blob/master/doc/solver.md#branching-error-reporting
 fn main() {
     let mut dependency_provider = OfflineDependencyProvider::<&str, SemVS>::new();
+
     #[rustfmt::skip]
     // root 1.0.0 depends on foo ^1.0.0
-        dependency_provider.add_dependencies(
+    dependency_provider.add_dependencies(
         "root", (1, 0, 0),
         [("foo", Ranges::from_range_bounds((1, 0, 0)..(2, 0, 0)))],
     );
     #[rustfmt::skip]
     // foo 1.0.0 depends on a ^1.0.0 and b ^1.0.0
-        dependency_provider.add_dependencies(
+    dependency_provider.add_dependencies(
         "foo", (1, 0, 0),
         [
             ("a", Ranges::from_range_bounds((1, 0, 0)..(2, 0, 0))),
@@ -27,7 +28,7 @@ fn main() {
     );
     #[rustfmt::skip]
     // foo 1.1.0 depends on x ^1.0.0 and y ^1.0.0
-        dependency_provider.add_dependencies(
+    dependency_provider.add_dependencies(
         "foo", (1, 1, 0),
         [
             ("x", Ranges::from_range_bounds((1, 0, 0)..(2, 0, 0))),
@@ -36,7 +37,7 @@ fn main() {
     );
     #[rustfmt::skip]
     // a 1.0.0 depends on b ^2.0.0
-        dependency_provider.add_dependencies(
+    dependency_provider.add_dependencies(
         "a", (1, 0, 0),
         [("b", Ranges::from_range_bounds((2, 0, 0)..(3, 0, 0)))],
     );
@@ -45,7 +46,7 @@ fn main() {
     dependency_provider.add_dependencies("b", (2, 0, 0), []);
     #[rustfmt::skip]
     // x 1.0.0 depends on y ^2.0.0.
-        dependency_provider.add_dependencies(
+    dependency_provider.add_dependencies(
         "x", (1, 0, 0),
         [("y", Ranges::from_range_bounds((2, 0, 0)..(3, 0, 0)))],
     );
@@ -54,11 +55,14 @@ fn main() {
     dependency_provider.add_dependencies("y", (2, 0, 0), []);
 
     // Run the algorithm.
-    match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
+    match dependency_provider.resolve("root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut error)) => {
             error.derivation_tree.collapse_no_versions();
-            eprintln!("{}", DefaultStringReporter::report(&error));
+            eprintln!(
+                "{}",
+                DefaultStringReporter::report(&error, &dependency_provider)
+            );
             std::process::exit(1);
         }
         Err(err) => panic!("{:?}", err),

examples/caching_dependency_provider.rs

@@ -1,53 +1,89 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use std::cell::RefCell;
-use std::collections::BTreeMap;
 use std::fmt::{Debug, Display};
 use std::hash::Hash;
 
 use pubgrub::{
     resolve, Dependencies, DependencyConstraints, DependencyProvider, Map,
-    OfflineDependencyProvider, Package, PackageArena, Ranges,
+    OfflineDependencyProvider, Package, PackageArena, PubGrubError, Ranges, SelectedDependencies,
+    Version, VersionRanges, VersionSet,
 };
 
 type NumVS = Ranges<u32>;
-type CachedDeps<V, VS> = RefCell<Map<Package, BTreeMap<V, DependencyConstraints<VS>>>>;
+
+trait RemoteProvider: DependencyProvider {
+    type R: VersionRanges;
+
+    fn get_package_version(
+        &self,
+        p: &Self::P,
+        v: &<Self::R as VersionRanges>::V,
+    ) -> Option<Version>;
+}
+
+impl<P: Debug + Display + Clone + Eq + Hash, R: VersionRanges> RemoteProvider
+    for OfflineDependencyProvider<P, R>
+{
+    type R = R;
+
+    fn get_package_version(
+        &self,
+        p: &Self::P,
+        v: &<Self::R as VersionRanges>::V,
+    ) -> Option<Version> {
+        self.get_package_version(p, v)
+    }
+}
 
 // An example implementing caching dependency provider that will
 // store queried dependencies in memory and check them before querying more from remote.
-struct CachingDependencyProvider<DP: DependencyProvider>
+struct CachingDependencyProvider<DP: RemoteProvider<R = R>, R: VersionRanges>
 where
     DP::P: Debug + Display + Clone + Eq + Hash,
 {
     remote_dependencies: DP,
-    cached_dependencies: CachedDeps<DP::V, DP::VS>,
+    cached_dependencies: RefCell<Map<Package, Map<Version, DependencyConstraints>>>,
 }
 
-impl<DP: DependencyProvider> CachingDependencyProvider<DP>
+impl<DP: RemoteProvider<R = R>, R: VersionRanges> CachingDependencyProvider<DP, R>
 where
     DP::P: Debug + Display + Clone + Eq + Hash,
 {
-    pub fn new(remote_dependencies_provider: DP) -> Self {
+    fn new(remote_dependencies_provider: DP) -> Self {
         CachingDependencyProvider {
             remote_dependencies: remote_dependencies_provider,
             cached_dependencies: Default::default(),
         }
     }
+
+    fn resolve(
+        &mut self,
+        p: <Self as DependencyProvider>::P,
+        v: impl Into<R::V>,
+    ) -> Result<SelectedDependencies<Self>, PubGrubError<Self>> {
+        let Some(version) = self.remote_dependencies.get_package_version(&p, &v.into()) else {
+            return Err(PubGrubError::NoRoot);
+        };
+        resolve(self, p, version)
+    }
 }
 
-impl<DP: DependencyProvider<M = &'static str>> DependencyProvider for CachingDependencyProvider<DP>
+impl<DP: RemoteProvider<R = R>, R: VersionRanges> DependencyProvider
+    for CachingDependencyProvider<DP, R>
 where
     DP::P: Debug + Display + Clone + Eq + Hash,
+    R::V: Clone,
 {
     // Cache dependencies if they were already queried
     fn get_dependencies(
         &mut self,
         package: Package,
-        version: &DP::V,
+        version: Version,
         package_store: &mut PackageArena<Self::P>,
-    ) -> Result<Dependencies<DP::VS, DP::M>, DP::Err> {
+    ) -> Result<Dependencies<DP::M>, DP::Err> {
         let mut cache = self.cached_dependencies.borrow_mut();
-        if let Some(deps) = cache.get(&package).and_then(|vmap| vmap.get(version)) {
+        if let Some(deps) = cache.get(&package).and_then(|vmap| vmap.get(&version)) {
             return Ok(Dependencies::Available(deps.clone()));
         }
 
@@ -59,7 +95,7 @@ where
                 cache
                     .entry(package)
                     .or_default()
-                    .insert(version.clone(), deps.clone());
+                    .insert(version, deps.clone());
                 Ok(Dependencies::Available(deps))
             }
 
@@ -71,31 +107,42 @@ where
     fn choose_version(
         &mut self,
         package: Package,
-        ranges: &DP::VS,
+        range: VersionSet,
         package_store: &PackageArena<Self::P>,
-    ) -> Result<Option<DP::V>, DP::Err> {
+    ) -> Result<Option<Version>, DP::Err> {
         self.remote_dependencies
-            .choose_version(package, ranges, package_store)
+            .choose_version(package, range, package_store)
     }
 
     type Priority = DP::Priority;
 
     fn prioritize(
         &mut self,
         package: Package,
-        ranges: &DP::VS,
+        range: VersionSet,
         package_store: &PackageArena<Self::P>,
     ) -> Self::Priority {
         self.remote_dependencies
-            .prioritize(package, ranges, package_store)
+            .prioritize(package, range, package_store)
     }
 
     type Err = DP::Err;
 
     type P = DP::P;
-    type V = DP::V;
-    type VS = DP::VS;
     type M = DP::M;
+
+    fn package_version_repr<'a>(&'a self, pkg: &'a Self::P, version: Version) -> impl Display + 'a {
+        self.remote_dependencies.package_version_repr(pkg, version)
+    }
+
+    fn package_version_set_repr<'a>(
+        &'a self,
+        pkg: &'a Self::P,
+        version_set: VersionSet,
+    ) -> impl Display + 'a {
+        self.remote_dependencies
+            .package_version_set_repr(pkg, version_set)
+    }
 }
 
 fn main() {
@@ -108,6 +155,6 @@ fn main() {
     let mut caching_dependencies_provider =
         CachingDependencyProvider::new(remote_dependencies_provider);
 
-    let solution = resolve(&mut caching_dependencies_provider, "root", 1u32);
+    let solution = caching_dependencies_provider.resolve("root", 1u32);
     println!("Solution: {:?}", solution);
 }

examples/doc_interface.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use pubgrub::{resolve, OfflineDependencyProvider, Ranges};
+use pubgrub::{OfflineDependencyProvider, Ranges};
 
 type NumVS = Ranges<u32>;
 
@@ -19,6 +19,12 @@ fn main() {
     dependency_provider.add_dependencies("icons", 1u32, []);
 
     // Run the algorithm.
-    let solution = resolve(&mut dependency_provider, "root", 1u32);
-    println!("Solution: {:?}", solution);
+    let solution = dependency_provider.resolve("root", 1u32).unwrap();
+    println!(
+        "Solution: {:?}",
+        solution.iter().map(|(p, v)| {
+            (p, dependency_provider.versions(p).unwrap().nth(v.get() as usize).unwrap())
+        })
+        .collect::<Vec<_>>()
+    );
 }

examples/doc_interface_error.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use pubgrub::{
-    resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
+    DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
     SemanticVersion,
 };
 
@@ -71,11 +71,17 @@ fn main() {
     dependency_provider.add_dependencies("intl", (5, 0, 0), []);
 
     // Run the algorithm.
-    match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
-        Ok(sol) => println!("{:?}", sol),
+    match dependency_provider.resolve("root", (1, 0, 0)) {
+        Ok(sol) => println!(
+            "Solution: {:?}",
+            sol.iter().map(|(p, v)| {
+                (p, dependency_provider.versions(p).unwrap().nth(v.get() as usize).unwrap())
+            })
+            .collect::<Vec<_>>()
+        ),
         Err(PubGrubError::NoSolution(mut error)) => {
             error.derivation_tree.collapse_no_versions();
-            eprintln!("{}", DefaultStringReporter::report(&error));
+            eprintln!("{}", DefaultStringReporter::report(&error, &dependency_provider));
         }
         Err(err) => panic!("{:?}", err),
     };