Struct sim::mechanics::queue::Queue

pub(crate) struct Queue {
    pub id: Traversable,
    members: VecDeque<Queued>,
    pub laggy_head: Option<CarID>,
    pub geom_len: Distance,
    pub reserved_length: Distance,
}

A Queue of vehicles on a single lane or turn. This is where https://a-b-street.github.io/docs/tech/trafficsim/discrete_event.html#exact-positions is implemented.

Some helpful pieces of terminology:

• a “laggy head” is a vehicle whose front is now past the end of this queue, but whose back may still be partially in the queue. The position of the first car in the queue is still bounded by the laggy head’s back.
• a “static blockage” is due to a vehicle exiting a driveway and immediately cutting across a few lanes. The “static” part means it occupies a fixed interval of distance in the queue. When the vehicle is finished exiting the driveway, this blockage is removed.
• a “dynamic blockage” is due to a vehicle changing lanes in the middle of the queue. The exact position of the blockage in this queue is unknown (it depends on the target queue). The blockage just occupies the length of the vehicle and keeps following whatever’s in front of it.
• “active cars” are the main members of the queue – everything except for laggy heads and blockages.

Fields

id: Traversable

members: VecDeque<Queued>

laggy_head: Option<CarID>

This car’s back is still partly in this queue.

geom_len: Distance

How long the lane or turn physically is.

reserved_length: Distance

When a car’s turn is accepted, reserve the vehicle length + FOLLOWING_DISTANCE for the target lane. When the car completely leaves (stops being the laggy_head), free up that space. To prevent blocking the box for possibly scary amounts of time, allocate some of this length first. This is unused for turns themselves. This value can exceed geom_len (for the edge case of ONE long car on a short queue).

Implementations

impl Queue

pub fn new(id: Traversable, map: &Map) -> Queue

pub fn get_last_car_position( &self, now: Time, cars: &FixedMap<CarID, Car>, queues: &HashMap<Traversable, Queue> ) -> Option<(CarID, Distance)>

Get the front of the last car in the queue.

pub fn get_car_positions( &self, now: Time, cars: &FixedMap<CarID, Car>, queues: &HashMap<Traversable, Queue> ) -> Vec<QueueEntry>

Return the exact position of each member of the queue. The farthest along (greatest distance) is first.

fn inner_get_last_car_position( &self, now: Time, cars: &FixedMap<CarID, Car>, queues: &HashMap<Traversable, Queue>, recursed_queues: &mut BTreeSet<Traversable>, intermediate_results: Option<&mut Vec<QueueEntry>> ) -> Option<(CarID, Distance)>

Returns the front of the last car in the queue, only if the last member is an active car.

pub fn get_idx_to_insert_car( &self, start_dist: Distance, vehicle_len: Distance, now: Time, cars: &FixedMap<CarID, Car>, queues: &HashMap<Traversable, Queue> ) -> Option<usize>

If the specified car can appear in the queue, return the position in the queue to do so.

pub fn insert_car_at_idx(&mut self, idx: usize, car: &Car)

Record that a car has entered a queue at a position. This must match get_idx_to_insert_car – the same index and immediately after passing that query.

pub fn push_car_onto_end(&mut self, car: CarID)

Record that a car has entered a queue at the end. It’s assumed that try_to_reserve_entry has already happened.

pub fn move_first_car_to_laggy_head(&mut self) -> CarID

Change the first car in the queue to the laggy head, indicating that it’s front has left the queue, but its back is still there. Return that car.

pub fn try_to_reserve_entry(&mut self, car: &Car, force_entry: bool) -> bool

If true, there’s room and the car must actually start the turn (because the space is reserved).

pub fn is_overflowing(&self) -> bool

True if the reserved length exceeds the physical length. This means a vehicle is headed towards the queue already and is expected to not fit entirely inside.

pub fn room_for_car(&self, car: &Car) -> bool

Can a car start a turn for this queue?

pub fn free_reserved_space(&mut self, car: &Car)

Once a car has fully exited a queue, free up the space it was reserving.

pub fn target_lane_penalty(&self) -> (usize, usize)

Return a penalty for entering this queue, as opposed to some adjacent ones. Used for lane-changing. (number of vehicles, is there a bike here)

pub fn get_leader(&self, id: CarID) -> Option<CarID>

Find the vehicle in front of the specified input. None if the specified vehicle isn’t ACTIVE (not a blockage) in the queue at all, or they’re the front (with or without a laggy head).

pub fn add_static_blockage( &mut self, cause: CarID, front: Distance, back: Distance, idx: usize )

Record that a car is blocking a static portion of the queue (from front to back). Must use the index from can_block_from_driveway.

pub fn clear_static_blockage(&mut self, caused_by: CarID, idx: usize)

Record that a car is no longer blocking a static portion of the queue.

pub fn replace_car_with_dynamic_blockage(&mut self, car: &Car, idx: usize)

Record that a car is starting to change lanes away from this queue.

pub fn clear_dynamic_blockage(&mut self, caused_by: CarID, idx: usize)

Record that a car is no longer blocking a dynamic portion of the queue.

pub fn can_block_from_driveway( &self, pos: &Position, vehicle_len: Distance, now: Time, cars: &FixedMap<CarID, Car>, queues: &HashMap<Traversable, Queue> ) -> Option<usize>

True if a static blockage can be inserted into the queue without anything already there intersecting it. Returns the index if so. The position represents the front of the blockage.

pub fn get_active_cars(&self) -> Vec<CarID>

Get all cars in the queue, not including the laggy head or blockages.

TODO Do NOT use this for calculating indices or getting the leader/follower. Might be safer to just hide this and only expose number of active cars, first, and last.

pub fn remove_car_from_idx(&mut self, car: CarID, idx: usize)

Remove a car from a position. Need to separately do free_reserved_space.

pub fn is_car_at_front(&self, car: CarID) -> bool

If a car thinks it’s reached the end of the queue, double check. Blockages or laggy heads might be in the way.

Trait Implementations

impl Clone for Queue

fn clone(&self) -> Queue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Queue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Queue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Queue

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

where __S: Serializer,

Serialize this value into the given Serde serializer.