use crate::certificate::Certificate;
use crate::derived_artifact::{ArtifactMutation, ArtifactVerifyLimits};
use crate::derived_invariant::{
DerivedInvariantKind, InvariantReading, InvariantStop, InvariantValue,
};
use crate::gentle::WindingClass;
use super::super::{ClassificationLimits, ClassificationStatus, MutationWalk, UnresolvedPair};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct DerivedAtlasParseLimits {
pub max_input_bytes: usize,
pub max_certificate_bytes: usize,
pub max_members: usize,
pub max_entries: usize,
pub max_numeric_values: usize,
pub max_array_elements: usize,
pub max_integer_digits: usize,
}
impl Default for DerivedAtlasParseLimits {
fn default() -> Self {
DerivedAtlasParseLimits {
max_input_bytes: 67_108_864,
max_certificate_bytes: 4_194_304,
max_members: 100_000,
max_entries: 16_777_216,
max_numeric_values: 50_000_000,
max_array_elements: 50_000_000,
max_integer_digits: 39,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct DerivedAtlasVerifyLimits {
pub parse: DerivedAtlasParseLimits,
pub replay: ArtifactVerifyLimits,
pub max_hochschild_degree: u64,
pub max_tensor_tuples: u64,
pub max_cochain_dim: u64,
pub max_bar_matrix_entries: u64,
pub max_bar_work_units: u64,
pub max_member_dimension: u64,
}
impl Default for DerivedAtlasVerifyLimits {
fn default() -> Self {
DerivedAtlasVerifyLimits {
parse: DerivedAtlasParseLimits::default(),
replay: ArtifactVerifyLimits::default(),
max_hochschild_degree: 16,
max_tensor_tuples: 1_000_000,
max_cochain_dim: 1_000_000,
max_bar_matrix_entries: 100_000_000,
max_bar_work_units: 10_000_000_000,
max_member_dimension: 256,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum AtlasStop {
Overflow,
BarCut,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum AtlasReading {
Finished(Vec<i128>),
Stopped(AtlasStop),
NotApplicable,
}
impl AtlasReading {
pub fn from_reading(reading: &InvariantReading) -> Option<AtlasReading> {
Some(match reading {
InvariantReading::Finished(value) => AtlasReading::Finished(encode_value(value)),
InvariantReading::Stopped(InvariantStop::Overflow) => {
AtlasReading::Stopped(AtlasStop::Overflow)
}
InvariantReading::Stopped(InvariantStop::BarCut(_)) => {
AtlasReading::Stopped(AtlasStop::BarCut)
}
InvariantReading::Stopped(InvariantStop::Cancelled) => return None,
InvariantReading::NotApplicable(_) => AtlasReading::NotApplicable,
})
}
}
pub(super) fn encode_value(value: &InvariantValue) -> Vec<i128> {
let widen = |values: &[usize]| values.iter().map(|&v| v as i128).collect();
match value {
InvariantValue::Count(count) => vec![*count as i128],
InvariantValue::Integer(integer) => vec![*integer],
InvariantValue::Factors(values) | InvariantValue::Polynomial(values) => values.clone(),
InvariantValue::AagFunction(function) => function
.pairs()
.iter()
.flat_map(|&(n, m)| [n as i128, m as i128])
.collect(),
InvariantValue::WindingClass(class) => encode_winding(*class),
InvariantValue::Dimensions(dimensions) => widen(dimensions),
}
}
fn encode_winding(class: WindingClass) -> Vec<i128> {
match class {
WindingClass::Planar => vec![0],
WindingClass::Gcd(gcd) => vec![1, i128::from(gcd)],
WindingClass::Odd => vec![2],
WindingClass::Even => vec![3],
WindingClass::Arf(arf) => vec![4, i128::from(arf)],
}
}
pub(super) const KIND_NAMES: [&str; 10] = [
"vertex_count",
"cartan_determinant",
"cartan_factors",
"symmetric_factors",
"skew_factors",
"cartan_pencil",
"aag_function",
"winding_class",
"hochschild_dimensions",
"center_dimension",
];
pub(super) fn kind_name(kind: DerivedInvariantKind) -> &'static str {
KIND_NAMES[kind as usize]
}
pub(super) fn kind_from_name(name: &str) -> Option<DerivedInvariantKind> {
let position = KIND_NAMES.iter().position(|known| *known == name)?;
Some(DerivedInvariantKind::ALL[position])
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AtlasMerge {
pub(super) source: usize,
pub(super) member: usize,
pub(super) recipe: Vec<ArtifactMutation>,
pub(super) vertex_map: Vec<u32>,
pub(super) arrow_images: Vec<Vec<u64>>,
}
impl AtlasMerge {
accessor_methods! {
pub source() -> usize = |this| this.source;
pub member() -> usize = |this| this.member;
pub recipe() -> &[ArtifactMutation] = |this| &this.recipe;
pub vertex_map() -> &[u32] = |this| &this.vertex_map;
pub arrow_images() -> &[Vec<u64>] = |this| &this.arrow_images;
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AtlasClass {
pub(super) members: Vec<usize>,
pub(super) merges: Vec<AtlasMerge>,
}
impl AtlasClass {
accessor_methods! {
pub members() -> &[usize] = |this| &this.members;
pub merges() -> &[AtlasMerge] = |this| &this.merges;
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AtlasSeparation {
pub(super) classes: (usize, usize),
pub(super) members: (usize, usize),
pub(super) kind: DerivedInvariantKind,
pub(super) left: Vec<i128>,
pub(super) right: Vec<i128>,
}
impl AtlasSeparation {
accessor_methods! {
pub classes() -> (usize, usize) = |this| this.classes;
pub members() -> (usize, usize) = |this| this.members;
pub kind() -> DerivedInvariantKind = |this| this.kind;
pub left() -> &[i128] = |this| &this.left;
pub right() -> &[i128] = |this| &this.right;
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DerivedAtlasArtifact {
pub(super) field: u64,
pub(super) limits: ClassificationLimits,
pub(super) members: Vec<Certificate>,
pub(super) invariants: Vec<Vec<AtlasReading>>,
pub(super) classes: Vec<AtlasClass>,
pub(super) separations: Vec<AtlasSeparation>,
pub(super) unresolved: Vec<UnresolvedPair>,
pub(super) walks: Vec<MutationWalk>,
pub(super) status: ClassificationStatus,
pub(super) fingerprint: String,
}
impl DerivedAtlasArtifact {
accessor_methods! {
pub field() -> u64 = |this| this.field;
pub limits() -> &ClassificationLimits = |this| &this.limits;
pub members() -> &[Certificate] = |this| &this.members;
pub invariants() -> &[Vec<AtlasReading>] = |this| &this.invariants;
pub classes() -> &[AtlasClass] = |this| &this.classes;
pub separations() -> &[AtlasSeparation] = |this| &this.separations;
pub unresolved() -> &[UnresolvedPair] = |this| &this.unresolved;
pub walks() -> &[MutationWalk] = |this| &this.walks;
pub status() -> ClassificationStatus = |this| this.status;
pub fingerprint() -> &str = |this| &this.fingerprint;
}
}