Skip to content

Commit 6b61cbd

Browse files
x-hgg-xx-hgg-x
committed
Use u64 for version set type
1 parent 8628ea7 commit 6b61cbd

30 files changed

+2227
-1235
lines changed

‎benches/bench.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ fn bench(b: &mut Bencher, data: &str) {
2929
.first_key_value()
3030
.and_then(|(&p, vmap)| vmap.first_key_value().map(|(&v, _)| (p, v)))
3131
{
32-
b.iter(|| pubgrub::resolve(&mut dependency_provider, p, v).unwrap());
32+
b.iter(|| dependency_provider.resolve(p, v).unwrap());
3333
}
3434
}
3535

‎benches/large_case.rs‎

Lines changed: 7 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -6,20 +6,19 @@ use std::time::Duration;
66
use criterion::*;
77
use serde::de::Deserialize;
88

9-
use pubgrub::{resolve, Map, OfflineDependencyProvider, Range, SemanticVersion, VersionSet};
9+
use pubgrub::{Map, OfflineDependencyProvider, Range, VersionRanges};
1010

1111
fn bench<
1212
'a,
1313
P: Debug + Display + Clone + Eq + Hash + Deserialize<'a>,
14-
VS: VersionSet + Deserialize<'a>,
14+
R: VersionRanges + Deserialize<'a>,
1515
>(
1616
b: &mut Bencher,
1717
case: &'a str,
1818
) where
19-
<VS as VersionSet>::V: Deserialize<'a>,
19+
R::V: Deserialize<'a>,
2020
{
21-
let mut dependency_provider: OfflineDependencyProvider<P, VS> =
22-
ron::de::from_str(case).unwrap();
21+
let mut dependency_provider: OfflineDependencyProvider<P, R> = ron::de::from_str(case).unwrap();
2322

2423
let dependencies = dependency_provider
2524
.packages()
@@ -33,8 +32,8 @@ fn bench<
3332

3433
b.iter(|| {
3534
for (p, versions) in &dependencies {
36-
for n in versions {
37-
let _ = resolve(&mut dependency_provider, p.clone(), n.clone());
35+
for v in versions {
36+
let _ = dependency_provider.resolve(p.clone(), v.clone());
3837
}
3938
}
4039
});
@@ -48,14 +47,10 @@ fn bench_nested(c: &mut Criterion) {
4847
let case = case.unwrap().path();
4948
let name = case.file_name().unwrap().to_string_lossy();
5049
let data = std::fs::read_to_string(&case).unwrap();
51-
if name.ends_with("u16_NumberVersion.ron") || name.ends_with("u16_u32.ron") {
50+
if name.ends_with("u16_NumberVersion.ron") {
5251
group.bench_function(name, |b| {
5352
bench::<u16, Range<u32>>(b, &data);
5453
});
55-
} else if name.ends_with("str_SemanticVersion.ron") {
56-
group.bench_function(name, |b| {
57-
bench::<&str, Range<SemanticVersion>>(b, &data);
58-
});
5954
}
6055
}
6156

‎benches/sudoku.rs‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
use std::fmt;
55

66
use pubgrub::{
7-
resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Range, Reporter,
7+
DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Range, Reporter,
88
SelectedDependencies,
99
};
1010
use version_ranges::Ranges;
@@ -121,11 +121,14 @@ fn solve(board: Vec<(SudokuPackage, Ranges<u8>)>) -> SelectedDependencies<DP> {
121121
let mut dependency_provider = DP::new();
122122
encode_constraints(&mut dependency_provider);
123123
dependency_provider.add_dependencies(SudokuPackage::Root, 1, board);
124-
match resolve(&mut dependency_provider, SudokuPackage::Root, 1) {
124+
match dependency_provider.resolve(SudokuPackage::Root, 1) {
125125
Ok(sol) => sol,
126126
Err(PubGrubError::NoSolution(mut error)) => {
127127
error.derivation_tree.collapse_no_versions();
128-
eprintln!("{}", DefaultStringReporter::report(&error));
128+
eprintln!(
129+
"{}",
130+
DefaultStringReporter::report(&error, &dependency_provider)
131+
);
129132
std::process::exit(1);
130133
}
131134
Err(err) => panic!("{:?}", err),

‎examples/branching_error_reporting.rs‎

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
// SPDX-License-Identifier: MPL-2.0
22

33
use pubgrub::{
4-
resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
4+
DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
55
SemanticVersion,
66
};
77

@@ -10,15 +10,16 @@ type SemVS = Ranges<SemanticVersion>;
1010
// https://github.com/dart-lang/pub/blob/master/doc/solver.md#branching-error-reporting
1111
fn main() {
1212
let mut dependency_provider = OfflineDependencyProvider::<&str, SemVS>::new();
13+
1314
#[rustfmt::skip]
1415
// root 1.0.0 depends on foo ^1.0.0
15-
dependency_provider.add_dependencies(
16+
dependency_provider.add_dependencies(
1617
"root", (1, 0, 0),
1718
[("foo", Ranges::from_range_bounds((1, 0, 0)..(2, 0, 0)))],
1819
);
1920
#[rustfmt::skip]
2021
// foo 1.0.0 depends on a ^1.0.0 and b ^1.0.0
21-
dependency_provider.add_dependencies(
22+
dependency_provider.add_dependencies(
2223
"foo", (1, 0, 0),
2324
[
2425
("a", Ranges::from_range_bounds((1, 0, 0)..(2, 0, 0))),
@@ -27,7 +28,7 @@ fn main() {
2728
);
2829
#[rustfmt::skip]
2930
// foo 1.1.0 depends on x ^1.0.0 and y ^1.0.0
30-
dependency_provider.add_dependencies(
31+
dependency_provider.add_dependencies(
3132
"foo", (1, 1, 0),
3233
[
3334
("x", Ranges::from_range_bounds((1, 0, 0)..(2, 0, 0))),
@@ -36,7 +37,7 @@ fn main() {
3637
);
3738
#[rustfmt::skip]
3839
// a 1.0.0 depends on b ^2.0.0
39-
dependency_provider.add_dependencies(
40+
dependency_provider.add_dependencies(
4041
"a", (1, 0, 0),
4142
[("b", Ranges::from_range_bounds((2, 0, 0)..(3, 0, 0)))],
4243
);
@@ -45,7 +46,7 @@ fn main() {
4546
dependency_provider.add_dependencies("b", (2, 0, 0), []);
4647
#[rustfmt::skip]
4748
// x 1.0.0 depends on y ^2.0.0.
48-
dependency_provider.add_dependencies(
49+
dependency_provider.add_dependencies(
4950
"x", (1, 0, 0),
5051
[("y", Ranges::from_range_bounds((2, 0, 0)..(3, 0, 0)))],
5152
);
@@ -54,11 +55,14 @@ fn main() {
5455
dependency_provider.add_dependencies("y", (2, 0, 0), []);
5556

5657
// Run the algorithm.
57-
match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
58+
match dependency_provider.resolve("root", (1, 0, 0)) {
5859
Ok(sol) => println!("{:?}", sol),
5960
Err(PubGrubError::NoSolution(mut error)) => {
6061
error.derivation_tree.collapse_no_versions();
61-
eprintln!("{}", DefaultStringReporter::report(&error));
62+
eprintln!(
63+
"{}",
64+
DefaultStringReporter::report(&error, &dependency_provider)
65+
);
6266
std::process::exit(1);
6367
}
6468
Err(err) => panic!("{:?}", err),

‎examples/caching_dependency_provider.rs‎

Lines changed: 79 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,65 +1,107 @@
11
// SPDX-License-Identifier: MPL-2.0
22

33
use std::cell::RefCell;
4-
use std::collections::BTreeMap;
54
use std::fmt::{Debug, Display};
65
use std::hash::Hash;
76

87
use pubgrub::{
98
resolve, Dependencies, DependencyConstraints, DependencyProvider, Map,
10-
OfflineDependencyProvider, Package, PackageArena, Ranges,
9+
OfflineDependencyProvider, Package, PackageArena, PubGrubError, Ranges, SelectedDependencies,
10+
VersionIndex, VersionRanges, VersionSet,
1111
};
1212

1313
type NumVS = Ranges<u32>;
14-
type CachedDeps<V, VS> = RefCell<Map<Package, BTreeMap<V, DependencyConstraints<VS>>>>;
14+
15+
trait RemoteProvider: DependencyProvider {
16+
type R: VersionRanges;
17+
18+
fn package_version_index(
19+
&self,
20+
p: &Self::P,
21+
v: &<Self::R as VersionRanges>::V,
22+
) -> Option<VersionIndex>;
23+
}
24+
25+
impl<P: Debug + Display + Clone + Eq + Hash, R: VersionRanges> RemoteProvider
26+
for OfflineDependencyProvider<P, R>
27+
{
28+
type R = R;
29+
30+
fn package_version_index(
31+
&self,
32+
p: &Self::P,
33+
v: &<Self::R as VersionRanges>::V,
34+
) -> Option<VersionIndex> {
35+
self.package_version_index(p, v)
36+
}
37+
}
1538

1639
// An example implementing caching dependency provider that will
1740
// store queried dependencies in memory and check them before querying more from remote.
18-
struct CachingDependencyProvider<DP: DependencyProvider>
41+
struct CachingDependencyProvider<DP: RemoteProvider<R = R>, R: VersionRanges>
1942
where
2043
DP::P: Debug + Display + Clone + Eq + Hash,
2144
{
2245
remote_dependencies: DP,
23-
cached_dependencies: CachedDeps<DP::V, DP::VS>,
46+
cached_dependencies: RefCell<Map<Package, Map<VersionIndex, DependencyConstraints>>>,
2447
}
2548

26-
impl<DP: DependencyProvider> CachingDependencyProvider<DP>
49+
impl<DP: RemoteProvider<R = R>, R: VersionRanges> CachingDependencyProvider<DP, R>
2750
where
2851
DP::P: Debug + Display + Clone + Eq + Hash,
2952
{
30-
pub fn new(remote_dependencies_provider: DP) -> Self {
53+
fn new(remote_dependencies_provider: DP) -> Self {
3154
CachingDependencyProvider {
3255
remote_dependencies: remote_dependencies_provider,
3356
cached_dependencies: Default::default(),
3457
}
3558
}
59+
60+
fn resolve(
61+
&mut self,
62+
p: <Self as DependencyProvider>::P,
63+
v: impl Into<R::V>,
64+
) -> Result<SelectedDependencies<Self>, PubGrubError<Self>> {
65+
let Some(version_index) = self
66+
.remote_dependencies
67+
.package_version_index(&p, &v.into())
68+
else {
69+
return Err(PubGrubError::NoRoot);
70+
};
71+
resolve(self, p, version_index)
72+
}
3673
}
3774

38-
impl<DP: DependencyProvider<M = &'static str>> DependencyProvider for CachingDependencyProvider<DP>
75+
impl<DP: RemoteProvider<R = R>, R: VersionRanges> DependencyProvider
76+
for CachingDependencyProvider<DP, R>
3977
where
4078
DP::P: Debug + Display + Clone + Eq + Hash,
79+
R::V: Clone,
4180
{
4281
// Cache dependencies if they were already queried
4382
fn get_dependencies(
4483
&mut self,
4584
package: Package,
46-
version: &DP::V,
85+
version_index: VersionIndex,
4786
package_store: &mut PackageArena<Self::P>,
48-
) -> Result<Dependencies<DP::VS, DP::M>, DP::Err> {
87+
) -> Result<Dependencies<DP::M>, DP::Err> {
4988
let mut cache = self.cached_dependencies.borrow_mut();
50-
if let Some(deps) = cache.get(&package).and_then(|vmap| vmap.get(version)) {
89+
if let Some(deps) = cache
90+
.get(&package)
91+
.and_then(|vmap| vmap.get(&version_index))
92+
{
5193
return Ok(Dependencies::Available(deps.clone()));
5294
}
5395

5496
match self
5597
.remote_dependencies
56-
.get_dependencies(package, version, package_store)
98+
.get_dependencies(package, version_index, package_store)
5799
{
58100
Ok(Dependencies::Available(deps)) => {
59101
cache
60102
.entry(package)
61103
.or_default()
62-
.insert(version.clone(), deps.clone());
104+
.insert(version_index, deps.clone());
63105
Ok(Dependencies::Available(deps))
64106
}
65107

@@ -71,31 +113,47 @@ where
71113
fn choose_version(
72114
&mut self,
73115
package: Package,
74-
ranges: &DP::VS,
116+
set: VersionSet,
75117
package_store: &PackageArena<Self::P>,
76-
) -> Result<Option<DP::V>, DP::Err> {
118+
) -> Result<Option<VersionIndex>, DP::Err> {
77119
self.remote_dependencies
78-
.choose_version(package, ranges, package_store)
120+
.choose_version(package, set, package_store)
79121
}
80122

81123
type Priority = DP::Priority;
82124

83125
fn prioritize(
84126
&mut self,
85127
package: Package,
86-
ranges: &DP::VS,
128+
set: VersionSet,
87129
package_store: &PackageArena<Self::P>,
88130
) -> Self::Priority {
89131
self.remote_dependencies
90-
.prioritize(package, ranges, package_store)
132+
.prioritize(package, set, package_store)
91133
}
92134

93135
type Err = DP::Err;
94136

95137
type P = DP::P;
96-
type V = DP::V;
97-
type VS = DP::VS;
98138
type M = DP::M;
139+
140+
fn package_version_repr<'a>(
141+
&'a self,
142+
pkg: &'a Self::P,
143+
version_index: VersionIndex,
144+
) -> impl Display + 'a {
145+
self.remote_dependencies
146+
.package_version_repr(pkg, version_index)
147+
}
148+
149+
fn package_version_set_repr<'a>(
150+
&'a self,
151+
pkg: &'a Self::P,
152+
version_set: VersionSet,
153+
) -> impl Display + 'a {
154+
self.remote_dependencies
155+
.package_version_set_repr(pkg, version_set)
156+
}
99157
}
100158

101159
fn main() {
@@ -108,6 +166,6 @@ fn main() {
108166
let mut caching_dependencies_provider =
109167
CachingDependencyProvider::new(remote_dependencies_provider);
110168

111-
let solution = resolve(&mut caching_dependencies_provider, "root", 1u32);
169+
let solution = caching_dependencies_provider.resolve("root", 1u32);
112170
println!("Solution: {:?}", solution);
113171
}

‎examples/doc_interface.rs‎

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
// SPDX-License-Identifier: MPL-2.0
22

3-
use pubgrub::{resolve, OfflineDependencyProvider, Ranges};
3+
use pubgrub::{OfflineDependencyProvider, Ranges};
44

55
type NumVS = Ranges<u32>;
66

@@ -19,6 +19,12 @@ fn main() {
1919
dependency_provider.add_dependencies("icons", 1u32, []);
2020

2121
// Run the algorithm.
22-
let solution = resolve(&mut dependency_provider, "root", 1u32);
23-
println!("Solution: {:?}", solution);
22+
let solution = dependency_provider.resolve("root", 1u32).unwrap();
23+
println!(
24+
"Solution: {:?}",
25+
solution.iter().map(|(p, v)| {
26+
(p, dependency_provider.versions(p).unwrap().nth(v.get() as usize).unwrap())
27+
})
28+
.collect::<Vec<_>>()
29+
);
2430
}

‎examples/doc_interface_error.rs‎

Lines changed: 10 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
// SPDX-License-Identifier: MPL-2.0
22

33
use pubgrub::{
4-
resolve, DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
4+
DefaultStringReporter, OfflineDependencyProvider, PubGrubError, Ranges, Reporter,
55
SemanticVersion,
66
};
77

@@ -71,11 +71,17 @@ fn main() {
7171
dependency_provider.add_dependencies("intl", (5, 0, 0), []);
7272

7373
// Run the algorithm.
74-
match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
75-
Ok(sol) => println!("{:?}", sol),
74+
match dependency_provider.resolve("root", (1, 0, 0)) {
75+
Ok(sol) => println!(
76+
"Solution: {:?}",
77+
sol.iter().map(|(p, v)| {
78+
(p, dependency_provider.versions(p).unwrap().nth(v.get() as usize).unwrap())
79+
})
80+
.collect::<Vec<_>>()
81+
),
7682
Err(PubGrubError::NoSolution(mut error)) => {
7783
error.derivation_tree.collapse_no_versions();
78-
eprintln!("{}", DefaultStringReporter::report(&error));
84+
eprintln!("{}", DefaultStringReporter::report(&error, &dependency_provider));
7985
}
8086
Err(err) => panic!("{:?}", err),
8187
};

0 commit comments

Comments
 (0)