Struct HallCall 

#[non_exhaustive]
pub struct HallCall {
    pub stop: EntityId,
    pub direction: CallDirection,
    pub press_tick: u64,
    pub acknowledged_at: Option<u64>,
    pub ack_latency_ticks: u32,
    pub pending_riders: Vec<EntityId>,
    pub destination: Option<EntityId>,
    pub assigned_cars_by_line: BTreeMap<EntityId, EntityId>,
    pub pinned: bool,
}

A pressed hall button at stop requesting service in direction.

Stored per (stop, direction) pair — at most two per stop. Built-in dispatch reads calls via DispatchManifest::iter_hall_calls.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

stop: EntityId

Stop where the button was pressed.

direction: CallDirection

Direction the button requests.

press_tick: u64

Tick at which the button was first pressed.

acknowledged_at: Option<u64>

Tick at which dispatch first sees this call (after ack latency). None while still pending acknowledgement.

ack_latency_ticks: u32

Ticks the controller took to acknowledge this call, copied from the serving group’s ElevatorGroup::ack_latency_ticks when the button was first pressed. Stored on the call itself so advance_transient can tick the counter without needing to look up the group.

pending_riders: Vec<EntityId>

Riders currently waiting on this call. Empty in HallCallMode::Destination mode — calls there carry a single destination per press instead of a shared direction.

destination: Option<EntityId>

Destination requested at press time. Populated in HallCallMode::Destination mode (lobby kiosk); None in Classic mode.

assigned_cars_by_line: BTreeMap<EntityId, EntityId>

Cars assigned to this call by dispatch, keyed by the line entity the car runs on. A stop served by multiple lines can hold one entry per line simultaneously — the low-bank car, the express car, and the service car can all be en route to the same lobby without one overwriting another. Within a single line the latest assignment replaces the previous one.

Pre-15.23 snapshots stored a single assigned_car: Option<EntityId> field. Those snapshots silently drop the transient assignment on load (serde’s default unknown-field handling); the next dispatch pass repopulates this map.

pinned: bool

When true, dispatch is forbidden from reassigning this call to a different car. Set by Simulation::pin_assignment.

Implementations

impl HallCall

pub const fn new( stop: EntityId, direction: CallDirection, press_tick: u64, ) -> Self

Create a new unacknowledged, unassigned hall call.

pub const fn is_acknowledged(&self) -> bool

Returns true when dispatch is allowed to see this call (ack latency has elapsed).

pub fn any_assigned_car(&self) -> Option<EntityId>

Any car currently assigned to this call, preferring the entry with the numerically smallest line-entity key (stable across ticks because BTreeMap iteration is ordered). None when no line has recorded an assignment yet.

This matches the pre-per-line assigned_car semantics for callers that just want “is anyone coming?” The richer shape is available directly on assigned_cars_by_line.

Trait Implementations

impl Clone for HallCall

fn clone(&self) -> HallCall

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HallCall

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HallCall

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for HallCall

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

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 HallCall