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. PR 3 will add construction-time validation (max_cars * min_headway <= circumference); until then, the dispatch and movement code added in subsequent PRs is responsible for behaving sanely on degenerate values. Callers should set this strictly positive.

Implementations

impl LineKind

pub const fn is_loop(&self) -> bool

Whether this line is a closed loop.

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, initial spacing) are PR 3.

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