Google Maps

https://docs.rs/google_maps/latest/google_maps
Admin
An unofficial Google Maps Platform client library for Rust that implements the Directions API,...
Tokens:278,577
Snippets:3,590
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Waypoint Order Example

Source: https://docs.rs/google_maps/latest/google_maps/directions/response/route/struct.Route.html

Example of input and output waypoint ordering for route optimization.

```text
    Origin: Los Angeles
    Waypoints: Dallas, Bangor, Phoenix
    Destination: New York
```

```text
    Origin: Los Angeles
    Waypoints: Phoenix, Dallas, Bangor
    Destination: New York
```

--------------------------------

### Perform a Legacy Text Search Request

Source: https://docs.rs/google_maps/latest/google_maps/places_new/text_search/index.html

Example of a GET request using the legacy Text Search API.

```bash
curl -L -X GET \
'https://maps.googleapis.com/maps/api/place/textsearch/json?query=Spicy%20Vegetarian%20Food%20in%20Sydney%20Australia&key=API_KEY'
```

--------------------------------

### Partitioning a slice

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Examples demonstrating how to find the partition point of a slice based on a predicate.

```rust
assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

```rust
let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);
```

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

--------------------------------

### Place Details (New) GET Request

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_details/index.html

Example of a modern API request using headers for authentication and field masking.

```curl
curl -X GET -H 'Content-Type: application/json' \
-H "X-Goog-Api-Key: API_KEY" \
-H "X-Goog-FieldMask: displayName,formattedAddress" \
https://places.googleapis.com/v1/places/ChIJj61dQgK6j4AR4GeTYWZsKWw
```

--------------------------------

### Decimal macro usage examples

Source: https://docs.rs/google_maps/latest/google_maps/prelude/macro.dec.html

Demonstrates creating Decimal values with standard, radix-based, and exponent-based syntax.

```rust
use rust_decimal_macros::dec;

// If the reexportable feature is enabled, `Decimal` needs to be in scope
#[cfg(feature = "reexportable")]
use rust_decimal::Decimal;

let number = dec!(1.2345);
assert_eq!("1.2345", number.to_string());
let number = dec!(-5.4321);
assert_eq!("-5.4321", number.to_string());
let number = dec!(-0o1_777);
assert_eq!("-1023", number.to_string());
let number = dec!(-1_777, radix 8);
assert_eq!("-1023", number.to_string());
```

--------------------------------

### Download from a photo name string

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.ClientSettings.html

Example of fetching a photo using a direct photo name string.

```rust
// When you just have the name from storage or cache
let photo = client.place_photos_image("places/ChIJ.../photos/ABC")?
    .max_width_px(400)
    .execute()
    .await?;

std::fs::write("photo.jpg", &photo)?;
```

--------------------------------

### Decimal Constant Usage

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Decimal.html

Examples demonstrating the use of predefined Decimal constants.

```rust
assert_eq!(Decimal::MIN, dec!(-79_228_162_514_264_337_593_543_950_335));
```

```rust
assert_eq!(Decimal::MAX, dec!(79_228_162_514_264_337_593_543_950_335));
```

```rust
assert_eq!(Decimal::ZERO, dec!(0));
```

```rust
assert_eq!(Decimal::ONE, dec!(1));
```

```rust
assert_eq!(Decimal::NEGATIVE_ONE, dec!(-1));
```

```rust
assert_eq!(Decimal::TWO, dec!(2));
```

```rust
assert_eq!(Decimal::TEN, dec!(10));
```

```rust
assert_eq!(Decimal::ONE_HUNDRED, dec!(100));
```

```rust
assert_eq!(Decimal::ONE_THOUSAND, dec!(1000));
```

--------------------------------

### Executing a Place Photo Request

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_photos/image/struct.Request.html

Example showing how to configure and execute a request to retrieve a photo URL.

```rust
let photo_uri = client.place_photos_uri(&photo_info)?
    .max_width_px(800)
    .max_height_px(600)
    .skip_http_redirect(true)
    .execute()
    .await?;

println!("Photo URL: {}", photo_uri.uri());
```

--------------------------------

### Dimension constraints

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.ClientSettings.html

Examples of applying different dimension constraints to the image request.

```rust
// Width only - height scales proportionally
.max_width_px(800)

// Height only - width scales proportionally
.max_height_px(600)

// Both - scales to fit within box, maintaining aspect ratio
.max_width_px(800)
.max_height_px(600)
```

--------------------------------

### Convert Place to PhotoRequest

Source: https://docs.rs/google_maps/latest/google_maps/places_new/struct.Place.html

Examples of converting a Place or a reference to a Place into a PhotoRequest using TryFrom.

```rust
let place = client.place_details("ChIJ...")?.execute().await?;

// Get the first photo automatically
let request = PhotoRequest::try_from(&place)?;

// Equivalent to:
// let request = PhotoRequest::from(&place.photos()[0]);
```

```rust
let place = client.place_details("ChIJ...")?.execute().await?;

// Move place into the conversion
let request = PhotoRequest::try_from(place)?;
```

--------------------------------

### Example Query String

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_photos/image/struct.Request.html

A sample query string demonstrating the required parameters for the Place Photos API, where at least one of maxWidthPx or maxHeightPx must be provided.

```text
maxWidthPx=800&maxHeightPx=600&skipHttpRedirect=true
```

--------------------------------

### Nearby Search (Legacy) GET Request

Source: https://docs.rs/google_maps/latest/google_maps/places_new/nearby_search/index.html

Example of a legacy Nearby Search request using URL parameters via an HTTP GET method.

```curl
curl -L -X GET \
'https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=37.7937%2C-122.3965&radius=500&type=restaurant&key=API_KEY'
```

--------------------------------

### Configure client using builder pattern

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.ClientSettings.html

Example of initializing a Google Maps client with custom settings using the builder pattern.

```rust
let mut my_settings = google_maps::Client::try_new(YOUR_GOOGLE_API_KEY_HERE)
    .with_max_delay(std::time::Duration::from_secs(32))
    .with_max_retries(10)
    .with_rate(&Api::All, 1, std::time::Duration::from_secs(2))
    .build();
```

--------------------------------

### Legacy Place Autocomplete GET Request

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/index.html

Example of a legacy Place Autocomplete request using URL parameters via an HTTP GET method.

```curl
curl -L -X GET \
'https://maps.googleapis.com/maps/api/place/autocomplete/json?input=amoeba&types=establishment&location=37.76999%2C-122.44696&radius=500&key=YOUR_API_KEY'
```

--------------------------------

### Initialize and format StructuredFormat

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.StructuredFormat.html

Demonstrates creating a StructuredFormat instance and applying HTML highlighting to the main text.

```rust
// Place prediction
let format = StructuredFormat {
    main_text: FormattableText::from("Pizza Hut"),
    secondary_text: Some(FormattableText::from("123 Main St, San Francisco")),
};

println!("{}", format.main_text.text());     // "Pizza Hut"
println!("{}", format.secondary_text.unwrap().text()); // "123 Main St, San Francisco"

// With HTML highlighting on main text
let highlighted = format.main_text().to_html("strong");
// "<strong>Pizza</strong> Hut"
```

--------------------------------

### Retrieve URL Path

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_photos/uri/struct.Response.html

Use path() to get the percent-encoded path string. Always starts with a slash for base-capable URLs.

```rust
use url::{Url, ParseError};

let url = Url::parse("https://example.com/api/versions?page=2")?;
assert_eq!(url.path(), "/api/versions");

let url = Url::parse("https://example.com")?;
assert_eq!(url.path(), "/");

let url = Url::parse("https://example.com/countries/việt nam")?;
assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
```

--------------------------------

### Legacy Place Details GET Request

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_details/index.html

Example of a legacy API request using URL parameters for place ID and field selection.

```curl
curl -L -X GET \
'https://maps.googleapis.com/maps/api/place/details/json?place_id=ChIJj61dQgK6j4AR4GeTYWZsKWw&fields=name%2Cformatted_address&key=API_KEY'
```

--------------------------------

### Get Decimal mantissa

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Decimal.html

Returns the mantissa of the decimal number.

```rust

let num = dec!(-1.2345678);
assert_eq!(num.mantissa(), -12345678i128);
assert_eq!(num.scale(), 7);
```

--------------------------------

### Client::try_new

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Client.html

Initializes a new Google Maps client with the provided API key.

```APIDOC
## Client::try_new(key: impl Into<String>) -> Result<Self, GoogleMapsError>

### Description
Initializes the settings needed for a Google Cloud Maps API transaction using the provided API key.

### Parameters
- **key** (String) - Required - Your application’s API key for quota management.
```

--------------------------------

### Get slice length

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Get Decimal scale

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Decimal.html

Returns the scale (exponent) of the decimal number.

```rust
let num = Decimal::new(1234, 3);
assert_eq!(num.scale(), 3u32);
```

--------------------------------

### Client::try_new

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.ClientSettings.html

Initializes a new Google Maps client with the provided API key.

```APIDOC
## pub fn try_new(key: impl Into<String>) -> Result<Self, GoogleMapsError>

### Description
Initializes the settings needed for a Google Cloud Maps API transaction using the provided API key.

### Arguments
- **key** (impl Into<String>) - Required - Your application’s API key used for quota management.
```

--------------------------------

### Retrieve and display image size in KB

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_photos/image/struct.PhotoImage.html

Demonstrates how to fetch a photo image and print its size in kilobytes.

```rust
let photo = client.place_photo_image(&place)?.execute().await?;
println!("Downloaded {} KB", photo.size_bytes() / 1024);
```

--------------------------------

### Get vector length

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Returns the number of elements currently in the vector.

```rust
let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Get BTreeSet length

Source: https://docs.rs/google_maps/latest/google_maps/places_new/struct.PlaceTypeSet.html

Returns the number of elements currently in the set.

```rust
use std::collections::BTreeSet;

let mut v = BTreeSet::new();
assert_eq!(v.len(), 0);
v.insert(1);
assert_eq!(v.len(), 1);
```

--------------------------------

### Configure Dependencies

Source: https://docs.rs/google_maps/latest/google_maps/index.html

Add the google_maps crate to your Cargo.toml file.

```toml
[dependencies]
google_maps = "3.9"
```

--------------------------------

### Request::new

Source: https://docs.rs/google_maps/latest/google_maps/roads/snap_to_roads/request/struct.Request.html

Initializes a new Snap To Roads request builder with the required client and path parameters.

```APIDOC
## pub const fn new(client: &'r Client, path: Vec<LatLng>) -> Self

### Description
Initializes the builder pattern for a Snap To Roads query with the required, non-optional parameters.

### Parameters
- **client** (&'r Client) - Required - Your application’s Google Maps API client struct.
- **path** (Vec<LatLng>) - Required - The path to be snapped. For best quality, consecutive pairs of points should be within 300m of each other.
```

--------------------------------

### Get Route Summary

Source: https://docs.rs/google_maps/latest/google_maps/directions/response/route/struct.Route.html

Retrieves the summary text from the route if it exists.

```rust
let summary = route.get_summary();
```

--------------------------------

### week

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.NaiveDate.html

Returns the NaiveWeek that the date belongs to, starting with the Weekday specified.

```APIDOC
## pub const fn week(&self, start: Weekday) -> NaiveWeek

### Description
Returns the `NaiveWeek` that the date belongs to, starting with the `Weekday` specified.
```

--------------------------------

### Importing the Google Maps prelude

Source: https://docs.rs/google_maps/latest/google_maps/prelude/index.html

Use this glob import to bring all common structs and enums into the current scope.

```rust
use google_maps::prelude::*;
```

--------------------------------

### Initialize Vec via as_non_null

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Demonstrates manual initialization using the nightly-only as_non_null API.

```rust
#![feature(box_vec_non_null)]

// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_non_null();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        x_ptr.add(i).write(i as i32);
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

--------------------------------

### Execute RequestWithClient Directly

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.RequestWithClient.html

Shows how to manually construct and execute a request using the RequestWithClient wrapper.

```rust
let request = Request::default().with_client(&client);
let ctx = request.execute().await?;
```

--------------------------------

### Splitting mutable slices with split_off_mut

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Examples for removing a subslice from a mutable slice.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off_mut(..3).unwrap();

assert_eq!(slice, &mut ['d']);
assert_eq!(first_three, &mut ['a', 'b', 'c']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off_mut(5..));
assert_eq!(None, slice.split_off_mut(..5));
assert_eq!(None, slice.split_off_mut(..=4));
let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off_mut(..4));
```

--------------------------------

### TryFrom<(f64, f64, f64, f64)> for Viewport

Source: https://docs.rs/google_maps/latest/google_maps/places_new/struct.Viewport.html

Creates a Viewport instance from a tuple of four f64 values representing (low_lat, low_lng, high_lat, high_lng). This is a convenience method for creating viewports without explicitly constructing LatLng objects.

```APIDOC
## fn try_from((low_lat, low_lng, high_lat, high_lng): (f64, f64, f64, f64)) -> Result<Self, Self::Error>

### Description
Creates a viewport from a tuple of `(low_lat, low_lng, high_lat, high_lng)`. This convenience conversion allows creating a viewport from raw f64 coordinates without explicitly constructing `LatLng` points first.

### Parameters
- **(low_lat, low_lng, high_lat, high_lng)** (tuple of f64) - Required - The geographic bounds defined by low latitude, low longitude, high latitude, and high longitude.

### Returns
- **Result<Self, Self::Error>** - Returns the constructed Viewport or an error if the conversion fails.

### Example
```rust
let viewport = Viewport::try_from((37.0, -122.5, 38.0, -122.0))?;
```
```

--------------------------------

### Constructing DateTime with Local

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Local.html

Demonstrates creating DateTime instances using the Local struct and TimeZone methods.

```rust
use chrono::{DateTime, Local, TimeZone};

let dt1: DateTime<Local> = Local::now();
let dt2: DateTime<Local> = Local.timestamp_opt(0, 0).unwrap();
assert!(dt1 >= dt2);
```

--------------------------------

### Get day of week

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.NaiveDateTime.html

Retrieves the day of the week as a Weekday enum variant.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime, Weekday};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.weekday(), Weekday::Fri);
```

--------------------------------

### Get day of year (1-based)

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.NaiveDateTime.html

Retrieves the day of the year as a 1-based index.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);
```

--------------------------------

### Execute Autocomplete Request

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.RequestWithClientBuilder.html

Demonstrates how to configure and execute an autocomplete request using the builder pattern.

```rust
let response = client
    .autocomplete("pizza")
    .location_bias(LocationBias::circle(circle))
    .execute()
    .await?;
```

--------------------------------

### Initialize and use QueryPrediction

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.QueryPrediction.html

Demonstrates how to construct a QueryPrediction instance and access its text content for search operations.

```rust
let prediction = QueryPrediction {
    text: FormattableText {
        text: "pizza restaurants near me".to_string(),
        matches: vec![StringRange::new(0, 5)], // "pizza" matched
    },
    structured_format: Some(StructuredFormat {
        main_text: FormattableText::from("pizza restaurants"),
        secondary_text: Some(FormattableText::from("near me")),
    }),
};

// Use the query for a search
println!("Search for: {}", prediction.text.text());
// "pizza restaurants near me"
```

--------------------------------

### Get last element

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Returns the last element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Get first element

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Returns the first element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### Client::build

Source: https://docs.rs/google_maps/latest/google_maps/struct.Client.html

Completes the builder pattern configuration into a final Client structure.

```APIDOC
## pub fn build(&self) -> Self

### Description
Completes the builder pattern into a final structure.
```

--------------------------------

### Get Waypoint Order

Source: https://docs.rs/google_maps/latest/google_maps/directions/response/route/struct.Route.html

Retrieves the waypoint order as a CSV string if populated.

```rust
let waypoint_order = route.get_fare_text();
```

--------------------------------

### pub fn main_html(&self, tag: &str) -> String

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.StructuredFormat.html

Formats the main text with HTML highlighting. This method wraps main_text().to_html(tag) to quickly generate HTML-highlighted main text for UI display.

```APIDOC
## pub fn main_html(&self, tag: &str) -> String

### Description
Formats the main text with HTML highlighting. This method wraps main_text().to_html(tag) to quickly generate HTML-highlighted main text for UI display.

### Parameters
- **tag** (&str) - Required - The HTML tag to use for highlighting (e.g., "strong").

### Returns
- **String** - The HTML-formatted main text.
```

--------------------------------

### Get Route Warnings

Source: https://docs.rs/google_maps/latest/google_maps/directions/response/route/struct.Route.html

Retrieves route warnings as a pipe-separated string if any exist.

```rust
let warnings = route.get_warning();
```

--------------------------------

### pub fn autocomplete(&self, input: impl Into<String>) -> RequestWithClientBuilder<'_, SetInput<SetClient>>

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Client.html

Initiates a new Place Autocomplete request. This method returns a builder that allows for further configuration of the request before execution.

```APIDOC
## autocomplete

### Description
Returns place predictions and query predictions in response to an input text string. This is the entry point for starting an autocomplete session.

### Parameters
- **input** (String) - Required - The text string on which to search.
```

--------------------------------

### Get Fare Currency

Source: https://docs.rs/google_maps/latest/google_maps/directions/response/route/struct.Route.html

Retrieves the currency code from the fare struct if available.

```rust
let fare_currency = route.get_fare_currency();
```

--------------------------------

### place()

Source: https://docs.rs/google_maps/latest/google_maps/places_new/struct.GoogleMapsLinks.html

Returns a direct link to show the place on Google Maps.

```APIDOC
## pub fn place(&self) -> &String

### Description
Returns a direct link to show this place on Google Maps. This opens the main Google Maps view centered on the place, showing the marker and basic information.
```

--------------------------------

### Validate slice prefix with starts_with

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Checks if a slice starts with a given prefix.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### pub fn place_photos_uri<P>( &self, photo_request: P, ) -> Result<RequestBuilder<'_, SetSkipHttpRedirect<SetPhotoRequest<SetClient>>>, Error>

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Client.html

Fetches a photo URI from Google’s servers. This method returns a builder that allows you to configure size constraints (max_width_px or max_height_px) before executing the request.

```APIDOC
## Method: place_photos_uri

### Description
Fetches a temporary URL for a place photo. You must specify at least one dimension (max_width_px or max_height_px) to control the image size.

### Parameters
- **photo_request** (P: TryInto<PhotoRequest>) - Required - The input source for the photo, which can be a photo name string, a PhotoInfo reference, or a Place reference.

### Builder Methods
- **max_width_px(u32)** - Optional - Sets the maximum width of the image (1-4800 pixels).
- **max_height_px(u32)** - Optional - Sets the maximum height of the image (1-4800 pixels).

### Returns
- **PhotoUri** - Contains the temporary photo URL, metadata, and helper methods for HTML generation and image downloading.

### Errors
- Returns an error if the place has no photos, the photo name is invalid/expired, dimension constraints are missing/out of range, or if the network request fails.
```

--------------------------------

### Create DateTime from seconds using timestamp_opt

Source: https://docs.rs/google_maps/latest/google_maps/prelude/trait.TimeZone.html

Demonstrates creating a DateTime object from a UNIX timestamp in seconds using the non-panicking timestamp_opt method.

```rust
use chrono::{TimeZone, Utc};

assert_eq!(Utc.timestamp_opt(1431648000, 0).unwrap().to_string(), "2015-05-15 00:00:00 UTC");
```

--------------------------------

### Splitting the last element

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_photos/image/struct.PhotoImage.html

Examples of using split_off_last and split_off_last_mut to remove the last element.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';
```

--------------------------------

### Splitting the first element

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_photos/image/struct.PhotoImage.html

Examples of using split_off_first and split_off_first_mut to remove the first element.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

--------------------------------

### pub async fn next_autocomplete(&self, input: impl Into<String>, previous: ResponseWithContext) -> Result<ResponseWithContext, Error>

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.Client.html

Continues an existing Place Autocomplete session with new input, reusing the session token and parameters from the previous response.

```APIDOC
## next_autocomplete

### Description
Continues a Place Autocomplete session with new input. It reuses the session token and parameters from the previous response to maintain billing and relevance consistency.

### Parameters
- **input** (String) - Required - The new text string on which to search.
- **previous** (ResponseWithContext) - Required - The previous response context containing the session state.
```

--------------------------------

### Splitting first and last elements

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Examples for removing the first or last element of a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';
```

--------------------------------

### Viewport::try_from((f32, f32, f32, f32))

Source: https://docs.rs/google_maps/latest/google_maps/places_new/struct.Viewport.html

Creates a viewport from a tuple of (low_lat, low_lng, high_lat, high_lng) using f32 precision.

```APIDOC
## Viewport::try_from((f32, f32, f32, f32))

### Description
Creates a viewport from a tuple of (low_lat, low_lng, high_lat, high_lng) using f32 precision. This is a convenience conversion useful for lower-precision data or memory-constrained environments.

### Parameters
- **(low_lat, low_lng, high_lat, high_lng)** (tuple of f32) - Required - The coordinates defining the viewport boundaries.

### Example
```rust
let viewport = Viewport::try_from((37.0f32, -122.5f32, 38.0f32, -122.0f32))?;
```
```

--------------------------------

### Splitting slices with split_off

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Examples for removing a subslice from a slice using one-sided ranges.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off(..3).unwrap();

assert_eq!(slice, &['d']);
assert_eq!(first_three, &['a', 'b', 'c']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off(5..));
assert_eq!(None, slice.split_off(..5));
assert_eq!(None, slice.split_off(..=4));
let expected: &[char] = &['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off(..4));
```

--------------------------------

### Display human-readable file size

Source: https://docs.rs/google_maps/latest/google_maps/places_new/place_photos/image/struct.PhotoImage.html

Demonstrates how to fetch a photo image and print its size formatted with appropriate units.

```rust
let photo = client.place_photo_image(&place)?.execute().await?;
println!("File size: {}", photo.display_size()); // "245.3 KB"
```

--------------------------------

### Initialize Vec via as_mut_ptr

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Demonstrates manual initialization of vector elements using a raw mutable pointer obtained from as_mut_ptr.

```rust
// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_mut_ptr();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        *x_ptr.add(i) = i as i32;
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

--------------------------------

### Swapping elements in a slice

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.ResponseWithContext.html

Examples of swapping elements using safe and unchecked methods.

```rust
let mut v = ["a", "b", "c", "d", "e"];
v.swap(2, 4);
assert!(v == ["a", "b", "e", "d", "c"]);
```

```rust
#![feature(slice_swap_unchecked)]

let mut v = ["a", "b", "c", "d"];
// SAFETY: we know that 1 and 3 are both indices of the slice
unsafe { v.swap_unchecked(1, 3) };
assert!(v == ["a", "d", "c", "b"]);
```

--------------------------------

### Get Year from NaiveDateTime

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.NaiveDateTime.html

Retrieves the year component of a NaiveDateTime using the Datelike trait.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.year(), 2015);
```

--------------------------------

### Collect all text search results

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.ClientSettings.html

Demonstrates fetching the initial page and then using the convenience method to retrieve all remaining results.

```rust
use google_maps::places_new::Field;

// Get first page
let response = google_maps_client
    .text_search("coffee shops in Seattle")
    .field_mask([
        Field::PlacesDisplayName,
        Field::PlacesLocation,
        Field::NextPageToken,
    ])
    .execute()
    .await?;

// Collect all remaining pages
let all_places = google_maps_client
    .collect_all_text_search_pages(response)
    .await?;

println!("Found {} total places", all_places.len());
```

--------------------------------

### Fetch photo URI from a nearby search result

Source: https://docs.rs/google_maps/latest/google_maps/prelude/struct.ClientSettings.html

Demonstrates using a Place object to automatically fetch the first available photo.

```rust
// Find nearby restaurants and get their first photo
let places = client.nearby_search((37.7749, -122.4194, 5000.0))?
    .field_mask(FieldMask::specific([Field::PlacesPhotos, Field::PlacesDisplayName]))
    .included_primary_types(vec![PlaceType::Restaurant])
    .execute()
    .await?;

for place in places {
    // Pass the entire place - automatically uses first photo
    let photo_uri = client.place_photos_uri(&place)?
        .max_width_px(1024)
        .execute()
        .await?;

    println!("{}: {}", place.display_text().unwrap(), photo_uri);
}
```

--------------------------------

### Get Fare Text

Source: https://docs.rs/google_maps/latest/google_maps/directions/response/route/struct.Route.html

Retrieves the fare text representation if the fare struct is populated.

```rust
let fare_text = route.get_fare_text();
```

--------------------------------

### Get Fare Value

Source: https://docs.rs/google_maps/latest/google_maps/directions/response/route/struct.Route.html

Retrieves the fare value as a decimal if the fare struct is populated.

```rust
let fare_value = route.get_fare_value();
```

--------------------------------

### Unsafe mutable chunking

Source: https://docs.rs/google_maps/latest/google_maps/places_new/autocomplete/struct.Response.html

Example of using as_chunks_unchecked_mut to split a slice assuming no remainder exists.

```rust
let slice: &mut [char] = &mut ['l', 'o', 'r', 'e', 'm', '!'];
let chunks: &mut [[char; 1]] =
    // SAFETY: 1-element chunks never have remainder
    unsafe { slice.as_chunks_unchecked_mut() };
chunks[0] = ['L'];
assert_eq!(chunks, &[['L'], ['o'], ['r'], ['e'], ['m'], ['!']]);
let chunks: &mut [[char; 3]] =
    // SAFETY: The slice length (6) is a multiple of 3
    unsafe { slice.as_chunks_unchecked_mut() };
chunks[1] = ['a', 'x', '?'];
assert_eq!(slice, &['L', 'o', 'r', 'a', 'x', '?']);
```
Tokens:
Raw