resolvo 0.11.1

Fast package resolver written in Rust (CDCL based SAT solving)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Public ID types used by dependency providers, snapshots, and diagnostics.

use std::num::{NonZero, NonZeroU32};

use crate::solver_id::DenseId;

/// A dense zero-based ID that can be transformed to and from a `usize` index.
///
/// This is primarily used by dense storage such as [`crate::Mapping`] and the
/// default pool-backed IDs. Sparse provider IDs should implement
/// [`crate::SolverId`] without implementing this trait.
pub trait DenseIndex {
    /// Constructs a new ID from a zero-based index.
    fn from_index(x: usize) -> Self;

    /// Returns the zero-based index of the ID.
    fn to_index(self) -> usize;
}

/// The id associated to a package name.
pub type NameId = DenseId<NameTag>;

/// Domain tag for [`NameId`].
pub enum NameTag {}

/// The id associated with a generic string.
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct StringId(pub u32);

impl DenseIndex for StringId {
    fn from_index(x: usize) -> Self {
        Self(x as u32)
    }

    fn to_index(self) -> usize {
        self.0 as usize
    }
}

/// The id associated with a version set.
#[repr(transparent)]
#[derive(Clone, Default, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct VersionSetId(pub u32);

impl DenseIndex for VersionSetId {
    fn from_index(x: usize) -> Self {
        Self(x as u32)
    }

    fn to_index(self) -> usize {
        self.0 as usize
    }
}

/// The id associated with a condition.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct ConditionId(NonZero<u32>);

impl ConditionId {
    /// Creates a new [`ConditionId`] from a `u32`.
    pub fn new(id: u32) -> Self {
        Self::from_index(id as usize)
    }

    /// Returns the inner `u32` value of the [`ConditionId`].
    pub fn as_u32(self) -> u32 {
        self.0.get() - 1
    }
}

impl DenseIndex for ConditionId {
    fn from_index(x: usize) -> Self {
        let id = (x + 1).try_into().expect("condition id too big");
        Self(unsafe { NonZero::new_unchecked(id) })
    }

    fn to_index(self) -> usize {
        (self.0.get() - 1) as usize
    }
}

/// The id associated with a union (logical OR) of two or more version sets.
#[repr(transparent)]
#[derive(Clone, Default, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct VersionSetUnionId(pub u32);

impl DenseIndex for VersionSetUnionId {
    fn from_index(x: usize) -> Self {
        Self(x as u32)
    }

    fn to_index(self) -> usize {
        self.0 as usize
    }
}

/// The id associated to a solvable.
pub type SolvableId = DenseId<SolvableTag>;

/// Domain tag for [`SolvableId`].
pub enum SolvableTag {}

/// A unique identifier for a variable in the solver.
///
/// Uses a non-zero representation so that `Option<VariableId>` is the same
/// size as `VariableId`.
#[repr(transparent)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
pub struct VariableId(NonZeroU32);

impl VariableId {
    const ROOT_ID: u32 = 1;

    /// Returns the variable id representing the root of the decision tree.
    pub fn root() -> Self {
        // SAFETY: 1 is non-zero.
        Self(unsafe { NonZeroU32::new_unchecked(Self::ROOT_ID) })
    }

    /// Returns `true` if this variable represents the root.
    pub fn is_root(self) -> bool {
        self.0.get() == Self::ROOT_ID
    }
}

impl DenseIndex for VariableId {
    #[inline]
    fn from_index(x: usize) -> Self {
        let raw: u32 = (x + Self::ROOT_ID as usize)
            .try_into()
            .expect("variable id too big");
        // SAFETY: `raw` is `x + 1`, hence at least 1, hence non-zero.
        Self(unsafe { NonZeroU32::new_unchecked(raw) })
    }

    #[inline]
    fn to_index(self) -> usize {
        (self.0.get() - Self::ROOT_ID) as usize
    }
}