diff --git a/crates/kernel/src/blend.rs b/crates/kernel/src/blend.rs
index 46cdeaf9d..ac134b452 100644
--- a/crates/kernel/src/blend.rs
+++ b/crates/kernel/src/blend.rs
@@ -502,7 +502,9 @@ fn largest_that_fits(size: f64, blend: impl Fn(f64) -> Result
) -> Result {
lo = mid;
best = Some(b);
diff --git a/crates/kernel/src/blend_smlib.rs b/crates/kernel/src/blend_smlib.rs
index 757b6ff81..39229c613 100644
--- a/crates/kernel/src/blend_smlib.rs
+++ b/crates/kernel/src/blend_smlib.rs
@@ -357,12 +357,20 @@ mod imp {
SmError::NoRoom => KernelError::TooLarge(format!("the {what} is larger than the faces beside its edges allow")),
e => failed(what, "operation", e),
})?;
- let check = r.check(CheckLevel::All).map_err(|e| failed(what, "check", e))?;
- if !check.is_valid() {
- let input_fails = sb.check(CheckLevel::All).is_ok_and(|c| !c.is_valid());
- let step =
- if input_fails { "SMLib's check refuses the result (the input already fails it)" } else { "SMLib's check refuses the result" };
- return Err(failed(what, step, check));
+ // Checked here unless the evaluation's validation mode leaves it to the feature's end
+ // (`crate::validation`).
+ let step = crate::validation::step();
+ if step == crate::validation::Step::Check {
+ let check = r.check(CheckLevel::All).map_err(|e| failed(what, "check", e))?;
+ if !check.is_valid() {
+ let input_fails = sb.check(CheckLevel::All).is_ok_and(|c| !c.is_valid());
+ let step = if input_fails {
+ "SMLib's check refuses the result (the input already fails it)"
+ } else {
+ "SMLib's check refuses the result"
+ };
+ return Err(failed(what, step, check));
+ }
}
let (out, result_order) = body_from_smlib_ordered(&r)?;
let history = match (order, &result_order) {
@@ -380,7 +388,13 @@ mod imp {
},
_ => None,
};
- Ok((out.with_checked_history(history, &record::counts(&[body])).inherit_regularization_protection(body), extra, result_order))
+ let out = out.with_checked_history(history, &record::counts(&[body])).inherit_regularization_protection(body);
+ let out = if step == crate::validation::Step::Defer {
+ out.left_unchecked(&format!("SMLib {what}"), crate::validation::Checked::AsIs, r)
+ } else {
+ out
+ };
+ Ok((out, extra, result_order))
})
}
diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rs
index f781ab85a..74bfcbd73 100644
--- a/crates/kernel/src/body.rs
+++ b/crates/kernel/src/body.rs
@@ -55,6 +55,10 @@ pub struct Body {
/// Meshes of this record kept for reuse, set by [`Body::keeping_meshes`]: a check that
/// intersects one large body with many small ones meshes it at the same tolerance each time.
pub(crate) meshes: Option>,
+ /// The SMLib result this body was decoded from, when the step that made it left SMLib's
+ /// check to the end of its feature ([`crate::validation`]): checked there as the step's own
+ /// check would have, then let go. Answers only for this record.
+ pub(crate) unchecked: Option>,
}
/// The meshes made of one record (see [`Body::keeping_meshes`]), by tolerance and angle. They
@@ -473,9 +477,17 @@ impl Body {
history: None,
display_of: None,
meshes: None,
+ unchecked: None,
}
}
+ /// This body with `result`, the SMLib result of the step `what` it was decoded from, whose
+ /// check that step left to the end of its feature ([`crate::validation::check_kept`]).
+ pub(crate) fn left_unchecked(self, what: &str, how: crate::validation::Checked, result: solidcraft_smlib::Brep) -> Body {
+ let unchecked = crate::validation::Unchecked::new(&self.record, what, how, result);
+ Body { unchecked: Some(std::sync::Arc::new(unchecked)), ..self }
+ }
+
/// The body of a schema 4 record (a solid, or a surface body of open shells): checked for
/// structure (references, loops, regions, canonical order; a record from a file is checked
/// against the file budgets where it is read). Its faces face as the
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 086e23979..e5a4bf18d 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -151,6 +151,7 @@ mod topo;
mod tspline;
#[cfg(test)]
mod untouched_faces_tests;
+mod validation;
mod validity;
pub mod watch;
@@ -232,6 +233,7 @@ pub use sweep_path::{RailFit, SweepControl, SweepOrientation, sweep_path, sweep_
pub use topo::{CylinderFace, cylinder_end_at, cylinder_face, cylinder_face_at, material_in_ring};
pub use topo::{TopoCounts, merged_topology, seam_flags};
pub use tspline::tspline_sheet;
+pub use validation::{Validation, check_kept, validating};
pub use validity::{SmlibCheck, Validity, smlib_built, smlib_dump_dir, validity};
#[derive(Debug, Clone, PartialEq, thiserror::Error)]
diff --git a/crates/kernel/src/par.rs b/crates/kernel/src/par.rs
index b18ea88bb..00aa24a6e 100644
--- a/crates/kernel/src/par.rs
+++ b/crates/kernel/src/par.rs
@@ -8,7 +8,9 @@ use crate::{Result, guard};
/// thread. Waking the pool's workers costs tens of microseconds, so callers ask for it only
/// when the items carry more work than that (decided from the work, not the item count).
pub(crate) fn map(what: &'static str, items: &[T], parallel: bool, f: impl Fn(&T) -> Result + Sync) -> Vec> {
- let one = |item: &T| guard(what, || f(item));
+ // The workers run under the caller's validation mode (`crate::validation`).
+ let scope = crate::validation::current();
+ let one = |item: &T| crate::validation::within(scope.clone(), || guard(what, || f(item)));
// The browser build has no worker pool: everything runs on the calling thread.
#[cfg(target_arch = "wasm32")]
let _ = parallel;
@@ -53,7 +55,8 @@ pub fn map_with_local_pools(items: &[T], max_threads: usize, f
let _ = cell.set(pool);
}
let pool = cell.get().ok_or_else(|| crate::KernelError::Failed("missing mesh worker".into()))?;
- pool.install(|| guard("mesh worker", || f(item)))
+ let scope = crate::validation::current();
+ pool.install(|| crate::validation::within(scope, || guard("mesh worker", || f(item))))
})
};
#[cfg(target_arch = "wasm32")]
@@ -67,7 +70,9 @@ pub fn map_with_local_pools(items: &[T], max_threads: usize, f
/// `f` over `items` as [`for_each_on_threads`] runs it, results in item order (`None` where an
/// item panicked).
pub fn map_on_threads(items: &[T], max_threads: usize, f: impl Fn(&T) -> R + Sync) -> Vec> {
- let one = |item: &T| guard("parallel item", || Ok(f(item))).ok();
+ // The threads run under the caller's validation mode (`crate::validation`).
+ let scope = crate::validation::current();
+ let one = |item: &T| crate::validation::within(scope.clone(), || guard("parallel item", || Ok(f(item))).ok());
#[cfg(not(target_arch = "wasm32"))]
{
use std::sync::atomic::{AtomicUsize, Ordering};
diff --git a/crates/kernel/src/smlib_boolean.rs b/crates/kernel/src/smlib_boolean.rs
index 87f41d0d3..df079532e 100644
--- a/crates/kernel/src/smlib_boolean.rs
+++ b/crates/kernel/src/smlib_boolean.rs
@@ -13,6 +13,7 @@ mod smlib {
use crate::history::History;
use crate::native::{body_from_smlib_ordered, smlib_body_ordered};
use crate::ops::BoolOp;
+ use crate::validation::{Checked, Step};
use crate::{KernelError, Result, record};
fn failed(what: &str, e: impl std::fmt::Display) -> KernelError {
@@ -34,7 +35,7 @@ mod smlib {
BoolOp::Intersect => BooleanOp::Intersect,
};
let Some(r) = ta.boolean(&tb, kind).map_err(|e| failed("operation", e))? else { return Ok(None) };
- checked(&r, &[&sa, &sb])?;
+ let step = checked(&r, &[&sa, &sb])?;
let (body, or) = body_from_smlib_ordered(&r)?;
let history = match (oa, ob, or) {
(Some(oa), Some(ob), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&[oa, ob], &or).map(Some).unwrap_or_else(|e| {
@@ -43,7 +44,7 @@ mod smlib {
}),
_ => None,
};
- Ok(Some(with_history(body, history, a, b)))
+ Ok(Some(left(with_history(body, history, a, b), step, r)))
}
/// The union of `bodies` in one SMLib call, each tagged as its own operand, checked once:
@@ -68,7 +69,7 @@ mod smlib {
let refs: Vec<&solidcraft_smlib::Brep> = tagged.iter().collect();
let r = solidcraft_smlib::Brep::union_all(&refs).map_err(|e| failed("operation", e))?;
let operand_refs: Vec<&solidcraft_smlib::Brep> = operands.iter().collect();
- checked(&r, &operand_refs)?;
+ let step = checked(&r, &operand_refs)?;
let (body, or) = body_from_smlib_ordered(&r)?;
let history = match (orders, or) {
(Some(orders), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&orders, &or).map(Some).unwrap_or_else(|e| {
@@ -77,25 +78,30 @@ mod smlib {
}),
_ => None,
};
- Ok(body.with_checked_history(history, &record::counts(bodies)))
+ Ok(left(body.with_checked_history(history, &record::counts(bodies)), step, r))
}
- /// An error unless SMLib's check accepts `r`, the result of combining `operands`.
- fn checked(r: &solidcraft_smlib::Brep, operands: &[&solidcraft_smlib::Brep]) -> Result<()> {
+ /// `body`, decoded from `r`, keeping `r` for the check at the end of its feature when the
+ /// step left it there.
+ fn left(body: Body, step: Step, r: solidcraft_smlib::Brep) -> Body {
+ if step == Step::Defer { body.left_unchecked("SMLib boolean", Checked::Combined, r) } else { body }
+ }
+
+ /// An error unless SMLib's check accepts `r`, the result of combining `operands` (checked
+ /// here unless the evaluation's validation mode leaves it to the feature's end,
+ /// `crate::validation`): what was done with the check.
+ fn checked(r: &solidcraft_smlib::Brep, operands: &[&solidcraft_smlib::Brep]) -> Result {
+ let step = crate::validation::step();
+ if step != Step::Check {
+ return Ok(step);
+ }
// Solids touching each other along an edge or at a vertex come back as one non-manifold
// body, which the export splits into separate solids: SMLib's check is of those, imported
// as given (its check of the touching arrangement itself refuses the radial order of
// faces round an edge they share).
- let manifold = r.is_manifold_solid().map_err(|e| failed("check", e))?;
- let check = if manifold {
- r.check(CheckLevel::All).map_err(|e| failed("check", e))?
- } else {
- let record = r.to_native().map_err(|e| failed("export", e))?;
- let split = solidcraft_smlib::Brep::from_record(&record, true).map_err(|e| failed("the separate solids", e))?;
- split.check(CheckLevel::All).map_err(|e| failed("check", e))?
- };
+ let check = crate::validation::check_result(r, Checked::Combined).map_err(|e| KernelError::Failed(format!("SMLib boolean: {e}")))?;
if check.is_valid() {
- return Ok(());
+ return Ok(step);
}
// Whether an operand failed it already says whose the fault is.
let failing: Vec = operands
diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rs
index cbaf1e922..bf27ffd44 100644
--- a/crates/kernel/src/smlib_sweeps.rs
+++ b/crates/kernel/src/smlib_sweeps.rs
@@ -155,20 +155,26 @@ mod imp {
segs.iter().map(|s| curve(plane, s)).collect()
}
- /// The kernel body of an SMLib result SMLib's own check finds valid.
- fn body_of(brep: &Brep, what: &str) -> Result {
- let check = brep.check(CheckLevel::All).map_err(|e| failed(what, e))?;
- if !check.is_valid() {
- return Err(failed(what, format!("SMLib's check refuses the result: {check}")));
+ /// The kernel body of an SMLib result SMLib's own check finds valid (checked here unless the
+ /// evaluation's validation mode leaves it to the feature's end, `crate::validation`).
+ fn body_of(brep: Brep, what: &str) -> Result {
+ use crate::validation::{Checked, Step};
+ let step = crate::validation::step();
+ if step == Step::Check {
+ let check = brep.check(CheckLevel::All).map_err(|e| failed(what, e))?;
+ if !check.is_valid() {
+ return Err(failed(what, format!("SMLib's check refuses the result: {check}")));
+ }
}
- crate::native::body_from_smlib(brep)
+ let body = crate::native::body_from_smlib(&brep)?;
+ Ok(if step == Step::Defer { body.left_unchecked(&format!("SMLib {what}"), Checked::AsIs, brep) } else { body })
}
/// The body (a solid or a sheet) a schema 4 record describes, taken by SMLib as a
/// modeller's own record (no healing) and checked there.
pub(crate) fn body_from_record(record: &solidcraft_geom::brep::Brep, what: &str) -> Result {
let brep = Brep::from_record(record, true).map_err(|e| failed(what, e))?;
- body_of(&brep, what)
+ body_of(brep, what)
}
/// The sketch segments `segs` on `plane` projected along `direction` onto the face of
@@ -236,7 +242,7 @@ mod imp {
/// a sphere revolves.
pub(crate) fn sphere(center: Vec3, radius: f64) -> Result {
let brep = Brep::make_sphere(p(center), radius).map_err(|e| failed("sphere", e))?;
- let body = body_of(&brep, "sphere")?;
+ let body = body_of(brep, "sphere")?;
let faces = body.face_count();
Ok(record::attach(body, &[], Some(vec![record::profile(&[0usize]); faces]), &[]))
}
@@ -415,7 +421,7 @@ mod imp {
Brep::extrude(&curves(&knee, pieces)?, p(dir), distance - foot, lean, corner(d.corner), true).map_err(|e| failed("extrude", e))?;
let brep = prism.boolean(&slope, solidcraft_smlib::BooleanOp::Union).map_err(|e| failed("extrude", e))?;
let brep = brep.ok_or_else(|| failed("extrude", "nothing is left"))?;
- let body = body_of(&brep, "extrude")?;
+ let body = body_of(brep, "extrude")?;
// The caps and the foot's walls from the base; the sloping walls (and the foot's again)
// from the edges at the knee, which both stand on.
let low = roles(&body, &base, Some(&top), &edges, &[], false)?;
@@ -438,7 +444,7 @@ mod imp {
let lean = draft.map_or(0.0, |d| -d.taper);
let rule = draft.map_or(DraftCorner::default(), |d| corner(d.corner));
let brep = Brep::extrude(&c, p(dir), distance, lean, rule, true).map_err(|e| failed("extrude", e))?;
- let body = body_of(&brep, "extrude")?;
+ let body = body_of(brep, "extrude")?;
// Half-way along a straight wall lies over its segment; a drafted one has moved.
let inside = if draft.is_none() { seeds(&base, pieces, |q| q + dir * (distance * 0.5)) } else { Vec::new() };
let roles = roles(&body, &base, Some(&top), &edges, &inside, false)?;
@@ -495,7 +501,7 @@ mod imp {
.map_err(|e| failed("extrude", e))?
.ok_or_else(|| KernelError::Invalid("the draft leaves nothing of the profile".into()))?;
}
- let body = body_of(&brep, "extrude")?;
+ let body = body_of(brep, "extrude")?;
let base = plane.offset(from);
let top = plane.offset(from + sign.signum() * distance);
let low = roles(&body, &base, Some(&top), &seeds(&base, all, |q| q), &[], false)?;
@@ -574,7 +580,7 @@ mod imp {
let turn = turn.min(std::f64::consts::TAU);
let c = curves(plane, pieces)?;
let brep = Brep::revolve(&c, p(origin), p(k), turn, true).map_err(|e| failed("revolve", e))?;
- let body = body_of(&brep, "revolve")?;
+ let body = body_of(brep, "revolve")?;
let size = body.size().max(1e-9);
let off_axis = |q: Vec3| {
let w = q - origin;
@@ -639,7 +645,7 @@ mod imp {
return cornered(plane, pieces, path, &runs, translate);
}
let (brep, [_, middle, last]) = swept(plane, pieces, path, translate)?;
- let body = body_of(&brep, "sweep")?;
+ let body = body_of(brep, "sweep")?;
// The walls known by the profile carried half way (past the start's edges: a wall the
// start touches by no edge, as round a closed path, and walls along later path segments).
let inside = seeds(plane, pieces, |q| apply(&middle, q));
@@ -852,7 +858,7 @@ mod imp {
}
}
let brep = body.ok_or_else(|| KernelError::Invalid("empty path".into()))?;
- let body = body_of(&brep, "sweep")?;
+ let body = body_of(brep, "sweep")?;
let roles = roles(&body, plane, (!closed).then_some(&pose), &seeds(plane, pieces, |q| q), &inside, false)?;
with_history(body, &roles, pieces)
}
@@ -1015,7 +1021,7 @@ mod imp {
})
.collect();
let brep = Brep::sweep_stations(&c, &maps, if closed { Ends::Joined } else { Ends::Capped }).map_err(|e| failed("sweep", e))?;
- let body = body_of(&brep, "sweep")?;
+ let body = body_of(brep, "sweep")?;
let mid = st.get(st.len() / 2).copied().unwrap_or(*last);
let inside = seeds(plane, &pieces, |q| mid.at + mid.apply(q - s0));
let roles = if closed {
@@ -1227,7 +1233,7 @@ mod imp {
crate::sweep_path::closing_offset(plane, l, &[to_station(&IDENTITY), to_station(&at_start)])?;
}
}
- let body = body_of(&brep, "sweep")?;
+ let body = body_of(brep, "sweep")?;
let roles = if closed {
roles(&body, &plane.offset(size * 10.0), None, &[], &inside, false)?
} else {
@@ -1382,7 +1388,7 @@ mod imp {
/// across them; `sections` and `first` as [`loft`] takes them name the faces.
fn loft_through(sections: &[(Plane, Vec)], first: usize, curves: &[Vec], degree: u32) -> Result {
let brep = Brep::loft(curves, degree, true).map_err(|e| failed("loft", e))?;
- let body = body_of(&brep, "loft")?;
+ let body = body_of(brep, "loft")?;
let (Some((start, lead)), Some(last)) = (sections.get(first), sections.get(if first == 0 { sections.len().saturating_sub(1) } else { 0 }))
else {
return Err(KernelError::Invalid("loft sections".into()));
@@ -1442,7 +1448,7 @@ mod imp {
pub(crate) fn loft_to_point(plane: &Plane, pieces: &[Piece], apex: Vec3) -> Result {
let c = curves(plane, pieces)?;
let brep = Brep::loft_to_point(&c, p(apex)).map_err(|e| failed("loft to a point", e))?;
- let body = body_of(&brep, "loft to a point")?;
+ let body = body_of(brep, "loft to a point")?;
let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], false)?;
with_history(body, &roles, pieces)
}
@@ -1454,7 +1460,7 @@ mod imp {
// Walls within a ten-thousandth of the pitch of the true screw surfaces.
let tolerance = (pitch.abs() * 1e-4).clamp(1e-6, 1e-2);
let brep = Brep::screw_sweep(&c, p(origin), p(axis), pitch, turns, tolerance).map_err(|e| failed("screw sweep", e))?;
- let body = body_of(&brep, "screw sweep")?;
+ let body = body_of(brep, "screw sweep")?;
let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], true)?;
with_history(body, &roles, pieces)
}
@@ -1474,7 +1480,7 @@ mod imp {
let tolerance = (pitch.abs() * 1e-4).clamp(1e-6, 1e-2);
let brep =
Brep::screw_sweep_radial(&c, p(origin), p(axis), pitch, turns, law, tolerance).map_err(|e| failed("screw sweep with a radial law", e))?;
- let body = body_of(&brep, "screw sweep")?;
+ let body = body_of(brep, "screw sweep")?;
let roles = roles(&body, plane, None, &seeds(plane, pieces, |q| q), &[], true)?;
with_history(body, &roles, pieces)
}
diff --git a/crates/kernel/src/validation.rs b/crates/kernel/src/validation.rs
new file mode 100644
index 000000000..4ebfbf108
--- /dev/null
+++ b/crates/kernel/src/validation.rs
@@ -0,0 +1,261 @@
+//! How often SMLib's full check runs while a model is evaluated. Every sweep, boolean and blend
+//! checks its result in SMLib before it is decoded ([`Validation::EachStep`]); an evaluation can
+//! instead leave those checks to one check of the bodies each feature keeps
+//! ([`Validation::EachFeature`]), or skip them ([`Validation::Off`]). A body kept straight from
+//! a step is checked at the end as that step would have checked it, on the step's own result
+//! (kept with the body until then): the record a result is decoded to can pass SMLib's check
+//! where the result itself fails it (a surface of revolution's polar curve, rebuilt on import).
+//!
+//! The evaluation installs its mode around a feature with [`validating`], as [`crate::watch`]
+//! installs a watch: the operations a feature runs are reached through hundreds of public kernel
+//! functions, and the mode is the evaluation's, not each operation's. Outside [`validating`]
+//! (the kernel called directly, a preview, a test) every step is checked, as it always was. The
+//! worker threads the kernel starts for a step run under the same mode ([`crate::par`]).
+
+use std::cell::RefCell;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use serde::{Deserialize, Serialize};
+
+use crate::body::Body;
+use crate::{KernelError, Result};
+
+/// When SMLib's full check of a result runs during a model evaluation.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Validation {
+ /// After every sweep, boolean and blend: a step whose result fails the check fails the
+ /// feature there (how every evaluation checked before the mode existed).
+ EachStep,
+ /// Once per feature: the steps inside a feature are not checked, and each body the feature
+ /// makes or changes is checked before it is kept, so a feature that makes a body the check
+ /// refuses still fails, with the check's reason.
+ #[default]
+ EachFeature,
+ /// Never (experimental): a body the check would refuse is kept.
+ Off,
+}
+
+impl Validation {
+ pub const ALL: [Validation; 3] = [Validation::EachStep, Validation::EachFeature, Validation::Off];
+
+ /// The mode's name: `each_step`, `each_feature` or `off` (as it is saved and sent).
+ pub fn id(self) -> &'static str {
+ match self {
+ Validation::EachStep => "each_step",
+ Validation::EachFeature => "each_feature",
+ Validation::Off => "off",
+ }
+ }
+
+ /// The mode named `id` ([`Validation::id`]), `None` for anything else.
+ pub fn parse(id: &str) -> Option {
+ Validation::ALL.into_iter().find(|v| v.id() == id)
+ }
+}
+
+/// One feature's work under a mode, shared with the worker threads it starts.
+#[derive(Debug)]
+pub(crate) struct Scope {
+ mode: Validation,
+ /// A step's check was left for the end of the feature ([`Validation::EachFeature`]).
+ deferred: AtomicBool,
+}
+
+thread_local! {
+ static CURRENT: RefCell>> = const { RefCell::new(None) };
+}
+
+/// Run `f` with `mode` deciding which checks the kernel work it does on this thread runs. Also
+/// gives whether a step's check was left for later under [`Validation::EachFeature`]: the
+/// caller then checks the bodies it keeps ([`check_kept`]).
+pub fn validating(mode: Validation, f: impl FnOnce() -> R) -> (R, bool) {
+ let scope = Arc::new(Scope { mode, deferred: AtomicBool::new(false) });
+ let r = within(Some(scope.clone()), f);
+ (r, scope.deferred.load(Ordering::Relaxed))
+}
+
+/// The scope this thread's work runs in, to hand to the worker threads it starts.
+pub(crate) fn current() -> Option> {
+ CURRENT.with(|c| c.borrow().clone())
+}
+
+/// Run `f` in `scope` (one [`current`] gave on another thread), restoring this thread's own
+/// afterwards, also when `f` panics.
+pub(crate) fn within(scope: Option>, f: impl FnOnce() -> R) -> R {
+ struct Restore(Option>>);
+ impl Drop for Restore {
+ fn drop(&mut self) {
+ if let Some(previous) = self.0.take() {
+ CURRENT.with(|c| *c.borrow_mut() = previous);
+ }
+ }
+ }
+ let previous = CURRENT.with(|c| c.replace(scope));
+ let _restore = Restore(Some(previous));
+ f()
+}
+
+/// What a step does with SMLib's check of its result ([`step`]).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Step {
+ /// Check it now (outside [`validating`], and under [`Validation::EachStep`]).
+ Check,
+ /// Leave it to the end of the feature (under [`Validation::EachFeature`]): the body decoded
+ /// from the result keeps it ([`Body::left_unchecked`]) for [`check_kept`].
+ Defer,
+ /// Never check it (under [`Validation::Off`]).
+ Skip,
+}
+
+/// What the step about to check its result does. [`Step::Defer`] also tells the feature a check
+/// was left for its end.
+pub(crate) fn step() -> Step {
+ CURRENT.with(|c| match c.borrow().as_deref() {
+ None | Some(Scope { mode: Validation::EachStep, .. }) => Step::Check,
+ Some(s @ Scope { mode: Validation::EachFeature, .. }) => {
+ s.deferred.store(true, Ordering::Relaxed);
+ Step::Defer
+ }
+ Some(Scope { mode: Validation::Off, .. }) => Step::Skip,
+ })
+}
+
+/// How a step's own check takes its result.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Checked {
+ /// As it is.
+ AsIs,
+ /// A boolean's: solids touching each other along an edge or at a vertex come back as one
+ /// non-manifold body, checked as the separate solids its export holds (the boolean's rule).
+ Combined,
+}
+
+/// A step's SMLib result whose check was left to the end of its feature: kept with the body
+/// decoded from it (and only for that body's record) until [`check_kept`] takes it, so the check
+/// at the end is the step's own, of the result the step made.
+#[derive(Debug)]
+pub(crate) struct Unchecked {
+ record: std::sync::Weak,
+ /// The step, as its own refusal names it (`SMLib fillet`).
+ what: String,
+ how: Checked,
+ result: std::sync::Mutex>,
+}
+
+impl Unchecked {
+ pub(crate) fn new(record: &Arc, what: &str, how: Checked, result: solidcraft_smlib::Brep) -> Unchecked {
+ Unchecked { record: Arc::downgrade(record), what: what.to_string(), how, result: std::sync::Mutex::new(Some(result)) }
+ }
+
+ /// The step's result, taken (once), when this is `record`'s.
+ fn take(&self, record: &Arc) -> Option {
+ if !std::ptr::eq(self.record.as_ptr(), Arc::as_ptr(record)) {
+ return None;
+ }
+ self.result.lock().ok().and_then(|mut r| r.take())
+ }
+}
+
+/// SMLib's full check of `r` as a step takes it (`how`): the check's report.
+pub(crate) fn check_result(r: &solidcraft_smlib::Brep, how: Checked) -> std::result::Result {
+ fn failed(what: &'static str) -> impl Fn(&dyn std::fmt::Display) -> String {
+ move |e| format!("{what}: {e}")
+ }
+ match how {
+ Checked::Combined if !r.is_manifold_solid().map_err(|e| failed("check")(&e))? => {
+ let record = r.to_native().map_err(|e| failed("export")(&e))?;
+ let split = solidcraft_smlib::Brep::from_record(&record, true).map_err(|e| failed("the separate solids")(&e))?;
+ split.check(solidcraft_smlib::CheckLevel::All).map_err(|e| failed("check")(&e))
+ }
+ _ => r.check(solidcraft_smlib::CheckLevel::All).map_err(|e| failed("check")(&e)),
+ }
+}
+
+/// SMLib's full check of a body a feature keeps, once a step of the feature left its check to
+/// the end: an error with the check's reason unless it passes. A body decoded from a step's
+/// result is checked as that step would have checked it, on its result; any other (a copy moved
+/// into place, pieces joined without an operation) as SMLib takes it for the operations after it.
+/// A mesh body has nothing to check.
+pub fn check_kept(body: &Body) -> Result<()> {
+ if body.is_mesh() {
+ return Ok(());
+ }
+ let step = body.unchecked.as_deref().and_then(|u| u.take(&body.record).map(|r| (u, r)));
+ let (what, check) = match &step {
+ Some((u, r)) => (u.what.as_str(), check_result(r, u.how)),
+ None => ("SMLib", body.smlib()?.check(solidcraft_smlib::CheckLevel::All).map_err(|e| format!("check: {e}"))),
+ };
+ match check {
+ Ok(c) if c.is_valid() => Ok(()),
+ Ok(c) => Err(KernelError::Failed(format!("{what}: SMLib's check refuses the result: {c}"))),
+ Err(e) => Err(KernelError::Failed(format!("{what}: {e}"))),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn a_step_is_checked_outside_an_evaluation_and_under_each_step() {
+ assert_eq!(step(), Step::Check);
+ assert_eq!(validating(Validation::EachStep, step), (Step::Check, false));
+ assert_eq!(validating(Validation::EachFeature, step), (Step::Defer, true));
+ assert_eq!(validating(Validation::Off, step), (Step::Skip, false));
+ // The thread's own mode comes back, also after a nested scope.
+ let ((inner, outer), deferred) = validating(Validation::Off, || (validating(Validation::EachStep, step).0, step()));
+ assert!(inner == Step::Check && outer == Step::Skip && !deferred);
+ assert_eq!(step(), Step::Check);
+ }
+
+ #[test]
+ fn the_mode_reaches_the_kernels_worker_threads() {
+ let items = [0, 1, 2, 3];
+ let (checked, deferred) = validating(Validation::EachFeature, || {
+ crate::par::map("validation", &items, true, |_| Ok(step())).into_iter().collect::>>()
+ });
+ assert_eq!(checked.ok(), Some(vec![Step::Defer; 4]));
+ assert!(deferred);
+ let (on_threads, deferred) = validating(Validation::EachFeature, || crate::par::map_on_threads(&items, 4, |_| step()));
+ assert_eq!(on_threads, vec![Some(Step::Defer); 4]);
+ assert!(deferred);
+ }
+
+ /// A box with one corner moved off its three edges: SMLib's check refuses it. Under each_step
+ /// the boolean that takes it refuses its result there; under each_feature it is not checked,
+ /// says the check was left for later, and the check of the body kept refuses it.
+ #[cfg(feature = "smlib")]
+ #[test]
+ fn a_body_the_check_refuses_is_refused_at_the_step_or_at_the_end() {
+ use solidcraft_geom::Vec3;
+ let good = crate::box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(10.0, 10.0, 10.0)).unwrap();
+ assert!(check_kept(&good).is_ok());
+ let mut record = good.record().clone();
+ record.vertices[0].point[2] += 0.5;
+ let bad = Body::from_record(record).unwrap();
+ let e = check_kept(&bad).unwrap_err().to_string();
+ assert!(e.contains("SMLib's check refuses the result"), "{e}");
+ let tool = crate::box_solid(Vec3::new(5.0, 5.0, 5.0), Vec3::new(20.0, 20.0, 20.0)).unwrap();
+ let (step, deferred) = validating(Validation::EachStep, || crate::boolean(&bad, &tool, crate::BoolOp::Union));
+ let e = step.unwrap_err().to_string();
+ assert!(e.contains("SMLib's check refuses the result (the first operand already fails it)") && !deferred, "{e}");
+ let (joined, deferred) = validating(Validation::EachFeature, || crate::boolean(&bad, &tool, crate::BoolOp::Union));
+ assert!(deferred);
+ let joined = joined.unwrap().unwrap();
+ assert!(check_kept(&joined).unwrap_err().to_string().contains("SMLib's check refuses the result"));
+ let (off, deferred) = validating(Validation::Off, || crate::boolean(&bad, &tool, crate::BoolOp::Union));
+ assert!(off.is_ok_and(|b| b.is_some()) && !deferred);
+ }
+
+ #[test]
+ fn modes_are_named_as_they_are_saved() {
+ for v in Validation::ALL {
+ assert_eq!(Validation::parse(v.id()), Some(v));
+ assert_eq!(serde_json::to_value(v).ok(), Some(serde_json::json!(v.id())));
+ }
+ assert_eq!(Validation::parse("each step"), None);
+ assert_eq!(Validation::default(), Validation::EachFeature);
+ }
+}