Enum Rule 

#[non_exhaustive]
pub enum Rule {
    PointMustNotOverlap,
    PointMustNotOverlapWith,
    PointMustBeInside,
    LineMustNotHaveDangles,
    LineMustNotHavePseudoNodes,
    LineMustNotOverlap,
    LineMustNotOverlapWith,
    LineMustNotSelfOverlap,
    LineMustNotIntersect,
    LineMustNotIntersectWith,
    LineMustNotIntersectOrTouchInterior,
    LineMustNotIntersectOrTouchInteriorWith,
    LineMustNotSelfIntersect,
    LineMustBeInside,
    PolygonMustNotOverlap,
    PolygonMustNotOverlapWith,
    PolygonMustNotHaveGaps,
    GeometryMustNotBeMultipart,
    PointMustBeCoveredByLines,
    PointMustBeCoveredByLineEndpoints,
    PointMustBeCoveredByPolygonBoundaries,
    LineEndpointsMustBeCoveredByPoints,
    LineMustBeCoveredByPolygonBoundaries,
    PolygonBoundariesMustBeCoveredByLines,
    PolygonMustContainPoint,
    PolygonMustContainOnePoint,
    LineMustNotCrossPolygonBoundaries,
    GeometryMustNotBeContainedBy,
    PointMustBeCoveredByPolygons,
    PointMustNotBeInsidePolygons,
    PointMustNotIntersectLines,
    PointMustNotIntersectPolygons,
    LineMustBeProperlyInsidePolygons,
    LineMustNotOverlapWithPolygons,
    LineMustNotOverlapPolygonBoundaries,
    LineMustNotIntersectPolygons,
    LineEndpointsMustBeCoveredByPolygonBoundaries,
    PolygonMustNotContainPoints,
}

A supported topology rule with its canonical CLI and serialization name.

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.

PointMustNotOverlap

Report each pair of coincident points within tolerance once.

PointMustNotOverlapWith

Report coincident point pairs across two layers.

PointMustBeInside

Report points not strictly inside any polygon; boundary distances at or below tolerance are outside.

LineMustNotHaveDangles

Report part endpoints with one incident use after noding and clustering.

LineMustNotHavePseudoNodes

Report nodes with exactly two endpoint uses from distinct features. Closed loops are valid.

LineMustNotOverlap

Report shared linework between distinct features, once per feature pair. Self-overlaps are excluded.

LineMustNotOverlapWith

Report shared linework across two layers, once per feature pair.

LineMustNotSelfOverlap

Report linework traversed repeatedly by one feature, including its multiple parts.

LineMustNotIntersect

Report overlaps and interior-to-interior intersections between distinct features. Endpoint touches and self violations are excluded.

LineMustNotIntersectWith

Report overlaps and interior-to-interior intersections across two layers.

LineMustNotIntersectOrTouchInterior

Report overlaps and meetings between distinct features where at least one feature is interior.

LineMustNotIntersectOrTouchInteriorWith

Report overlaps and meetings across two layers where at least one feature is interior.

LineMustNotSelfIntersect

Report self-overlaps and true self-crossings. Closed loops and self-touches are valid.

LineMustBeInside

Report pieces outside the polygon union longer than tolerance. Polygon boundaries are covered.

PolygonMustNotOverlap

Report polygon intersection areas once per distinct feature pair, excluding slivers below tolerance.

PolygonMustNotOverlapWith

Report polygon intersection areas across two layers, excluding slivers below tolerance.

PolygonMustNotHaveGaps

Report union interior rings as gaps and exterior rings as outer-boundary. Ignore sliver holes below tolerance.

GeometryMustNotBeMultipart

Report features containing more than one part. A single-part Multi geometry is valid.

PointMustBeCoveredByLines

Every point must be within tolerance of linework, including endpoints.

PointMustBeCoveredByLineEndpoints

Every point must be within tolerance of an open line part endpoint. Closed parts have no endpoints.

PointMustBeCoveredByPolygonBoundaries

Every point must be within tolerance of an individual polygon exterior or hole boundary, including shared edges.

LineEndpointsMustBeCoveredByPoints

Every open line part endpoint must be within tolerance of a point. Closed parts have no endpoints.

LineMustBeCoveredByPolygonBoundaries

Report line pieces not covered by individual polygon boundaries, longer than tolerance. Includes hole and shared boundaries.

PolygonBoundariesMustBeCoveredByLines

Report exterior and hole boundary pieces without covering linework, longer than tolerance.

PolygonMustContainPoint

Every polygon feature must strictly contain all retained parts of at least one point feature. Count distinct FIDs.

PolygonMustContainOnePoint

Every polygon feature must strictly contain exactly one point feature, and every point feature must belong to exactly one polygon feature. Count distinct FIDs.

LineMustNotCrossPolygonBoundaries

Report entry and exit crossings of individual exterior and hole boundaries. Tangencies, endpoint contacts and shared segments are allowed.

GeometryMustNotBeContainedBy

Report whole cleaned features topologically contained by individual target features, excluding mutual containment. No tolerance buffer is used.

PointMustBeCoveredByPolygons

Every point must be inside polygon areas or within tolerance of their boundaries.

PointMustNotBeInsidePolygons

Report strictly interior points. Points within tolerance of polygon boundaries are allowed.

PointMustNotIntersectLines

Report point contacts within tolerance anywhere on linework, including endpoints.

PointMustNotIntersectPolygons

Report points inside polygon areas or within tolerance of their boundaries.

LineMustBeProperlyInsidePolygons

Every cleaned line part must be inside the polygon union and farther than tolerance from its boundary. Report the whole failing part.

LineMustNotOverlapWithPolygons

Report line pieces inside individual polygon areas or along their boundaries, longer than tolerance. Isolated contacts are allowed.

LineMustNotOverlapPolygonBoundaries

Report shared individual polygon boundary segments longer than tolerance. Crossings and isolated contacts are allowed.

LineMustNotIntersectPolygons

Report interior pieces, shared boundary pieces and isolated contacts with individual polygons. Boundary proximity within tolerance counts as contact.

LineEndpointsMustBeCoveredByPolygonBoundaries

Every open line part endpoint must be within tolerance of an exterior or hole boundary. Closed parts have no endpoints.

PolygonMustNotContainPoints

Report strictly contained point parts with polygon origin provenance. Points within tolerance of boundaries are allowed.

Implementations

impl Rule

pub const ALL: &'static [Self]

All 38 rules in registry order. The original 18 remain the prefix.

pub const fn name(self) -> &'static str

Return the canonical slash-separated rule name.

pub const fn inputs(self) -> (GeometryKind, Option<GeometryKind>)

Return the primary family and optional secondary input family.

pub const fn description(self) -> &'static str

Describe the rule’s violation semantics and tolerance behavior.

pub const fn summary(self) -> &'static str

Summarize the rule in plain language for rule catalogs.

pub const fn arcgis(self) -> Option<&'static str>

Return the corresponding ArcGIS name, when available.

pub const fn qgis(self) -> Option<&'static str>

Return the corresponding QGIS name, when available.

impl Rule

pub fn check_input_count(self, other: bool) -> Result<(), Error>

Check that a secondary input is supplied exactly when the rule needs one. Callers can use this before loading layers; distinct inputs are checked at registration, which returns Error::SameLayer.

Errors

Returns Error::Inputs with the required layer count.

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Rule

impl Debug for Rule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Rule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Rule

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

Formats the value using the given formatter.

impl Eq for Rule

impl FromStr for Rule

fn from_str(value: &str) -> Result<Self, Self::Err>

Parse an exact, case-sensitive canonical rule name.

Errors

Returns ParseRuleError containing the unrecognized input name.

type Err = ParseRuleError

The associated error which can be returned from parsing.

impl Hash for Rule

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Rule

fn cmp(&self, other: &Rule) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Rule

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Rule

fn partial_cmp(&self, other: &Rule) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Rule

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 Rule