Struct ShipmentRoute 

#[non_exhaustive]
pub struct ShipmentRoute {

    pub vehicle_index: i32,
    pub vehicle_label: String,
    pub vehicle_start_time: Option<Timestamp>,
    pub vehicle_end_time: Option<Timestamp>,
    pub visits: Vec<Visit>,
    pub transitions: Vec<Transition>,
    pub has_traffic_infeasibilities: bool,
    pub route_polyline: Option<EncodedPolyline>,
    pub breaks: Vec<Break>,
    pub metrics: Option<AggregatedMetrics>,
    pub vehicle_fullness: Option<VehicleFullness>,
    pub route_costs: HashMap<String, f64>,
    pub route_total_cost: f64,
    /* private fields */
}

A vehicle’s route can be decomposed, along the time axis, like this (we assume there are n visits):

  |            |            |          |       |  T[2], |        |      |
  | Transition |  Visit #0  |          |       |  V[2], |        |      |
  |     #0     |    aka     |   T[1]   |  V[1] |  ...   | V[n-1] | T[n] |
  |  aka T[0]  |    V[0]    |          |       | V[n-2],|        |      |
  |            |            |          |       | T[n-1] |        |      |
  ^            ^            ^          ^       ^        ^        ^      ^
vehicle    V[0].start   V[0].end     V[1].   V[1].    V[n].    V[n]. vehicle
 start     (arrival)   (departure)   start   end      start    end     end

Note that we make a difference between:

• “punctual events”, such as the vehicle start and end and each visit’s start and end (aka arrival and departure). They happen at a given second.
• “time intervals”, such as the visits themselves, and the transition between visits. Though time intervals can sometimes have zero duration, i.e. start and end at the same second, they often have a positive duration.

Invariants:

• If there are n visits, there are n+1 transitions.
• A visit is always surrounded by a transition before it (same index) and a transition after it (index + 1).
• The vehicle start is always followed by transition #0.
• The vehicle end is always preceded by transition #n.

Zooming in, here is what happens during a Transition and a Visit:

---+-------------------------------------+-----------------------------+-->
   |           TRANSITION[i]             |           VISIT[i]          |
   |                                     |                             |
   |  * TRAVEL: the vehicle moves from   |      PERFORM the visit:     |
   |    VISIT[i-1].departure_location to |                             |
   |    VISIT[i].arrival_location, which |  * Spend some time:         |
   |    takes a given travel duration    |    the "visit duration".    |
   |    and distance                     |                             |
   |                                     |  * Load or unload           |
   |  * BREAKS: the driver may have      |    some quantities from the |
   |    breaks (e.g. lunch break).       |    vehicle: the "demand".   |
   |                                     |                             |
   |  * WAIT: the driver/vehicle does    |                             |
   |    nothing. This can happen for     |                             |
   |    many reasons, for example when   |                             |
   |    the vehicle reaches the next     |                             |
   |    event's destination before the   |                             |
   |    start of its time window         |                             |
   |                                     |                             |
   |  * DELAY: *right before* the next   |                             |
   |    arrival. E.g. the vehicle and/or |                             |
   |    driver spends time unloading.    |                             |
   |                                     |                             |
---+-------------------------------------+-----------------------------+-->
   ^                                     ^                             ^
V[i-1].end                           V[i].start                    V[i].end

Lastly, here is how the TRAVEL, BREAKS, DELAY and WAIT can be arranged during a transition.

• They don’t overlap.
• The DELAY is unique and must be a contiguous period of time right before the next visit (or vehicle end). Thus, it suffice to know the delay duration to know its start and end time.
• The BREAKS are contiguous, non-overlapping periods of time. The response specifies the start time and duration of each break.
• TRAVEL and WAIT are “preemptable”: they can be interrupted several times during this transition. Clients can assume that travel happens “as soon as possible” and that “wait” fills the remaining time.

A (complex) example:

                               TRANSITION[i]
--++-----+-----------------------------------------------------------++-->
  ||     |       |           |       |           |         |         ||
  ||  T  |   B   |     T     |       |     B     |         |    D    ||
  ||  r  |   r   |     r     |   W   |     r     |    W    |    e    ||
  ||  a  |   e   |     a     |   a   |     e     |    a    |    l    ||
  ||  v  |   a   |     v     |   i   |     a     |    i    |    a    ||
  ||  e  |   k   |     e     |   t   |     k     |    t    |    y    ||
  ||  l  |       |     l     |       |           |         |         ||
  ||     |       |           |       |           |         |         ||
--++-----------------------------------------------------------------++-->

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

vehicle_index: i32

Vehicle performing the route, identified by its index in the source ShipmentModel.

vehicle_label: String

Label of the vehicle performing this route, equal to ShipmentModel.vehicles(vehicle_index).label, if specified.

vehicle_start_time: Option<Timestamp>

Time at which the vehicle starts its route.

vehicle_end_time: Option<Timestamp>

Time at which the vehicle finishes its route.

visits: Vec<Visit>

Ordered sequence of visits representing a route. visits[i] is the i-th visit in the route. If this field is empty, the vehicle is considered as unused.

transitions: Vec<Transition>

Ordered list of transitions for the route.

has_traffic_infeasibilities: bool

When OptimizeToursRequest.consider_road_traffic, is set to true, this field indicates that inconsistencies in route timings are predicted using traffic-based travel duration estimates. There may be insufficient time to complete traffic-adjusted travel, delays, and breaks between visits, before the first visit, or after the last visit, while still satisfying the visit and vehicle time windows. For example,

  start_time(previous_visit) + duration(previous_visit) +
  travel_duration(previous_visit, next_visit) > start_time(next_visit)

Arrival at next_visit will likely happen later than its current time window due the increased estimate of travel time travel_duration(previous_visit, next_visit) due to traffic. Also, a break may be forced to overlap with a visit due to an increase in travel time estimates and visit or break time window restrictions.

route_polyline: Option<EncodedPolyline>

The encoded polyline representation of the route. This field is only populated if OptimizeToursRequest.populate_polylines is set to true.

breaks: Vec<Break>

Breaks scheduled for the vehicle performing this route. The breaks sequence represents time intervals, each starting at the corresponding start_time and lasting duration seconds.

metrics: Option<AggregatedMetrics>

Duration, distance and load metrics for this route. The fields of AggregatedMetrics are summed over all ShipmentRoute.transitions or ShipmentRoute.visits, depending on the context.

vehicle_fullness: Option<VehicleFullness>

VehicleFullness field for computing how close the capped metrics are to their respective vehicle limits. Its fields are ratios between a capped metric field (e.g. AggregatedMetrics.travel_distance_meters) and the related vehicle limit (e.g. Vehicle.route_distance_limit).

Experimental: This field’s behavior or existence may change in future.

route_costs: HashMap<String, f64>

Cost of the route, broken down by cost-related request fields. The keys are proto paths, relative to the input OptimizeToursRequest, e.g. “model.shipments.pickups.cost”, and the values are the total cost generated by the corresponding cost field, aggregated over the whole route. In other words, costs[“model.shipments.pickups.cost”] is the sum of all pickup costs over the route. All costs defined in the model are reported in detail here with the exception of costs related to TransitionAttributes that are only reported in an aggregated way as of 2022/01.

route_total_cost: f64

Total cost of the route. The sum of all costs in the cost map.

Implementations

impl ShipmentRoute

pub fn new() -> Self

Creates a new default instance.

pub fn set_vehicle_index<T: Into<i32>>(self, v: T) -> Self

Sets the value of vehicle_index.

Example

let x = ShipmentRoute::new().set_vehicle_index(42);

pub fn set_vehicle_label<T: Into<String>>(self, v: T) -> Self

Sets the value of vehicle_label.

Example

let x = ShipmentRoute::new().set_vehicle_label("example");

pub fn set_vehicle_start_time<T>(self, v: T) -> Self

where T: Into<Timestamp>,

Sets the value of vehicle_start_time.

Example

use wkt::Timestamp;
let x = ShipmentRoute::new().set_vehicle_start_time(Timestamp::default()/* use setters */);

pub fn set_or_clear_vehicle_start_time<T>(self, v: Option<T>) -> Self

where T: Into<Timestamp>,

Sets or clears the value of vehicle_start_time.

Example

use wkt::Timestamp;
let x = ShipmentRoute::new().set_or_clear_vehicle_start_time(Some(Timestamp::default()/* use setters */));
let x = ShipmentRoute::new().set_or_clear_vehicle_start_time(None::<Timestamp>);

pub fn set_vehicle_end_time<T>(self, v: T) -> Self

where T: Into<Timestamp>,

Sets the value of vehicle_end_time.

Example

use wkt::Timestamp;
let x = ShipmentRoute::new().set_vehicle_end_time(Timestamp::default()/* use setters */);

pub fn set_or_clear_vehicle_end_time<T>(self, v: Option<T>) -> Self

where T: Into<Timestamp>,

Sets or clears the value of vehicle_end_time.

Example

use wkt::Timestamp;
let x = ShipmentRoute::new().set_or_clear_vehicle_end_time(Some(Timestamp::default()/* use setters */));
let x = ShipmentRoute::new().set_or_clear_vehicle_end_time(None::<Timestamp>);

pub fn set_visits<T, V>(self, v: T) -> Self

where T: IntoIterator<Item = V>, V: Into<Visit>,

Sets the value of visits.

Example

use google_maps_routeoptimization_v1::model::shipment_route::Visit;
let x = ShipmentRoute::new()
    .set_visits([
        Visit::default()/* use setters */,
        Visit::default()/* use (different) setters */,
    ]);

pub fn set_transitions<T, V>(self, v: T) -> Self

where T: IntoIterator<Item = V>, V: Into<Transition>,

Sets the value of transitions.

Example

use google_maps_routeoptimization_v1::model::shipment_route::Transition;
let x = ShipmentRoute::new()
    .set_transitions([
        Transition::default()/* use setters */,
        Transition::default()/* use (different) setters */,
    ]);

pub fn set_has_traffic_infeasibilities<T: Into<bool>>(self, v: T) -> Self

Sets the value of has_traffic_infeasibilities.

Example

let x = ShipmentRoute::new().set_has_traffic_infeasibilities(true);

pub fn set_route_polyline<T>(self, v: T) -> Self

where T: Into<EncodedPolyline>,

Sets the value of route_polyline.

Example

use google_maps_routeoptimization_v1::model::shipment_route::EncodedPolyline;
let x = ShipmentRoute::new().set_route_polyline(EncodedPolyline::default()/* use setters */);

pub fn set_or_clear_route_polyline<T>(self, v: Option<T>) -> Self

where T: Into<EncodedPolyline>,

Sets or clears the value of route_polyline.

Example

use google_maps_routeoptimization_v1::model::shipment_route::EncodedPolyline;
let x = ShipmentRoute::new().set_or_clear_route_polyline(Some(EncodedPolyline::default()/* use setters */));
let x = ShipmentRoute::new().set_or_clear_route_polyline(None::<EncodedPolyline>);

pub fn set_breaks<T, V>(self, v: T) -> Self

where T: IntoIterator<Item = V>, V: Into<Break>,

Sets the value of breaks.

Example

use google_maps_routeoptimization_v1::model::shipment_route::Break;
let x = ShipmentRoute::new()
    .set_breaks([
        Break::default()/* use setters */,
        Break::default()/* use (different) setters */,
    ]);

pub fn set_metrics<T>(self, v: T) -> Self

where T: Into<AggregatedMetrics>,

Sets the value of metrics.

Example

use google_maps_routeoptimization_v1::model::AggregatedMetrics;
let x = ShipmentRoute::new().set_metrics(AggregatedMetrics::default()/* use setters */);

pub fn set_or_clear_metrics<T>(self, v: Option<T>) -> Self

where T: Into<AggregatedMetrics>,

Sets or clears the value of metrics.

Example

use google_maps_routeoptimization_v1::model::AggregatedMetrics;
let x = ShipmentRoute::new().set_or_clear_metrics(Some(AggregatedMetrics::default()/* use setters */));
let x = ShipmentRoute::new().set_or_clear_metrics(None::<AggregatedMetrics>);

pub fn set_vehicle_fullness<T>(self, v: T) -> Self

where T: Into<VehicleFullness>,

Sets the value of vehicle_fullness.

Example

use google_maps_routeoptimization_v1::model::VehicleFullness;
let x = ShipmentRoute::new().set_vehicle_fullness(VehicleFullness::default()/* use setters */);

pub fn set_or_clear_vehicle_fullness<T>(self, v: Option<T>) -> Self

where T: Into<VehicleFullness>,

Sets or clears the value of vehicle_fullness.

Example

use google_maps_routeoptimization_v1::model::VehicleFullness;
let x = ShipmentRoute::new().set_or_clear_vehicle_fullness(Some(VehicleFullness::default()/* use setters */));
let x = ShipmentRoute::new().set_or_clear_vehicle_fullness(None::<VehicleFullness>);

pub fn set_route_costs<T, K, V>(self, v: T) -> Self

where T: IntoIterator<Item = (K, V)>, K: Into<String>, V: Into<f64>,

Sets the value of route_costs.

Example

let x = ShipmentRoute::new().set_route_costs([
    ("key0", 123.5),
    ("key1", 456.5),
]);

pub fn set_route_total_cost<T: Into<f64>>(self, v: T) -> Self

Sets the value of route_total_cost.

Example

let x = ShipmentRoute::new().set_route_total_cost(42.0);

Trait Implementations

impl Clone for ShipmentRoute

fn clone(&self) -> ShipmentRoute

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShipmentRoute

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

Formats the value using the given formatter.

impl Default for ShipmentRoute

fn default() -> ShipmentRoute

Returns the “default value” for a type.

impl Message for ShipmentRoute

fn typename() -> &'static str

The typename of this message.

impl PartialEq for ShipmentRoute

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ShipmentRoute