Struct RouteOptimization 

pub struct RouteOptimization { /* private fields */ }

Implements a client for the Route Optimization API.

Example

async fn sample(
) -> anyhow::Result<()> {
    let client = RouteOptimization::builder().build().await?;
    let response = client.optimize_tours()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

Service Description

A service for optimizing vehicle tours.

Validity of certain types of fields:

• google.protobuf.Timestamp
  • Times are in Unix time: seconds since 1970-01-01T00:00:00+00:00.
  • seconds must be in [0, 253402300799], i.e. in [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
  • nanos must be unset or set to 0.
• google.protobuf.Duration
  • seconds must be in [0, 253402300799], i.e. in [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
  • nanos must be unset or set to 0.
• google.type.LatLng
  • latitude must be in [-90.0, 90.0].
  • longitude must be in [-180.0, 180.0].
  • at least one of latitude and longitude must be non-zero.

Configuration

To configure RouteOptimization use the with_* methods in the type returned by builder(). The default configuration should work for most applications. Common configuration changes include

• with_endpoint(): by default this client uses the global default endpoint (https://routeoptimization.googleapis.com). Applications using regional endpoints or running in restricted networks (e.g. a network configured with Private Google Access with VPC Service Controls) may want to override this default.
• with_credentials(): by default this client uses Application Default Credentials. Applications using custom authentication may need to override this default.

Pooling and Cloning

RouteOptimization holds a connection pool internally, it is advised to create one and reuse it. You do not need to wrap RouteOptimization in an Rc or Arc to reuse it, because it already uses an Arc internally.

Implementations

impl RouteOptimization

pub fn builder() -> ClientBuilder

Returns a builder for RouteOptimization.

let client = RouteOptimization::builder().build().await?;

pub fn from_stub<T>(stub: impl Into<Arc<T>>) -> Self

where T: RouteOptimization + 'static,

Creates a new client from the provided stub.

The most common case for calling this function is in tests mocking the client’s behavior.

pub fn optimize_tours(&self) -> OptimizeTours

Sends an OptimizeToursRequest containing a ShipmentModel and returns an OptimizeToursResponse containing ShipmentRoutes, which are a set of routes to be performed by vehicles minimizing the overall cost.

A ShipmentModel model consists mainly of Shipments that need to be carried out and Vehicles that can be used to transport the Shipments. The ShipmentRoutes assign Shipments to Vehicles. More specifically, they assign a series of Visits to each vehicle, where a Visit corresponds to a VisitRequest, which is a pickup or delivery for a Shipment.

The goal is to provide an assignment of ShipmentRoutes to Vehicles that minimizes the total cost where cost has many components defined in the ShipmentModel.

Example

use google_maps_routeoptimization_v1::Result;
async fn sample(
   client: &RouteOptimization
) -> Result<()> {
    let response = client.optimize_tours()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn batch_optimize_tours(&self) -> BatchOptimizeTours

Optimizes vehicle tours for one or more OptimizeToursRequest messages as a batch.

This method is a Long Running Operation (LRO). The inputs for optimization (OptimizeToursRequest messages) and outputs (OptimizeToursResponse messages) are read from and written to Cloud Storage in user-specified format. Like the OptimizeTours method, each OptimizeToursRequest contains a ShipmentModel and returns an OptimizeToursResponse containing ShipmentRoute fields, which are a set of routes to be performed by vehicles minimizing the overall cost.

The user can poll operations.get to check the status of the LRO:

If the LRO done field is false, then at least one request is still being processed. Other requests may have completed successfully and their results are available in Cloud Storage.

If the LRO’s done field is true, then all requests have been processed. Any successfully processed requests will have their results available in Cloud Storage. Any requests that failed will not have their results available in Cloud Storage. If the LRO’s error field is set, then it contains the error from one of the failed requests.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_maps_routeoptimization_v1::Result;
async fn sample(
   client: &RouteOptimization
) -> Result<()> {
    let response = client.batch_optimize_tours()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn optimize_tours_long_running(&self) -> OptimizeToursLongRunning

This is a variant of the OptimizeTours method designed for optimizations with large timeout values. It should be preferred over the OptimizeTours method for optimizations that take longer than a few minutes.

The returned long-running operation (LRO) will have a name of the format <parent>/operations/<operation_id> and can be used to track progress of the computation. The metadata field type is OptimizeToursLongRunningMetadata. The response field type is OptimizeToursResponse, if successful.

Experimental: See https://developers.google.com/maps/tt/route-optimization/experimental/otlr/make-request for more details.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_maps_routeoptimization_v1::Result;
async fn sample(
   client: &RouteOptimization
) -> Result<()> {
    let response = client.optimize_tours_long_running()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn optimize_tours_uri(&self) -> OptimizeToursUri

This is a variant of the OptimizeToursLongRunning method designed for optimizations with large timeout values and large input/output sizes.

The client specifies the URI of the OptimizeToursRequest stored in Google Cloud Storage and the server writes the OptimizeToursResponse to a client-specified Google Cloud Storage URI.

This method should be preferred over the OptimizeTours method for optimizations that take longer than a few minutes and input/output sizes that are larger than 8MB, though it can be used for shorter and smaller optimizations as well.

The returned long-running operation (LRO) will have a name of the format <parent>/operations/<operation_id> and can be used to track progress of the computation. The metadata field type is OptimizeToursLongRunningMetadata. The response field type is OptimizeToursUriResponse, if successful.

Experimental: See https://developers.google.com/maps/tt/route-optimization/experimental/otlr/make-request for more details.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_maps_routeoptimization_v1::Result;
async fn sample(
   client: &RouteOptimization
) -> Result<()> {
    let response = client.optimize_tours_uri()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn get_operation(&self) -> GetOperation

Provides the Operations service functionality in this service.

Example

use google_maps_routeoptimization_v1::Result;
async fn sample(
   client: &RouteOptimization
) -> Result<()> {
    let response = client.get_operation()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

Trait Implementations

impl Clone for RouteOptimization

fn clone(&self) -> RouteOptimization

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RouteOptimization

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

Formats the value using the given formatter.