Enum RouteError

#[non_exhaustive]
pub enum RouteError {
    NonFinitePoint,
    RingTooShort,
    BarrierTooShort,
    TooManyVertices {
        supplied: usize,
        budget: usize,
        lower_bound: f64,
    },
    Undecidable,
}

A malformed query, as opposed to an honest “no route”.

PartialEq but not Eq: RouteError::TooManyVertices carries a float bound, and float equality is not reflexive.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NonFinitePoint

A coordinate was NaN or infinite.

RingTooShort

A ring had fewer than three vertices.

BarrierTooShort

A barrier had fewer than two vertices, so it bounds no segment.

TooManyVertices

The input exceeds the vertex budget. Refused, not truncated.

Carries a PROVEN lower bound rather than only a complaint. A refusal and a bound are different facts: a caller that cannot afford the exact route can still report a minimum, defer, or escalate, where a bare error forces it to drop the query or reimplement routing (kernel#92).

The added fields make this a breaking change: Eq is gone because the bound is a float, and an exhaustive struct variant gained fields. Both are recorded against the 0.3.0 minor bump rather than worked around — marking the variant #[non_exhaustive] now would itself be breaking, so it buys nothing here.

Fields

supplied: usize

Vertices the caller supplied.

budget: usize

The budget that was applied, so the caller can raise it.

lower_bound: f64

Straight-line distance between the endpoints.

A lower bound on EVERY route between them, not an estimate: a polyline is at least as long as the straight line joining its ends, and obstacles only lengthen it. Both endpoints are already proven inside the free-space region when this is reported, so the bound applies to a route that could exist.

Being a bound, it is safe to act on: no admissible route is shorter. It says nothing about whether a route EXISTS.

Undecidable

The exact predicate could not decide a sidedness question.

Distinct from every Unreachable variant: this is the kernel declining to guess, not a statement about the geometry.

Trait Implementations

impl Clone for RouteError

fn clone(&self) -> RouteError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RouteError

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

Formats the value using the given formatter.

impl From<RouteError> for FarthestError

fn from(error: RouteError) -> FarthestError

Converts to this type from the input type.

impl From<RouteError> for MapError

fn from(error: RouteError) -> MapError

Converts to this type from the input type.

impl From<RouteError> for SkeletonError

fn from(error: RouteError) -> SkeletonError

Converts to this type from the input type.

impl PartialEq for RouteError

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for RouteError

impl StructuralPartialEq for RouteError