Struct google_maps::directions::response::step::Step

pub struct Step {
    pub distance: DirectionsDistance,
    pub duration: DirectionsDuration,
    pub end_location: LatLng,
    pub html_instructions: String,
    pub maneuver: Option<DrivingManeuver>,
    pub polyline: Polyline,
    pub start_location: LatLng,
    pub steps: Option<Vec<Step>>,
    pub transit_details: Option<TransitDetails>,
    pub travel_mode: TravelMode,
}

Each element in the steps array defines a single step of the calculated directions. A step is the most atomic unit of a direction’s route, containing a single step describing a specific, single instruction on the journey. E.g. “Turn left at W. 4th St.” The step not only describes the instruction but also contains distance and duration information relating to how this step relates to the following step. For example, a step denoted as “Merge onto I-80 West” may contain a duration of “37 miles” and “40 minutes,” indicating that the next step is 37 miles/40 minutes from this step.

When using the Directions API to search for transit directions, the steps array will include additional transit details in the form of a transit_details array. If the directions include multiple modes of transportation, detailed directions will be provided for walking or driving steps in an inner steps array. For example, a walking step will include directions from the start and end locations: “Walk to Innes Ave & Fitch St”. That step will include detailed walking directions for that route in the inner steps array, such as: “Head north-west”, “Turn left onto Arelious Walker”, and “Turn left onto Innes Ave”.

Fields

distance: DirectionsDistance

The distance covered by this step. This property may be undefined as the distance may be unknown.

duration: DirectionsDuration

The typical time required to perform this step in seconds and in text form. This property may be undefined as the duration may be unknown.

end_location: LatLng

The ending location of this step.

html_instructions: String

Instructions for this step.

maneuver: Option<DrivingManeuver>

Contains the action to take for the current step (turn left, merge, straight, etc.). This field is used to determine which icon to display.

polyline: Polyline

Contains a single points object that holds an encoded polyline representation of the step. This polyline is an approximate (smoothed) path of the step. (Corresponds to path in the Directions.Step interface.)

start_location: LatLng

The starting location of this step.

steps: Option<Vec<Step>>

Contains detailed directions for walking or driving steps in transit directions. Substeps are only available when travel_mode is set to “transit”. The inner steps array is of the same type as steps.

transit_details: Option<TransitDetails>

Transit-specific details about this step. This property will be undefined unless the travel mode of this step is TravelMode::Transit.

travel_mode: TravelMode

The mode of travel used in this step.

Implementations

impl Step

pub fn get_maneuver(&self) -> Option<String>

A helper function for destructuring (or serializing) the optional maneuver field. If the ManeuverType enum in the step is populated, this function will return it as a String. If the ManeuverType enum is empty, this function will return None.

let maneuver = step.get_maneuver();

Trait Implementations

impl Clone for Step

fn clone(&self) -> Step

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Step

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Step

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

Deserialize this value from the given Serde deserializer.

impl Hash for Step

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Step> for Step

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

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

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

This method tests for !=.

impl Serialize for Step

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

Serialize this value into the given Serde serializer.

impl Eq for Step

impl StructuralEq for Step

impl StructuralPartialEq for Step