Enum IntersectionKind

pub enum IntersectionKind {
    MapEdge,
    Terminus,
    Connection,
    Fork,
    Intersection,
}

What kind of feature an Intersection actually represents. Any connection between roads in the network graph is represented by an Intersection, but many of them are not traffic “intersections” in the common sense.

Variants

MapEdge

A Road ends because the road crosses the map boundary.

Terminus

A single Road ends because the actual roadway ends; “the end of the line”.

E.g. turning circles, road end signs, train terminus thingos, …

Connection

Multiple Roads connect but no flow of traffic interacts with any other.

Usually one Road ends and another begins because the number of lanes has changed or some other attribute of the roadway has changed. More than two Roads could be involved, e.g. when a single carriageway (a bidirectional Road) splits into a dual carriageway (two oneway Roads).

Fork

One flow of traffic forks into multiple, or multiple merge into one, but all traffic is expected to keep flowing.

E.g. highway on-ramps and off-ramps.

Intersection

At least three Roads meet at an actual “intersection” where at least one flow of traffic gives way to, or conflicts with, another.

Trait Implementations

impl Clone for IntersectionKind

fn clone(&self) -> IntersectionKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IntersectionKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IntersectionKind

fn deserialize<__D>( __deserializer: __D, ) -> Result<IntersectionKind, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for IntersectionKind

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

where __H: Hasher,

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 PartialEq for IntersectionKind

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for IntersectionKind

impl Eq for IntersectionKind

impl StructuralPartialEq for IntersectionKind