Struct sim::mechanics::intersection::IntersectionSimState

pub struct IntersectionSimState {
    state: BTreeMap<IntersectionID, State>,
    use_freeform_policy_everywhere: bool,
    dont_block_the_box: bool,
    break_turn_conflict_cycles: bool,
    handle_uber_turns: bool,
    disable_turn_conflicts: bool,
    blocked_by: BTreeSet<(CarID, CarID)>,
    events: Vec<Event>,
}

Manages conflicts at intersections. When an agent has reached the end of a lane, they call maybe_start_turn to make a Request. Based on the intersection type (stop sign, traffic signal, or a "freeform policy"), the Request gets queued or immediately accepted. When agents finish turns or when some time passes (for traffic signals), the intersection also gets a chance to react, maybe granting one of the pending requests.

Most of the complexity comes from attempting to workaround https://dabreegster.github.io/abstreet/trafficsim/gridlock.html.

Fields

state: BTreeMap<IntersectionID, State>

use_freeform_policy_everywhere: bool

dont_block_the_box: bool

break_turn_conflict_cycles: bool

handle_uber_turns: bool

disable_turn_conflicts: bool

blocked_by: BTreeSet<(CarID, CarID)>

events: Vec<Event>

Implementations

impl IntersectionSimState

pub fn new(
    map: &Map,
    scheduler: &mut Scheduler,
    opts: &SimOptions
) -> IntersectionSimState

pub fn nobody_headed_towards(&self, lane: LaneID, i: IntersectionID) -> bool

pub fn turn_finished(
    &mut self,
    now: Time,
    agent: AgentID,
    turn: TurnID,
    scheduler: &mut Scheduler,
    map: &Map
)

pub fn cancel_request(&mut self, agent: AgentID, turn: TurnID)

For deleting cars

pub fn space_freed(
    &mut self,
    now: Time,
    i: IntersectionID,
    scheduler: &mut Scheduler,
    map: &Map
)

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

Vanished at border, stopped biking, etc -- a vehicle disappeared, and didn't have one last turn.

fn wakeup_waiting(
    &self,
    now: Time,
    i: IntersectionID,
    scheduler: &mut Scheduler,
    map: &Map
)

pub fn update_intersection(
    &mut self,
    now: Time,
    id: IntersectionID,
    map: &Map,
    scheduler: &mut Scheduler
)

This is only triggered for traffic signals.

pub fn maybe_start_turn(
    &mut self,
    agent: AgentID,
    turn: TurnID,
    speed: Speed,
    now: Time,
    map: &Map,
    scheduler: &mut Scheduler,
    maybe_cars_and_queues: Option<(&Car, &FixedMap<CarID, Car>, &mut HashMap<Traversable, Queue>)>
) -> bool

For cars: The head car calls this when they're at the end of the lane WaitingToAdvance. If this returns true, then the head car MUST actually start this turn. For peds: Likewise -- only called when the ped is at the start of the turn. They must actually do the turn if this returns true.

If this returns false, the agent should NOT retry. IntersectionSimState will schedule a retry event at some point.

pub fn debug(&self, id: IntersectionID, map: &Map)

pub fn get_accepted_agents(&self, id: IntersectionID) -> Vec<(AgentID, TurnID)>

pub fn get_waiting_agents(
    &self,
    id: IntersectionID
) -> Vec<(AgentID, TurnID, Time)>

pub fn get_blocked_by(&self, a: AgentID) -> HashSet<AgentID>

pub fn collect_events(&mut self) -> Vec<Event>

pub fn delayed_intersections(
    &self,
    now: Time,
    threshold: Duration
) -> Vec<(IntersectionID, Time)>

returns intersections with travelers waiting for at least threshold since now, ordered so the longest delayed intersection is first.

pub fn current_stage_and_remaining_time(
    &self,
    now: Time,
    i: IntersectionID
) -> (usize, Duration)

pub fn handle_live_edited_traffic_signals(
    &mut self,
    now: Time,
    map: &Map,
    scheduler: &mut Scheduler
)

impl IntersectionSimState

fn stop_sign_policy(
    &mut self,
    req: &Request,
    map: &Map,
    sign: &ControlStopSign,
    now: Time,
    scheduler: &mut Scheduler
) -> bool

fn traffic_signal_policy(
    &mut self,
    req: &Request,
    map: &Map,
    signal: &ControlTrafficSignal,
    speed: Speed,
    now: Time,
    scheduler: Option<&mut Scheduler>
) -> bool

fn handle_accepted_conflicts(
    &mut self,
    req: &Request,
    map: &Map,
    maybe_cars_and_queues: Option<(&FixedMap<CarID, Car>, &HashMap<Traversable, Queue>)>
) -> bool

fn detect_conflict_cycle(
    &self,
    car: CarID,
    pair: (&FixedMap<CarID, Car>, &HashMap<Traversable, Queue>)
) -> Option<HashSet<CarID>>

Trait Implementations

impl Clone for IntersectionSimState

fn clone(&self) -> IntersectionSimState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for IntersectionSimState

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

Deserialize this value from the given Serde deserializer.

impl Serialize for IntersectionSimState

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

Serialize this value into the given Serde serializer.