Enum RefusalClass 

pub enum RefusalClass {
    DegenerateArrangement {
        open_edges: u32,
        issues: u32,
    },
    NonIntegralGenus {
        shells: u32,
        euler: i64,
    },
    NonPositiveVolume,
    TangentNodeSingularity,
    InvalidResultTopology {
        issues: u32,
    },
    ConservativeEmptyOverlap,
    NonConvergence {
        what: String,
    },
    UnsupportedGeometry {
        what: String,
    },
    InvalidInput {
        what: String,
    },
    IllPosed {
        what: String,
    },
    UnsoundResult {
        defect: SoundnessDefect,
        faces: Vec<u64>,
    },
    Internal {
        what: String,
    },
}

The closed set of refusal classes. Dispatchers match on it exhaustively; adding a variant is a deliberate taxonomy change, never a message edit.

The first five are ARRANGEMENT DEGENERACIES — a coincident or near-tangent carrier pair made the exact arrangement structurally inconsistent — and are the only classes the boolean’s Simulation-of-Simplicity retry may act on, because their Backing is undecided by a degeneracy (RefusalClass::backing, RefusalClass::perturbation_eligible). The rest are honest refusals that a perturbation cannot and must not “fix”.

Variants

DegenerateArrangement

The assembled shell has open edges / invalid topology (the arrangement left a boundary unclosed).

Fields

open_edges: u32

issues: u32

NonIntegralGenus

Euler characteristic did not yield an integral genus.

Fields

shells: u32

euler: i64

NonPositiveVolume

The assembled solid’s signed volume is not positive.

TangentNodeSingularity

A singular / tangent-node surface intersection the marcher declines.

InvalidResultTopology

The FINAL validation of the result found topology issues.

Fields

issues: u32

ConservativeEmptyOverlap

The operation produced no boundary faces while contact / graze evidence exists — refusing rather than blessing an empty result.

NonConvergence

An iterative lane (edge conformance, an SSI march, a Newton polish) did not converge within its budget.

Fields

what: String

UnsupportedGeometry

A named deferral: geometry the kernel does not model yet.

Fields

what: String

InvalidInput

A caller error: bad ids, non-finite parameters, an unusable policy.

Fields

what: String

IllPosed

The operation, as specified, has no single answer and the input does not pick one: a turned face part of which moves into the body and part out, a carrier whose side the geometry does not decide, several drops of a crossing that all rebuild sound. Refusing rather than choosing; what is the origin’s stable slug.

Fields

what: String

UnsoundResult

The soundness scan convicted the RESULT a lane built — a face folded through itself, two faces crossing, a hole loop that left its face — and the repair that owns the defect declined it. Geometry, not incidence: validate()’s verdict is Self::InvalidResultTopology.

Fields

defect: SoundnessDefect

faces: Vec<u64>

Internal

The long tail — an internal consistency check tripped. Curated batteries assert zero of these among their expected refusals.

Fields

what: String

Implementations

impl RefusalClass

pub fn backing(&self) -> Backing

The backing of every class, exhaustively: a variant added without a row here does not compile, so no class is retryable or not “by whoever remembers to edit the list”.

pub fn perturbation_eligible(&self) -> bool

Whether the boolean’s perturbation retry may act on this refusal: an UNDECIDED refusal whose cause is an arrangement degeneracy, read off RefusalClass::backing. The resulting set is pinned by refusal_retry_parity against the former substring matcher and by backing_reproduces_the_retry_set below; moving a class between backings is a deliberate change.

pub fn tag(&self) -> &'static str

The snake_case tag serde emits — the name CI baselines and logs use.

Trait Implementations

impl Clone for RefusalClass

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RefusalClass

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RefusalClass

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RefusalClass

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RefusalClass

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RefusalClass