Struct map_model::pathfind::Path

pub struct Path {
    steps: VecDeque<PathStep>,
    orig_req: PathRequest,
    total_length: Distance,
    crossed_so_far: Distance,
    uber_turns: VecDeque<UberTurn>,
    currently_inside_ut: Option<UberTurn>,
}

Fields

steps: VecDeque<PathStep>

orig_req: PathRequest

total_length: Distance

crossed_so_far: Distance

uber_turns: VecDeque<UberTurn>

currently_inside_ut: Option<UberTurn>

Implementations

impl Path

pub(crate) fn new(
    map: &Map,
    steps: Vec<PathStep>,
    orig_req: PathRequest,
    uber_turns: Vec<UberTurn>
) -> Path

pub fn dist_crossed_from_step(&self, map: &Map, step: &PathStep) -> Distance

Once we finish this PathStep, how much distance will be crossed? If the step is at the beginning or end of our path, then the full length may not be used.

pub fn one_step(req: PathRequest, map: &Map) -> Path

pub fn get_req(&self) -> &PathRequest

The original PathRequest used to produce this path. If the path has been modified since creation, the start and end of the request won't match up with the current path steps.

pub fn crossed_so_far(&self) -> Distance

pub fn total_length(&self) -> Distance

pub fn percent_dist_crossed(&self) -> f64

pub fn is_empty(&self) -> bool

pub fn is_last_step(&self) -> bool

pub fn isnt_last_step(&self) -> bool

pub fn currently_inside_ut(&self) -> &Option<UberTurn>

pub fn about_to_start_ut(&self) -> Option<&UberTurn>

pub fn shift(&mut self, map: &Map) -> PathStep

pub fn add(&mut self, step: PathStep, map: &Map)

pub fn is_upcoming_uber_turn_component(&self, t: TurnID) -> bool

pub fn modify_step(&mut self, idx: usize, step: PathStep, map: &Map)

Trusting the caller to do this in valid ways.

pub fn current_step(&self) -> PathStep

pub fn next_step(&self) -> PathStep

pub fn maybe_next_step(&self) -> Option<PathStep>

pub fn last_step(&self) -> PathStep

pub fn trace(
    &self,
    map: &Map,
    start_dist: Distance,
    dist_ahead: Option<Distance>
) -> Option<PolyLine>

dist_ahead is unlimited when None. Note this starts at the beginning (or end, for some walking paths) of the first lane, not accounting for the original request's start distance.

pub fn get_steps(&self) -> &VecDeque<PathStep>

fn append(&mut self, other: Path, map: &Map)

pub fn estimate_duration(
    &self,
    map: &Map,
    constraints: PathConstraints,
    max_speed: Option<Speed>
) -> Duration

Estimate how long following the path will take in the best case, assuming no traffic or delay at intersections. To determine the speed along each step, the agent following their path and their optional max_speed must be specified.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Path

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Path

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<Path> for Path

fn eq(&self, other: &Path) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Path) -> bool

This method tests for !=.

impl Serialize for Path

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Path