Enum LineKind 

#[non_exhaustive]
pub enum LineKind {
    Linear {
        min: f64,
        max: f64,
    },
    Loop {
        circumference: f64,
        min_headway: f64,
    },
}

Topology of a line — open-ended linear axis or closed loop.

Linear is the default for elevator shafts, tethers, and other paths bounded by [min, max]. Loop (gated behind the loop_lines feature) models a closed-loop transit line where positions wrap modulo circumference. Helpers in super::cyclic operate on Loop positions; consumer code dispatches on this enum to pick linear vs cyclic semantics.

#[non_exhaustive] — future topologies (figure-eight, branching, etc.) can be added without a major version bump.

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.

Linear

Open-ended line with hard [min, max] position bounds. Cars reverse at endpoints; this matches every existing dispatch strategy (LOOK, sweep, scan, destination, etc.).

Fields

min: f64

Lowest reachable position.

max: f64

Highest reachable position.

Loop

Closed loop with cyclic position semantics. Positions wrap into [0, circumference); cars travel one direction only and maintain a strict no-overtake ordering with at least min_headway between successive cars.

Fields

circumference: f64

Total path length around the loop. Must be > 0 — construction (Simulation::add_line and the explicit-topology builder) rejects non-positive or non-finite values.

min_headway: f64

Minimum permitted forward distance between successive cars. Construction enforces n_cars * min_headway <= circumference at both add_line (via max_cars) and add_elevator (per-attach). Callers should set this strictly positive.

Implementations

impl LineKind

pub const fn is_loop(&self) -> bool

Returns true for LineKind::Loop; paired with Self::is_linear.

pub const fn is_linear(&self) -> bool

Whether this line is a (linear) open-ended axis.

Paired with Self::is_loop so consumers can dispatch positively on the expected variant rather than negatively on “not Loop”, which would silently absorb any future topology added to the enum.

pub fn validate(&self) -> Result<(), (&'static str, String)>

Validate that this kind’s intrinsic bounds are well-formed.

Returns Err((field, reason)) on a violation; both construction entry points (Simulation::add_line and the explicit-topology builder) call this and lift the error into SimError::InvalidConfig.

The intent is the trivial per-kind sanity checks — bounds finite and ordered, circumference positive. Cross-line invariants (max_cars × headway, group homogeneity) are checked by the Simulation construction and topology methods, not here.

Errors

Linear rejects non-finite or min > max bounds. Loop rejects non-finite or non-positive circumference.

Trait Implementations

impl Clone for LineKind

fn clone(&self) -> LineKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LineKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LineKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LineKind

fn eq(&self, other: &LineKind) -> 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 Serialize for LineKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for LineKind

impl StructuralPartialEq for LineKind