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,
    blocked_by: BTreeSet<(CarID, CarID)>,
    events: Vec<Event>,
}

Fields

state: BTreeMap<IntersectionID, State>

use_freeform_policy_everywhere: bool

dont_block_the_box: bool

break_turn_conflict_cycles: bool

handle_uber_turns: bool

blocked_by: BTreeSet<(CarID, CarID)>

events: Vec<Event>

Implementations

impl IntersectionSimState

pub fn new(
    map: &Map,
    scheduler: &mut Scheduler,
    use_freeform_policy_everywhere: bool,
    dont_block_the_box: bool,
    break_turn_conflict_cycles: bool,
    handle_uber_turns: bool
) -> 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)

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

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

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
)

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, &BTreeMap<CarID, Car>, &mut BTreeMap<Traversable, Queue>)>
) -> bool

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

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

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 worst_delay(
    &self,
    now: Time,
    map: &Map
) -> (BTreeMap<RoadID, Duration>, BTreeMap<IntersectionID, Duration>)

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<(&BTreeMap<CarID, Car>, &BTreeMap<Traversable, Queue>)>
) -> bool

fn detect_conflict_cycle(
    &self,
    car: CarID,
    pair: (&BTreeMap<CarID, Car>, &BTreeMap<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.