Struct map_model::Map

pub struct Map {
    roads: Vec<Road>,
    lanes: Vec<Lane>,
    intersections: Vec<Intersection>,
    turns: BTreeMap<TurnID, Turn>,
    buildings: Vec<Building>,
    bus_stops: BTreeMap<BusStopID, BusStop>,
    bus_routes: Vec<BusRoute>,
    areas: Vec<Area>,
    parking_lots: Vec<ParkingLot>,
    boundary_polygon: Polygon,
    stop_signs: BTreeMap<IntersectionID, ControlStopSign>,
    traffic_signals: BTreeMap<IntersectionID, ControlTrafficSignal>,
    gps_bounds: GPSBounds,
    bounds: Bounds,
    config: MapConfig,
    pathfinder: Pathfinder,
    pathfinder_dirty: bool,
    zones: Vec<Zone>,
    city_name: String,
    name: String,
    edits: MapEdits,
}

Fields

roads: Vec<Road>

lanes: Vec<Lane>

intersections: Vec<Intersection>

turns: BTreeMap<TurnID, Turn>

buildings: Vec<Building>

bus_stops: BTreeMap<BusStopID, BusStop>

bus_routes: Vec<BusRoute>

areas: Vec<Area>

parking_lots: Vec<ParkingLot>

boundary_polygon: Polygon

stop_signs: BTreeMap<IntersectionID, ControlStopSign>

traffic_signals: BTreeMap<IntersectionID, ControlTrafficSignal>

gps_bounds: GPSBounds

bounds: Bounds

config: MapConfig

pathfinder: Pathfinder

pathfinder_dirty: bool

zones: Vec<Zone>

city_name: String

name: String

edits: MapEdits

Implementations

impl Map

pub fn get_edits(&self) -> &MapEdits

pub fn get_i_edit(&self, i: IntersectionID) -> EditIntersection

pub fn save_edits(&self)

pub fn must_apply_edits(
    &mut self,
    new_edits: MapEdits,
    timer: &mut Timer
) -> (BTreeSet<RoadID>, BTreeSet<TurnID>, BTreeSet<TurnID>, BTreeSet<IntersectionID>)

pub fn try_apply_edits(&mut self, new_edits: MapEdits, timer: &mut Timer)

fn apply_edits(
    &mut self,
    new_edits: MapEdits,
    enforce_valid: bool,
    timer: &mut Timer
) -> (BTreeSet<RoadID>, BTreeSet<TurnID>, BTreeSet<TurnID>, BTreeSet<IntersectionID>)

pub fn recalculate_pathfinding_after_edits(&mut self, timer: &mut Timer)

pub fn incremental_edit_traffic_signal(&mut self, signal: ControlTrafficSignal)

impl Map

pub fn create_from_raw(raw: RawMap, build_ch: bool, timer: &mut Timer) -> Map

impl Map

pub fn new(path: String, timer: &mut Timer) -> Map

pub fn corrupt_err(path: String, err: Error)

pub fn blank() -> Map

pub fn all_roads(&self) -> &Vec<Road>

pub fn all_lanes(&self) -> &Vec<Lane>

pub fn all_intersections(&self) -> &Vec<Intersection>

pub fn all_turns(&self) -> &BTreeMap<TurnID, Turn>

pub fn all_buildings(&self) -> &Vec<Building>

pub fn all_areas(&self) -> &Vec<Area>

pub fn all_parking_lots(&self) -> &Vec<ParkingLot>

pub fn all_zones(&self) -> &Vec<Zone>

pub fn maybe_get_r(&self, id: RoadID) -> Option<&Road>

pub fn maybe_get_l(&self, id: LaneID) -> Option<&Lane>

pub fn maybe_get_i(&self, id: IntersectionID) -> Option<&Intersection>

pub fn maybe_get_t(&self, id: TurnID) -> Option<&Turn>

pub fn maybe_get_b(&self, id: BuildingID) -> Option<&Building>

pub fn maybe_get_pl(&self, id: ParkingLotID) -> Option<&ParkingLot>

pub fn maybe_get_a(&self, id: AreaID) -> Option<&Area>

pub fn maybe_get_bs(&self, id: BusStopID) -> Option<&BusStop>

pub fn maybe_get_stop_sign(
    &self,
    id: IntersectionID
) -> Option<&ControlStopSign>

pub fn maybe_get_traffic_signal(
    &self,
    id: IntersectionID
) -> Option<&ControlTrafficSignal>

pub fn maybe_get_br(&self, route: BusRouteID) -> Option<&BusRoute>

pub fn get_r(&self, id: RoadID) -> &Road

pub fn get_l(&self, id: LaneID) -> &Lane

pub fn get_i(&self, id: IntersectionID) -> &Intersection

pub fn get_t(&self, id: TurnID) -> &Turn

pub fn get_b(&self, id: BuildingID) -> &Building

pub fn get_a(&self, id: AreaID) -> &Area

pub fn get_pl(&self, id: ParkingLotID) -> &ParkingLot

pub fn get_stop_sign(&self, id: IntersectionID) -> &ControlStopSign

pub fn get_traffic_signal(&self, id: IntersectionID) -> &ControlTrafficSignal

pub fn get_turns_in_intersection<'a>(
    &'a self,
    id: IntersectionID
) -> impl Iterator<Item = &'a Turn> + 'a

pub fn get_turns_from_lane(&self, l: LaneID) -> Vec<&Turn>

pub fn get_turns_to_lane(&self, l: LaneID) -> Vec<&Turn>

pub fn get_turn_between(
    &self,
    from: LaneID,
    to: LaneID,
    parent: IntersectionID
) -> Option<TurnID>

pub fn get_next_turns_and_lanes<'a>(
    &'a self,
    from: LaneID,
    parent: IntersectionID
) -> impl Iterator<Item = (&'a Turn, &'a Lane)> + 'a

pub fn get_turns_for(
    &self,
    from: LaneID,
    constraints: PathConstraints
) -> Vec<&Turn>

pub fn get_next_roads(&self, from: RoadID) -> impl Iterator<Item = RoadID>

pub fn get_parent(&self, id: LaneID) -> &Road

pub fn get_gps_bounds(&self) -> &GPSBounds

pub fn get_bounds(&self) -> &Bounds

pub fn get_city_name(&self) -> &String

pub fn get_name(&self) -> &String

pub fn all_bus_stops(&self) -> &BTreeMap<BusStopID, BusStop>

pub fn get_bs(&self, stop: BusStopID) -> &BusStop

pub fn get_br(&self, route: BusRouteID) -> &BusRoute

pub fn all_bus_routes(&self) -> &Vec<BusRoute>

pub fn get_bus_route(&self, name: &str) -> Option<&BusRoute>

pub fn get_routes_serving_stop(&self, stop: BusStopID) -> Vec<&BusRoute>

pub fn building_to_road(&self, id: BuildingID) -> &Road

pub fn all_incoming_borders(&self) -> Vec<&Intersection>

pub fn all_outgoing_borders(&self) -> Vec<&Intersection>

pub fn unsaved_edits(&self) -> bool

pub fn save(&self)

pub fn find_driving_lane_near_building(&self, b: BuildingID) -> LaneID

pub fn get_boundary_polygon(&self) -> &Polygon

pub fn pathfind(&self, req: PathRequest) -> Option<Path>

pub fn should_use_transit(
    &self,
    start: Position,
    end: Position
) -> Option<(BusStopID, Option<BusStopID>, BusRouteID)>

pub fn get_turn_group(&self, t: TurnID) -> Option<TurnGroupID>

pub fn find_r_by_osm_id(&self, id: OriginalRoad) -> Result<RoadID, String>

pub fn find_i_by_osm_id(&self, id: NodeID) -> Result<IntersectionID, String>

pub fn find_b_by_osm_id(&self, id: OsmID) -> Option<BuildingID>

pub fn find_br(&self, id: RelationID) -> Option<BusRouteID>

pub fn right_shift(
    &self,
    pl: PolyLine,
    width: Distance
) -> Result<PolyLine, String>

pub fn must_right_shift(&self, pl: PolyLine, width: Distance) -> PolyLine

pub fn left_shift(
    &self,
    pl: PolyLine,
    width: Distance
) -> Result<PolyLine, String>

pub fn must_left_shift(&self, pl: PolyLine, width: Distance) -> PolyLine

pub fn right_shift_line(&self, line: Line, width: Distance) -> Line

pub fn left_shift_line(&self, line: Line, width: Distance) -> Line

pub fn driving_side_angle(&self, a: Angle) -> Angle

pub fn get_driving_side(&self) -> DrivingSide

pub fn hack_override_offstreet_spots(&mut self, spots_per_bldg: usize)

pub fn hack_override_offstreet_spots_individ(
    &mut self,
    b: BuildingID,
    spots: usize
)

pub fn hack_override_bldg_type(
    &mut self,
    b: BuildingID,
    bldg_type: BuildingType
)

pub fn hack_override_orig_spawn_times(
    &mut self,
    br: BusRouteID,
    times: Vec<Time>
)

pub fn get_languages(&self) -> BTreeSet<&str>

Trait Implementations

impl<'de> Deserialize<'de> for Map

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Map

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

Serialize this value into the given Serde serializer.