solvecraft/crates/kernel/src/validity.rs

//! Is a body one valid solid? The kernel regression rig (`tests/kernel-cases`) asks this of every
//! result: the schema 4 record's structure and geometry (`Brep::validate`, `check_geometry`),
//! and, with the `smlib` feature, SMLib's own check of the same record.

use crate::{Body, brep_record};

/// What the validity checks found for one body. `Err` holds why a check failed.
#[derive(Clone, Debug)]
pub struct Validity {
    /// The record: structure, then geometry against topology within tolerances.
    pub record: Result<(), String>,
    /// SMLib's `check(All)` of the record; `None` in a build without SMLib.
    pub smlib: Option<SmlibCheck>,
}

/// SMLib's verdict on a body.
#[derive(Clone, Debug)]
pub enum SmlibCheck {
    Valid,
    Invalid(String),
    /// The record can't be built in SMLib yet (a geometry kind the conversion doesn't take): no
    /// verdict, and no fault of the body's.
    NotSupported(String),
}

impl Validity {
    pub fn ok(&self) -> bool {
        self.record.is_ok() && !matches!(self.smlib, Some(SmlibCheck::Invalid(_)))
    }
}

/// Runs every validity check this build has on `body`.
pub fn validity(body: &Body) -> Validity {
    let record = brep_record(body).map_err(|e| e.to_string());
    let checked = record.as_ref().map_err(Clone::clone).and_then(|r| {
        r.validate().map_err(|e| format!("structure: {e}"))?;
        r.check_geometry().map_err(|e| format!("geometry: {e}"))
    });
    Validity { record: checked, smlib: smlib_validity(body) }
}

#[cfg(feature = "smlib")]
fn smlib_validity(body: &Body) -> Option<SmlibCheck> {
    let b = match crate::smlib_body(body) {
        Ok(b) => b,
        Err(e) => {
            let e = e.to_string();
            return Some(if e.contains("not supported yet") { SmlibCheck::NotSupported(e) } else { SmlibCheck::Invalid(e) });
        }
    };
    Some(match b.check(solidcraft_smlib::CheckLevel::All) {
        Ok(r) if r.is_valid() => SmlibCheck::Valid,
        Ok(r) => SmlibCheck::Invalid(format!("SMLib check: {r}")),
        Err(e) => SmlibCheck::Invalid(format!("SMLib check: {e}")),
    })
}

#[cfg(not(feature = "smlib"))]
fn smlib_validity(_: &Body) -> Option<SmlibCheck> {
    None
}

/// Whether this build links SMLib (the `smlib` feature).
pub fn smlib_built() -> bool {
    cfg!(feature = "smlib")
}

/// The kernel booleans run on in this process: `"default"` or `"smlib"`. The regression rig
/// refuses to grade a kernel the process isn't running. The SMLib boolean switch
/// (`SOLIDCRAFT_BOOLEANS=smlib`) answers here once it lands; until then this is always
/// `"default"`.
pub fn boolean_kernel() -> &'static str {
    "default"
}