Enum sim::mechanics::parking::ParkingSimState

pub enum ParkingSimState {
    Normal(NormalParkingSimState),
    Infinite(InfiniteParkingSimState),
}

Variants

Normal(NormalParkingSimState)

Tuple Fields

0: NormalParkingSimState

Infinite(InfiniteParkingSimState)

Tuple Fields

0: InfiniteParkingSimState

Implementations

impl ParkingSimState

pub fn new(map: &Map, infinite: bool, timer: &mut Timer<'_>) -> ParkingSimState

Counterintuitive: any spots located in blackholes are just not represented here. If somebody tries to drive from a blackholed spot, they couldn’t reach most places.

pub fn is_infinite(&self) -> bool

Trait Implementations

impl Clone for ParkingSimState

fn clone(&self) -> ParkingSimState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for ParkingSimState

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

Deserialize this value from the given Serde deserializer.

impl From<InfiniteParkingSimState> for ParkingSimState

fn from(v: InfiniteParkingSimState) -> ParkingSimState

Performs the conversion.

impl From<NormalParkingSimState> for ParkingSimState

fn from(v: NormalParkingSimState) -> ParkingSimState

Performs the conversion.

impl ParkingSim for ParkingSimState

fn handle_live_edits(
    &mut self,
    __enum_dispatch_arg_0: &Map,
    __enum_dispatch_arg_1: &mut Timer<'_>
) -> (Vec<ParkedCar>, Vec<CarID>)

Returns any cars that got very abruptly evicted from existence, and also cars actively moving into a deleted spot.

fn unreserve_spot(&mut self, __enum_dispatch_arg_0: CarID)

Needed when abruptly deleting a car, in case they’re being deleted during their last step.

fn canonical_pt(
    &self,
    __enum_dispatch_arg_0: CarID,
    __enum_dispatch_arg_1: &Map
) -> Option<Pt2D>

There’s no DrawCarInput for cars parked offstreet, so we need this.

fn get_all_free_spots(
    &self,
    __enum_dispatch_arg_0: Position,
    __enum_dispatch_arg_1: &Vehicle,
    __enum_dispatch_arg_2: BuildingID,
    __enum_dispatch_arg_3: &Map
) -> Vec<(ParkingSpot, Position)>

The vehicle’s front is currently at the given driving_pos. Returns all valid spots and their driving position.

fn get_all_parking_spots(&self) -> (Vec<ParkingSpot>, Vec<ParkingSpot>)

(Filled, available)

fn path_to_free_parking_spot(
    &self,
    __enum_dispatch_arg_0: LaneID,
    __enum_dispatch_arg_1: &Vehicle,
    __enum_dispatch_arg_2: BuildingID,
    __enum_dispatch_arg_3: &Map
) -> Option<(Vec<PathStep>, ParkingSpot, Position)>

Unrealistically assumes the driver has knowledge of currently free parking spots, even if they’re far away. Since they don’t reserve the spot in advance, somebody else can still beat them there, producing some nice, realistic churn if there’s too much contention. But the implementation has some internal jitter between different vehicles, to discourage everybody near one spot from all competing for it. Note the first PathStep is the turn after start, NOT PathStep::Lane(start).

fn get_free_onstreet_spots(
    &self,
    __enum_dispatch_arg_0: LaneID
) -> Vec<ParkingSpot>

fn get_free_offstreet_spots(
    &self,
    __enum_dispatch_arg_0: BuildingID
) -> Vec<ParkingSpot>

fn get_free_lot_spots(
    &self,
    __enum_dispatch_arg_0: ParkingLotID
) -> Vec<ParkingSpot>

fn reserve_spot(
    &mut self,
    __enum_dispatch_arg_0: ParkingSpot,
    __enum_dispatch_arg_1: CarID
)

fn remove_parked_car(&mut self, __enum_dispatch_arg_0: ParkedCar)

fn add_parked_car(&mut self, __enum_dispatch_arg_0: ParkedCar)

fn get_draw_cars(
    &self,
    __enum_dispatch_arg_0: LaneID,
    __enum_dispatch_arg_1: &Map
) -> Vec<DrawCarInput>

fn get_draw_cars_in_lots(
    &self,
    __enum_dispatch_arg_0: LaneID,
    __enum_dispatch_arg_1: &Map
) -> Vec<DrawCarInput>

fn get_draw_car(
    &self,
    __enum_dispatch_arg_0: CarID,
    __enum_dispatch_arg_1: &Map
) -> Option<DrawCarInput>

fn get_all_draw_cars(&self, __enum_dispatch_arg_0: &Map) -> Vec<DrawCarInput>

fn is_free(&self, __enum_dispatch_arg_0: ParkingSpot) -> bool

fn get_car_at_spot(
    &self,
    __enum_dispatch_arg_0: ParkingSpot
) -> Option<&ParkedCar>

fn spot_to_driving_pos(
    &self,
    __enum_dispatch_arg_0: ParkingSpot,
    __enum_dispatch_arg_1: &Vehicle,
    __enum_dispatch_arg_2: &Map
) -> Position

fn spot_to_sidewalk_pos(
    &self,
    __enum_dispatch_arg_0: ParkingSpot,
    __enum_dispatch_arg_1: &Map
) -> Position

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

fn lookup_parked_car(&self, __enum_dispatch_arg_0: CarID) -> Option<&ParkedCar>

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

fn all_parked_car_positions(
    &self,
    __enum_dispatch_arg_0: &Map
) -> Vec<(Position, PersonID)>

fn bldg_to_parked_cars(&self, __enum_dispatch_arg_0: BuildingID) -> Vec<CarID>

impl Serialize for ParkingSimState

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

Serialize this value into the given Serde serializer.

impl TryInto<InfiniteParkingSimState> for ParkingSimState

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(
    self
) -> Result<InfiniteParkingSimState, <Self as TryInto<InfiniteParkingSimState>>::Error>

Performs the conversion.

impl TryInto<NormalParkingSimState> for ParkingSimState

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(
    self
) -> Result<NormalParkingSimState, <Self as TryInto<NormalParkingSimState>>::Error>

Performs the conversion.