mod accept;
mod closure;
mod compatibility;
mod entry;
mod error;
mod lifecycle;
mod parse;
mod replacement;
mod retirement;
#[cfg(test)]
mod test_support;
mod wire;
mod write;
use std::{collections::BTreeMap, io::Write};
use serde::{Deserialize, Serialize};
use super::CatalogArtifact;
pub use accept::AcceptanceMode;
pub use compatibility::{CompatibilityChange, CompatibilityReport, CompatibilitySeverity};
pub use entry::{LockEntry, LockState};
pub use error::{
AcceptanceError, LockParseError, LockWriteError, ReservationError, RetirementError,
};
pub use lifecycle::Reservation;
pub use retirement::MAX_RETIREMENT_REASON_CHARS;
pub const MAX_CATALOG_LOCK_BYTES: usize = 16 * 1024 * 1024;
pub const MAX_CATALOG_LOCK_ENTRIES: usize = 32_768;
const CURRENT_SCHEMA_VERSION: u32 = 2;
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct CatalogLock {
schema_version: u32,
catalog: LockIdentity,
entries: Vec<LockEntry>,
problem_sets: BTreeMap<String, Vec<super::Code>>,
}
impl CatalogLock {
pub fn from_artifact(artifact: &CatalogArtifact) -> Self {
Self {
schema_version: CURRENT_SCHEMA_VERSION,
catalog: LockIdentity::from_artifact(artifact),
entries: artifact
.diagnostics()
.iter()
.cloned()
.map(LockEntry::active)
.collect(),
problem_sets: artifact.problem_sets().clone(),
}
}
pub fn from_slice(body: &[u8]) -> Result<Self, LockParseError> {
parse::parse_lock(body)
}
pub const fn schema_version(&self) -> u32 {
self.schema_version
}
pub fn name(&self) -> &str {
&self.catalog.name
}
pub fn prefix(&self) -> &str {
&self.catalog.prefix
}
pub fn type_base(&self) -> &str {
&self.catalog.type_base
}
pub fn entries(&self) -> &[LockEntry] {
&self.entries
}
pub const fn problem_sets(&self) -> &BTreeMap<String, Vec<super::Code>> {
&self.problem_sets
}
pub fn write_pretty<W: Write>(&self, writer: W) -> Result<(), LockWriteError> {
write::write_pretty(self, writer)
}
pub fn reserve(&mut self, reservation: Reservation) -> Result<&LockEntry, ReservationError> {
lifecycle::reserve(self, reservation)
}
pub fn check(&self, current: &CatalogArtifact) -> CompatibilityReport {
compatibility::check(self, current)
}
pub fn accept(
&mut self,
current: &CatalogArtifact,
mode: AcceptanceMode,
) -> Result<CompatibilityReport, AcceptanceError> {
accept::accept(self, current, mode)
}
pub fn retire(
&mut self,
code: &super::Code,
reason: impl Into<String>,
replacement: Option<super::Code>,
) -> Result<&LockEntry, RetirementError> {
accept::retire(self, code, reason.into(), replacement)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct LockIdentity {
pub(crate) name: String,
pub(crate) prefix: String,
pub(crate) type_base: String,
}
impl LockIdentity {
fn from_artifact(artifact: &CatalogArtifact) -> Self {
Self {
name: artifact.name().to_owned(),
prefix: artifact.prefix().to_owned(),
type_base: artifact.type_base().to_owned(),
}
}
}