diff --git a/crates/kernel/src/backend.rs b/crates/kernel/src/backend.rs deleted file mode 100644 index 8ff0b40d6..000000000 --- a/crates/kernel/src/backend.rs +++ /dev/null @@ -1,51 +0,0 @@ -//! Which kernel this process runs its operations on: truck (the default) or SMLib. -//! -//! The setting is the environment variable `SOLIDCRAFT_KERNEL`, read once per process: `truck` -//! (or unset) or `smlib`. Every operation that has an SMLib path asks [`backend`]. SMLib needs a -//! build with the kernel's `smlib` feature; set without it, or set to anything else, every such -//! operation fails with an error that says so rather than quietly running truck, so a comparison -//! run can never compare truck with itself. - -use crate::{KernelError, Result}; - -/// The environment variable that picks the kernel. -pub const KERNEL_ENV: &str = "SOLIDCRAFT_KERNEL"; - -/// A kernel operations run on. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Backend { - Truck, - Smlib, -} - -impl Backend { - /// The backend a setting names; `None` (unset) is truck. - pub fn parse(setting: Option<&str>) -> std::result::Result { - match setting.map(str::trim) { - None | Some("") | Some("truck") => Ok(Backend::Truck), - Some("smlib") if cfg!(feature = "smlib") => Ok(Backend::Smlib), - Some("smlib") => Err(format!("{KERNEL_ENV}=smlib: not supported yet: this build has no SMLib (feature `smlib`)")), - Some(other) => Err(format!("{KERNEL_ENV}={other}: expected `truck` or `smlib`")), - } - } -} - -/// The kernel this process runs on ([`KERNEL_ENV`], read on first use). -pub fn backend() -> Result { - static SETTING: std::sync::OnceLock> = std::sync::OnceLock::new(); - SETTING.get_or_init(|| Backend::parse(std::env::var(KERNEL_ENV).ok().as_deref())).clone().map_err(KernelError::Invalid) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn the_setting_names_a_backend_or_is_refused() { - assert_eq!(Backend::parse(None), Ok(Backend::Truck)); - assert_eq!(Backend::parse(Some("truck")), Ok(Backend::Truck)); - assert_eq!(Backend::parse(Some(" ")), Ok(Backend::Truck)); - assert_eq!(Backend::parse(Some("smlib")).is_ok(), cfg!(feature = "smlib")); - assert!(Backend::parse(Some("occt")).is_err()); - } -} diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs index fa4e07eee..c382959c0 100644 --- a/crates/kernel/src/lib.rs +++ b/crates/kernel/src/lib.rs @@ -13,7 +13,6 @@ #![forbid(unsafe_code)] mod assemble; -mod backend; mod blend; mod blend_corner; mod blend_fit; @@ -83,7 +82,6 @@ mod loft_rails_tests; mod loft_region_tests; mod matchsurf; mod measure; -mod measure_backend; mod mesh_convert; mod meshbody; #[cfg(test)] @@ -115,7 +113,6 @@ pub mod provenance; mod record; mod seam_faces; mod sew; -#[cfg(feature = "smlib")] mod smlib_boolean; mod smlib_sweeps; #[cfg(test)] @@ -155,7 +152,6 @@ mod validity; pub mod watch; mod whole_face; -pub use backend::{Backend, KERNEL_ENV, backend}; pub use blend::{ChamferSide, chamfer, chamfer_sides, fillet, fillet_each, fillet_g2, fillet_g2_corners, fillet_max, fillet_max_each}; pub use blend_corner::fillet_radii; pub use blend_variable::{RadiusSpline, Taper, fillet_chord, fillet_tapered, fillet_variable, fillet_variable_points, fillet_variable_spline, taper}; @@ -189,7 +185,6 @@ pub use matchsurf::{match_surface, seam_continuity}; pub use measure::{BodyMeasure, MassMeasure, measure, measure_mass}; pub use mesh_convert::convert_prismatic_mesh; pub use meshbody::{MAX_TRIANGLES, mesh_body}; -#[cfg(feature = "smlib")] pub use native::{body_from_smlib, smlib_body}; pub use native::{brep_record, decode_native_body, encode_native_body, native_preview_mesh}; pub use offset::with_same_surface; @@ -223,7 +218,7 @@ pub use sweep_path::{RailFit, SweepControl, SweepOrientation, sweep_path, sweep_ pub use topo::{CylinderFace, cylinder_end_at, cylinder_face, cylinder_face_at}; pub use topo::{TopoCounts, merged_topology, seam_flags}; pub use tspline::tspline_sheet; -pub use validity::{SmlibCheck, Validity, boolean_kernel, smlib_built, validity}; +pub use validity::{SmlibCheck, Validity, smlib_built, validity}; pub use whole_face::{WholeFace, cut_takes_only_the_face, cut_tool, face_prism, matching_face}; #[derive(Debug, Clone, PartialEq, thiserror::Error)] @@ -243,16 +238,9 @@ pub enum KernelError { pub type Result = std::result::Result; -/// The native kernel call running right now (SMLib, with the `smlib` feature), for crash reports. +/// The native kernel call running right now (SMLib), for crash reports. pub fn native_call_in_flight() -> Option { - #[cfg(feature = "smlib")] - { - solidcraft_smlib::current_call() - } - #[cfg(not(feature = "smlib"))] - { - None - } + solidcraft_smlib::current_call() } thread_local! { diff --git a/crates/kernel/src/measure.rs b/crates/kernel/src/measure.rs index 6e7feda36..f7cc7d50c 100644 --- a/crates/kernel/src/measure.rs +++ b/crates/kernel/src/measure.rs @@ -1,5 +1,5 @@ use serde::Serialize; -use solidcraft_geom::{Aabb3, Mesh, Vec3}; +use solidcraft_geom::{Aabb3, Vec3}; use crate::Result; use crate::body::Body; @@ -20,56 +20,16 @@ pub struct BodyMeasure { /// Counts after merging split pieces of the same analytic surface/curve (comparable with /// systems that use periodic faces and edges). pub merged: TopoCounts, - /// What volume, area and centre come from: `smlib` (exact, integrated on the surfaces, with - /// the kernel setting SMLib) or `mesh` (a fine tessellation). + /// What volume, area and centre come from: `smlib` (exact, integrated on the surfaces) or + /// `mesh` (a mesh body's own triangles). pub measured_by: &'static str, - /// Why a measurement is not what the kernel setting asks for (SMLib refused the body, or - /// disagreed with the mesh). + /// Anything the measurement says about itself. #[serde(skip_serializing_if = "Vec::is_empty")] pub notes: Vec, } -/// Per-face sums: area, 6 × signed volume and 24 × first moments (divergence theorem), taken -/// about `o` (the moments relative to it), and the sum of the area vectors (zero over a closed -/// surface). Over a closed surface the volume does not depend on `o`; over one that leaves a -/// gap, the gap is closed by a cone to `o`, so `o` near the body keeps that cone small. -fn face_sums(m: &Mesh, nf: usize, o: Vec3) -> Vec<(f64, f64, Vec3, Vec3)> { - let mut out = vec![(0.0, 0.0, Vec3::ZERO, Vec3::ZERO); nf]; - for (t, f) in m.triangles.iter().zip(&m.tri_face) { - let (Some([a, b, c]), Some(slot)) = (m.tri(t), out.get_mut(*f as usize)) else { continue }; - let n = (b - a).cross(c - a) * 0.5; - let (a, b, c) = (a - o, b - o, c - o); - let d = a.dot(b.cross(c)); - slot.0 += n.len(); - slot.1 += d; - slot.2 += (a + b + c) * d; - slot.3 += n; - } - out -} - -/// Smallest radius of curvature along the mesh's edge polylines (straight edges ignored). -fn min_edge_radius(m: &Mesh) -> Option { - let mut best: Option = None; - for e in &m.edges { - for w in e.windows(3) { - let (Some(&a), Some(&b), Some(&c)) = (w.first(), w.get(1), w.get(2)) else { continue }; - let (ab, bc, ca) = (b - a, c - b, a - c); - let cross = ab.cross(bc).len(); - if !(cross > 1e-12 * ab.len() * bc.len()) { - continue; - } - let r = ab.len() * bc.len() * ca.len() / (2.0 * cross); - if r.is_finite() && r > 0.0 && best.is_none_or(|x| r < x) { - best = Some(r); - } - } - } - best -} - /// Volume, area, centre and box of a body, as [`measure`] works them out, without the topology -/// counts (and the tessellation they take). +/// counts. #[derive(Clone, Debug, Serialize)] pub struct MassMeasure { pub volume: f64, @@ -83,9 +43,14 @@ pub struct MassMeasure { pub notes: Vec, } -/// Measure a body from a fine tessellation (chord tolerance 5e-5 of the body size, finer for -/// small radii down to 5e-6). Faces whose fine tessellation disagrees with a coarse one (a -/// meshing failure) use the coarse result. +/// The relative accuracy SMLib integrates at: the finest of SmApiBrepComputeMassProperties' +/// documented range ("clamped to [1e-4, 1e-1]", SmApiQueries.h). Its cost is "governed by +/// dRelativeAccuracy". +const ACCURACY: f64 = 1e-4; + +/// Measure a body. A solid body's volume, area and centre are SMLib's, integrated on its exact +/// surfaces, and its box is SMLib's exact box; a body SMLib cannot measure is an error. A mesh +/// body is measured from its triangles, exactly. pub fn measure(b: &Body) -> Result { if let Some((pos, tris)) = b.triangle_mesh() { // Exact for a mesh body; topology counts are facets, sides and vertices. @@ -108,12 +73,8 @@ pub fn measure(b: &Body) -> Result { notes: Vec::new(), }); } - let (mut m, topo) = mass(b, true)?; - let chosen = crate::measure_backend::choose(b, &mut m); - let topo = match topo { - Some(t) => t, - None => b.mesh(&crate::MeshTolerance::chord((b.size() * 1e-3).max(1e-3)))?, - }; + let m = measure_mass(b)?; + let topo = b.mesh(&crate::MeshTolerance::chord((b.size() * 1e-3).max(1e-3)))?; Ok(BodyMeasure { volume: m.volume, area: m.area, @@ -124,93 +85,23 @@ pub fn measure(b: &Body) -> Result { vertices: b.vertex_count(), shells: b.shell_count(), merged: merged_topology(b, &topo)?, - measured_by: chosen.by, - notes: chosen.notes, + measured_by: m.measured_by, + notes: m.notes, }) } -/// [`measure`]'s volume, area, centre and box alone: the same numbers, a tessellation fewer -/// (for callers that need no topology counts, such as an interference check). +/// [`measure`]'s volume, area, centre and box alone (for callers that need no topology counts, +/// such as an interference check). pub fn measure_mass(b: &Body) -> Result { if b.triangle_mesh().is_some() { let m = measure(b)?; return Ok(MassMeasure { volume: m.volume, area: m.area, centroid: m.centroid, bbox: m.bbox, measured_by: m.measured_by, notes: m.notes }); } - let mut m = mass(b, false)?.0; - let chosen = crate::measure_backend::choose(b, &mut m); - m.measured_by = chosen.by; - m.notes = chosen.notes; - Ok(m) -} - -/// The mass properties of a B-rep body from three tessellations: a coarse one (which sets how -/// fine the others go), then a fine and a medium one at once on desktop (one after the other -/// in the browser). With `topology`, also the coarse unrefined mesh the topology counts take, -/// made alongside them. -fn mass(b: &Body, topology: bool) -> Result<(MassMeasure, Option)> { - let size = b.size(); - let coarse_tol = (size * 1e-3).max(1e-3); - let coarse = b.mesh(&crate::MeshTolerance::chord(coarse_tol))?; - // Chord error relative to a radius sets the volume error: keep it near 3e-4 of the - // smallest radius (thin tubes, small fillets). - let tight = min_edge_radius(&coarse).map(|r| r * 3e-4).unwrap_or(f64::INFINITY); - let fine_tol = (size * 5e-5).min(tight).max(size * 5e-6).max(1e-4); - let mut jobs = vec![(fine_tol, true), ((fine_tol * 5.0).max(2e-4), true)]; - if topology { - jobs.push((coarse_tol, false)); - } - // Independent tessellations of one body: each on its own thread, the calling thread's - // profile counting their wall time once as tessellation. Not from inside a worker pool: a - // pool thread blocked on threads of its own could leave their meshing (which runs on the - // shared pool) without a worker. - #[cfg(not(target_arch = "wasm32"))] - let threads = if rayon::current_thread_index().is_none() { jobs.len() } else { 1 }; - #[cfg(target_arch = "wasm32")] - let threads = 1; - let made = crate::profile::timed(crate::profile::Kind::Tessellate, || { - crate::par::map_on_threads(&jobs, threads, |&(tol, refine)| b.mesh(&crate::MeshTolerance::chord(tol))) - }); - let mut made = made.into_iter().map(|m| m.unwrap_or_else(|| Err(crate::KernelError::Internal("tessellation failed".into())))); - let missing = || crate::KernelError::Internal("tessellation missing".into()); - let fine = made.next().ok_or_else(missing)??; - let medium = made.next().ok_or_else(missing)??; - let topo = match made.next() { - Some(m) => Some(m?), - None => None, - }; - let nf = b.face_count(); - // About the box's centre when the meshes leave only a crack: see `face_sums`. A body that is - // open on purpose (a surface, or a cup whose lid is still a separate sheet) has no volume of - // its own; it keeps the origin, so such bodies still compare with each other when the centre - // of their boxes moves (a crowned lid rises, the open cup under it doesn't change). - let (surface, gap) = face_sums(&fine, nf, Vec3::ZERO).iter().fold((0.0, Vec3::ZERO), |s, f| (s.0 + f.0, s.1 + f.3)); - let o = Some(fine.bounds().center()).filter(|c| c.is_finite() && gap.len() <= 0.01 * surface).unwrap_or(Vec3::ZERO); - let (sf, sm, sc) = (face_sums(&fine, nf, o), face_sums(&medium, nf, o), face_sums(&coarse, nf, o)); - let close = |x: f64, y: f64| (x - y).abs() <= 0.01 * x.abs().max(y.abs()) + 1e-9; - let (mut area, mut v6, mut mom) = (0.0, 0.0, Vec3::ZERO); - for ((f, m), c) in sf.iter().zip(&sm).zip(&sc) { - // Trust the finest tessellation that agrees with the next coarser one. - let pick = if close(f.0, m.0) { - f - } else if close(m.0, c.0) { - m - } else { - f - }; - area += pick.0; - v6 += pick.1; - mom += pick.2; - } - // The moments back about the origin. A gap the meshes leave (a crack where a trimmed face - // meets a hole cut into it) is closed by a cone to the box's centre, which keeps it small - // (a crack of 0.3 mm² moved a part ring's volume by 7 % about the origin 1000 mm away; about - // the centre, by 0.1 %). Every body is measured by the same meshes this way, so a body and the - // pieces a boolean cuts it into add up: a closed display plan measured instead would mesh - // some faces more coarsely than the sums do and break that. - let mom = o * (4.0 * v6) + mom; - let volume = v6 / 6.0; - let centroid = if v6.abs() > 1e-12 { mom / (4.0 * v6) } else { fine.bounds().center() }; - Ok((MassMeasure { volume, area, centroid, bbox: coarse.bounds().union(&fine.bounds()), measured_by: "mesh", notes: Vec::new() }, topo)) + let m = crate::guard("SMLib mass properties", || { + b.smlib()?.mass_properties(ACCURACY).map_err(|e| crate::KernelError::Failed(format!("SMLib mass properties: {e}"))) + })?; + let [x, y, z] = m.centroid; + Ok(MassMeasure { volume: m.volume, area: m.area, centroid: Vec3::new(x, y, z), bbox: b.exact_bounds()?, measured_by: "smlib", notes: Vec::new() }) } #[cfg(test)] @@ -218,8 +109,8 @@ mod tests { use super::*; use crate::{BoolOp, boolean, cylinder, torus}; - /// The mass properties alone are [`measure`]'s, to the bit, with the tessellations made at - /// once; and on a curved intersection they are the textbook ones. + /// The mass properties alone are [`measure`]'s, to the bit; and on a curved intersection + /// they are the textbook ones. #[test] fn mass_alone_is_the_full_measure() { let ring = torus(Vec3::ZERO, 10.0, 2.0).unwrap(); diff --git a/crates/kernel/src/measure_backend.rs b/crates/kernel/src/measure_backend.rs deleted file mode 100644 index 92ba4c51f..000000000 --- a/crates/kernel/src/measure_backend.rs +++ /dev/null @@ -1,121 +0,0 @@ -//! Mass properties through SMLib, when [`crate::backend`] is SMLib: the body goes to SMLib as its -//! schema 4 record and SMLib integrates its volume, area and centroid on the exact surfaces -//! (`solidcraft_smlib::Brep::mass_properties`). The mesh measure is always made too, as an -//! independent check: where SMLib disagrees with it beyond the mesh's own accuracy -//! (tangency-labs/solidcore#384), or can't take the body, the mesh measure stands and the -//! measurement says why in its notes. - -use solidcraft_geom::Vec3; - -use crate::body::Body; -use crate::measure::MassMeasure; - -/// The mesh measure's own accuracy (relative, for volume and area; of the body's size, for the -/// centroid): SMLib must agree with it this closely for its numbers to be used. -const AGREE: f64 = 1e-3; - -/// The relative accuracy SMLib integrates at: the finest of SmApiBrepComputeMassProperties' -/// documented range ("clamped to [1e-4, 1e-1]", SmApiQueries.h), ten times inside the 1e-3 the -/// measure is held to ([`AGREE`], and the regression rig's volume and area tolerance). Its cost is -/// "governed by dRelativeAccuracy": the finest the integrator allows, 1e-8, took tens of seconds -/// on a modelled thread's faces. -const ACCURACY: f64 = 1e-4; - -/// Exact volume, area and centroid. -pub(crate) struct Exact { - pub volume: f64, - pub area: f64, - pub centroid: Vec3, -} - -/// What the measurement comes from, and what it says about it. -pub(crate) struct Choice { - pub by: &'static str, - pub notes: Vec, -} - -/// SMLib's mass properties of `b`, or why there are none. -#[cfg(feature = "smlib")] -fn exact(b: &Body) -> Result { - let sb = crate::native::smlib_body(b).map_err(|e| e.to_string())?; - let m = sb.mass_properties(ACCURACY).map_err(|e| format!("SMLib mass properties: {e}"))?; - let [x, y, z] = m.centroid; - Ok(Exact { volume: m.volume, area: m.area, centroid: Vec3::new(x, y, z) }) -} - -#[cfg(not(feature = "smlib"))] -fn exact(_: &Body) -> Result { - Err("this build has no SMLib".into()) -} - -/// Where the kernel setting is SMLib, replaces `mesh`'s volume, area and centroid with SMLib's -/// exact ones when they agree with it; otherwise keeps the mesh measure and notes why. The box -/// stays the mesh's. -pub(crate) fn choose(b: &Body, mesh: &mut MassMeasure) -> Choice { - if !matches!(crate::backend(), Ok(crate::Backend::Smlib)) { - return Choice { by: "mesh", notes: Vec::new() }; - } - let e = match crate::guard("SMLib mass properties", || Ok(exact(b))) { - Ok(Ok(e)) => e, - Ok(Err(why)) | Err(crate::KernelError::Internal(why)) => { - return Choice { by: "mesh", notes: vec![format!("measured from the mesh: SMLib could not measure this body ({why})")] }; - } - Err(e) => return Choice { by: "mesh", notes: vec![format!("measured from the mesh: SMLib could not measure this body ({e})")] }, - }; - match disagreement(&e, mesh, b.size()) { - None => { - mesh.volume = e.volume; - mesh.area = e.area; - mesh.centroid = e.centroid; - Choice { by: "smlib", notes: Vec::new() } - } - Some(what) => Choice { - by: "mesh", - notes: vec![format!("measured from the mesh: SMLib's exact mass properties disagree with it ({what}; tangency-labs/solidcore#384)")], - }, - } -} - -/// Where SMLib's numbers and the mesh's differ by more than the mesh's accuracy, which and by how -/// much. -fn disagreement(e: &Exact, m: &MassMeasure, size: f64) -> Option { - let rel = |a: f64, b: f64| (a - b).abs() / a.abs().max(b.abs()).max(1e-12); - let finite = e.volume.is_finite() && e.area.is_finite() && [e.centroid.x, e.centroid.y, e.centroid.z].iter().all(|x| x.is_finite()); - if !finite { - return Some("SMLib's numbers are not finite".into()); - } - let mut out = Vec::new(); - if rel(e.volume, m.volume) > AGREE { - out.push(format!("volume {:.6} against {:.6}", e.volume, m.volume)); - } - if rel(e.area, m.area) > AGREE { - out.push(format!("area {:.6} against {:.6}", e.area, m.area)); - } - let d = e.centroid.dist(m.centroid); - if d > AGREE * size.max(1e-9) { - out.push(format!("centroid {d:.6} mm apart")); - } - (!out.is_empty()).then(|| out.join(", ")) -} - -#[cfg(test)] -mod tests { - use super::*; - use solidcraft_geom::Aabb3; - - fn mesh(volume: f64, area: f64, centroid: Vec3) -> MassMeasure { - MassMeasure { volume, area, centroid, bbox: Aabb3::EMPTY, measured_by: "mesh", notes: Vec::new() } - } - - #[test] - fn agreement_is_within_the_mesh_accuracy() { - let e = Exact { volume: 1000.0, area: 600.0, centroid: Vec3::new(5.0, 5.0, 5.0) }; - assert!(disagreement(&e, &mesh(1000.4, 600.2, Vec3::new(5.0, 5.0, 5.001)), 17.3).is_none()); - let off = disagreement(&e, &mesh(1015.0, 600.0, Vec3::new(5.0, 5.0, 5.0)), 17.3).unwrap(); - assert!(off.contains("volume 1000.000000 against 1015.000000"), "{off}"); - let moved = disagreement(&e, &mesh(1000.0, 600.0, Vec3::new(5.0, 5.0, 6.0)), 17.3).unwrap(); - assert!(moved.contains("centroid"), "{moved}"); - let nan = Exact { volume: f64::NAN, area: 600.0, centroid: Vec3::ZERO }; - assert!(disagreement(&nan, &mesh(1000.0, 600.0, Vec3::ZERO), 17.3).is_some()); - } -} diff --git a/crates/kernel/src/offset_backend.rs b/crates/kernel/src/offset_backend.rs index 884647604..3dca4e3ab 100644 --- a/crates/kernel/src/offset_backend.rs +++ b/crates/kernel/src/offset_backend.rs @@ -12,7 +12,6 @@ //! ([`FaceOrigin::Offset`]), and its edges as where its faces meet. A face SMLib makes new along //! a sheet's open edge (a thickened sheet's wall) is recorded as made in place of that edge. -#![cfg(feature = "smlib")] use std::collections::{BTreeMap, BTreeSet}; diff --git a/crates/kernel/src/validity.rs b/crates/kernel/src/validity.rs index d07c4ed9f..52cb85129 100644 --- a/crates/kernel/src/validity.rs +++ b/crates/kernel/src/validity.rs @@ -1,6 +1,6 @@ //! 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. +//! and SMLib's own check of the same record. use crate::{Body, brep_record}; @@ -9,7 +9,7 @@ use crate::{Body, brep_record}; 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. + /// SMLib's `check(All)` of the record. pub smlib: Option, } @@ -39,7 +39,6 @@ pub fn validity(body: &Body) -> Validity { Validity { record: checked, smlib: smlib_validity(body) } } -#[cfg(feature = "smlib")] fn smlib_validity(body: &Body) -> Option { let b = match crate::smlib_body(body) { Ok(b) => b, @@ -55,23 +54,8 @@ fn smlib_validity(body: &Body) -> Option { }) } -#[cfg(not(feature = "smlib"))] -fn smlib_validity(_: &Body) -> Option { - None -} - /// Whether this build links SMLib (the `smlib` feature). pub fn smlib_built() -> bool { cfg!(feature = "smlib") } -/// The kernel this process runs on ([`crate::backend`]): `"default"` (truck) or `"smlib"`, and -/// `"invalid"` where [`crate::KERNEL_ENV`] names neither or names SMLib in a build without it. -/// The regression rig refuses to grade a kernel the process isn't running. -pub fn boolean_kernel() -> &'static str { - match crate::backend() { - Ok(crate::Backend::Truck) => "default", - Ok(crate::Backend::Smlib) => "smlib", - Err(_) => "invalid", - } -}