Struct sim::mechanics::driving::DrivingSimState

pub struct DrivingSimState {
    cars: BTreeMap<CarID, Car>,
    queues: BTreeMap<Traversable, Queue>,
    events: Vec<Event>,
    recalc_lanechanging: bool,
    handle_uber_turns: bool,
}

Fields

cars: BTreeMap<CarID, Car>

queues: BTreeMap<Traversable, Queue>

events: Vec<Event>

recalc_lanechanging: bool

handle_uber_turns: bool

Implementations

impl DrivingSimState

pub fn new(
    map: &Map,
    recalc_lanechanging: bool,
    handle_uber_turns: bool
) -> DrivingSimState

pub fn start_car_on_lane(
    &mut self,
    now: Time,
    params: CreateCar,
    map: &Map,
    intersections: &IntersectionSimState,
    parking: &ParkingSimState,
    scheduler: &mut Scheduler
) -> bool

pub fn update_car(
    &mut self,
    id: CarID,
    now: Time,
    ctx: &mut Ctx,
    trips: &mut TripManager,
    transit: &mut TransitSimState,
    walking: &mut WalkingSimState
)

fn update_car_without_distances(
    &mut self,
    car: &mut Car,
    now: Time,
    ctx: &mut Ctx,
    transit: &mut TransitSimState
) -> bool

fn update_car_with_distances(
    &mut self,
    car: &mut Car,
    dists: &Vec<(CarID, Distance)>,
    idx: usize,
    now: Time,
    ctx: &mut Ctx,
    trips: &mut TripManager,
    transit: &mut TransitSimState,
    walking: &mut WalkingSimState
) -> bool

pub fn delete_car(&mut self, c: CarID, now: Time, ctx: &mut Ctx) -> Vehicle

fn delete_car_internal(
    &mut self,
    car: &mut Car,
    dists: Vec<(CarID, Distance)>,
    idx: usize,
    now: Time,
    ctx: &mut Ctx
)

pub fn update_laggy_head(&mut self, id: CarID, now: Time, ctx: &mut Ctx)

fn trim_last_steps(&mut self, car: &mut Car, now: Time, n: usize, ctx: &mut Ctx)

pub fn get_unzoomed_agents(&self, now: Time, map: &Map) -> Vec<UnzoomedAgent>

pub fn does_car_exist(&self, id: CarID) -> bool

pub fn get_all_draw_cars(
    &self,
    now: Time,
    map: &Map,
    transit: &TransitSimState
) -> Vec<DrawCarInput>

pub fn get_single_draw_car(
    &self,
    id: CarID,
    now: Time,
    map: &Map,
    transit: &TransitSimState
) -> Option<DrawCarInput>

pub fn get_draw_cars_on(
    &self,
    now: Time,
    on: Traversable,
    map: &Map,
    transit: &TransitSimState
) -> Vec<DrawCarInput>

pub fn debug_car(&self, id: CarID)

pub fn debug_lane(&self, id: LaneID)

pub fn agent_properties(&self, id: CarID, now: Time) -> AgentProperties

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

pub fn get_all_driving_paths(&self) -> Vec<&Path>

pub fn trace_route(
    &self,
    now: Time,
    id: CarID,
    map: &Map,
    dist_ahead: Option<Distance>
) -> Option<PolyLine>

pub fn percent_along_route(&self, id: CarID) -> f64

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

pub fn find_blockage_front(
    &self,
    start: CarID,
    map: &Map,
    intersections: &IntersectionSimState
) -> String

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

pub fn target_lane_penalty(&self, l: LaneID) -> (usize, usize)

pub fn find_trips_to_edited_parking(
    &self,
    spots: BTreeSet<ParkingSpot>
) -> Vec<(AgentID, TripID)>

Trait Implementations

impl Clone for DrivingSimState

fn clone(&self) -> DrivingSimState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for DrivingSimState

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

Deserialize this value from the given Serde deserializer.

impl Serialize for DrivingSimState

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

Serialize this value into the given Serde serializer.