use crate::certificate::Certificate;
use crate::completion::CompletionLimits;
use crate::equivalence_edge::DerivedEquivalenceEdge;
use crate::target::{TargetLimits, TargetWork};
use crate::tilting_complex::{
ApproximationDirection, CertifiedTiltingComplex, ThickGenerationWitness, TiltingComplexLimits,
};
use super::DERIVED_ARTIFACT_SCHEMA;
use super::errors::ArtifactError;
use super::model::{ArtifactMutation, ArtifactParseLimits, DerivedArtifact};
use super::parser::RawArtifact;
impl DerivedArtifact {
pub fn from_edge(edge: &DerivedEquivalenceEdge) -> Result<DerivedArtifact, ArtifactError> {
if !edge.verify() {
return Err(ArtifactError::InvalidEdge);
}
let mut mutations = Vec::new();
collect_mutations(edge.tilting(), &mut mutations)?;
let mut artifact = DerivedArtifact {
source: edge.source().certificate().clone(),
mutations,
target: edge.target().certificate().clone(),
tilting_limits: edge.tilting().limits(),
target_limits: edge.target_presentation().limits().clone(),
work: edge.target_presentation().work(),
fingerprint: String::new(),
};
artifact.fingerprint = fingerprint(&artifact.canonical_without_fingerprint());
Ok(artifact)
}
accessor_methods! {
pub source_certificate() -> &Certificate = |this| &this.source;
pub mutations() -> &[ArtifactMutation] = |this| &this.mutations;
pub target_certificate() -> &Certificate = |this| &this.target;
pub tilting_limits() -> TiltingComplexLimits = |this| this.tilting_limits;
pub target_limits() -> &TargetLimits = |this| &this.target_limits;
pub work() -> TargetWork = |this| this.work;
pub fingerprint() -> &str = |this| &this.fingerprint;
}
pub(super) fn canonical_without_fingerprint(&self) -> String {
let mut output = String::new();
output.push_str("{\"schema\":\"");
output.push_str(DERIVED_ARTIFACT_SCHEMA);
output.push_str("\",\"source\":");
push_bytes(&mut output, self.source.to_canonical_json().as_bytes());
output.push_str(",\"mutations\":[");
for (index, mutation) in self.mutations.iter().enumerate() {
if index != 0 {
output.push(',');
}
output.push('[');
output.push(match mutation.direction {
ApproximationDirection::Left => '0',
ApproximationDirection::Right => '1',
});
output.push(',');
output.push_str(&mutation.summand.to_string());
output.push(']');
}
output.push_str("],\"target\":");
push_bytes(&mut output, self.target.to_canonical_json().as_bytes());
output.push_str(",\"limits\":[");
push_numbers(
&mut output,
&[
self.tilting_limits.max_hom_spaces,
self.target_limits.max_endo_dimension,
self.target_limits.max_radical_products,
self.target_limits.max_paths,
self.target_limits.max_relation_terms,
self.target_limits.completion.max_basis,
self.target_limits.completion.max_word_len,
self.target_limits.completion.max_steps,
self.target_limits.completion.max_origin_terms,
self.target_limits.completion.max_ambiguities,
],
);
output.push_str("],\"work\":[");
push_numbers(
&mut output,
&[
self.work.endo_dimension,
self.work.radical_products,
self.work.paths,
self.work.relation_terms,
],
);
output.push(']');
output
}
pub fn to_canonical_json(&self) -> String {
let mut output = self.canonical_without_fingerprint();
output.push_str(",\"fingerprint\":\"");
output.push_str(&self.fingerprint);
output.push_str("\"}");
output
}
pub fn from_json(
text: &str,
limits: ArtifactParseLimits,
) -> Result<DerivedArtifact, ArtifactError> {
if text.len() > limits.max_input_bytes {
return Err(ArtifactError::ParseLimit {
path: "$".to_string(),
used: text.len(),
limit: limits.max_input_bytes,
});
}
let raw = RawArtifact::parse(text, limits)?;
let source_text = String::from_utf8(raw.source).map_err(|_| ArtifactError::Syntax {
byte: 0,
message: "source certificate bytes are not UTF-8".to_string(),
})?;
let target_text = String::from_utf8(raw.target).map_err(|_| ArtifactError::Syntax {
byte: 0,
message: "target certificate bytes are not UTF-8".to_string(),
})?;
let source =
Certificate::from_json(&source_text).map_err(|error| ArtifactError::Certificate {
path: "$.source".to_string(),
message: error.to_string(),
})?;
let target =
Certificate::from_json(&target_text).map_err(|error| ArtifactError::Certificate {
path: "$.target".to_string(),
message: error.to_string(),
})?;
let tilting_limits = TiltingComplexLimits {
max_hom_spaces: raw.limits[0],
};
let target_limits = TargetLimits {
max_endo_dimension: raw.limits[1],
max_radical_products: raw.limits[2],
max_paths: raw.limits[3],
max_relation_terms: raw.limits[4],
completion: CompletionLimits {
max_basis: raw.limits[5],
max_word_len: raw.limits[6],
max_steps: raw.limits[7],
max_origin_terms: raw.limits[8],
max_ambiguities: raw.limits[9],
},
};
Ok(DerivedArtifact {
source,
mutations: raw.mutations,
target,
tilting_limits,
target_limits,
work: TargetWork {
endo_dimension: raw.work[0],
radical_products: raw.work[1],
paths: raw.work[2],
relation_terms: raw.work[3],
},
fingerprint: raw.fingerprint,
})
}
pub fn has_valid_fingerprint(&self) -> bool {
self.fingerprint == fingerprint(&self.canonical_without_fingerprint())
}
}
fn collect_mutations(
tilting: &CertifiedTiltingComplex,
output: &mut Vec<ArtifactMutation>,
) -> Result<(), ArtifactError> {
match tilting.generation() {
ThickGenerationWitness::Regular => Ok(()),
ThickGenerationWitness::Mutation {
parent,
approximation,
} => {
collect_mutations(parent, output)?;
output.push(ArtifactMutation {
direction: approximation.direction(),
summand: approximation.replaced(),
});
Ok(())
}
}
}
fn push_bytes(output: &mut String, bytes: &[u8]) {
output.push('[');
for (index, byte) in bytes.iter().enumerate() {
if index != 0 {
output.push(',');
}
output.push_str(&byte.to_string());
}
output.push(']');
}
fn push_numbers(output: &mut String, values: &[usize]) {
for (index, value) in values.iter().enumerate() {
if index != 0 {
output.push(',');
}
output.push_str(&value.to_string());
}
}
pub(super) fn fingerprint(text: &str) -> String {
let mut value = 0xcbf29ce484222325u64;
for byte in text.bytes() {
value ^= u64::from(byte);
value = value.wrapping_mul(0x100000001b3);
}
format!("{value:016x}")
}