#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FallbackInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__routing_mode,
__reason,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FallbackInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"routingMode" => Ok(__FieldTag::__routing_mode),
"routing_mode" => Ok(__FieldTag::__routing_mode),
"reason" => Ok(__FieldTag::__reason),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FallbackInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FallbackInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__routing_mode => {
if !fields.insert(__FieldTag::__routing_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for routing_mode",
));
}
result.routing_mode = map.next_value::<std::option::Option<crate::model::FallbackRoutingMode>>()?.unwrap_or_default();
}
__FieldTag::__reason => {
if !fields.insert(__FieldTag::__reason) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reason",
));
}
result.reason = map
.next_value::<std::option::Option<crate::model::FallbackReason>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GeocodingResults {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__origin,
__destination,
__intermediates,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GeocodingResults")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"origin" => Ok(__FieldTag::__origin),
"destination" => Ok(__FieldTag::__destination),
"intermediates" => Ok(__FieldTag::__intermediates),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GeocodingResults;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GeocodingResults")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__origin => {
if !fields.insert(__FieldTag::__origin) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for origin",
));
}
result.origin = map
.next_value::<std::option::Option<crate::model::GeocodedWaypoint>>(
)?;
}
__FieldTag::__destination => {
if !fields.insert(__FieldTag::__destination) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for destination",
));
}
result.destination = map
.next_value::<std::option::Option<crate::model::GeocodedWaypoint>>(
)?;
}
__FieldTag::__intermediates => {
if !fields.insert(__FieldTag::__intermediates) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for intermediates",
));
}
result.intermediates =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::GeocodedWaypoint>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GeocodedWaypoint {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__geocoder_status,
__intermediate_waypoint_request_index,
__type,
__partial_match,
__place_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GeocodedWaypoint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"geocoderStatus" => Ok(__FieldTag::__geocoder_status),
"geocoder_status" => Ok(__FieldTag::__geocoder_status),
"intermediateWaypointRequestIndex" => {
Ok(__FieldTag::__intermediate_waypoint_request_index)
}
"intermediate_waypoint_request_index" => {
Ok(__FieldTag::__intermediate_waypoint_request_index)
}
"type" => Ok(__FieldTag::__type),
"partialMatch" => Ok(__FieldTag::__partial_match),
"partial_match" => Ok(__FieldTag::__partial_match),
"placeId" => Ok(__FieldTag::__place_id),
"place_id" => Ok(__FieldTag::__place_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GeocodedWaypoint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GeocodedWaypoint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__geocoder_status => {
if !fields.insert(__FieldTag::__geocoder_status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for geocoder_status",
));
}
result.geocoder_status = map
.next_value::<std::option::Option<google_cloud_rpc::model::Status>>(
)?;
}
__FieldTag::__intermediate_waypoint_request_index => {
if !fields.insert(__FieldTag::__intermediate_waypoint_request_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for intermediate_waypoint_request_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.intermediate_waypoint_request_index =
map.next_value::<__With>()?.0;
}
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__partial_match => {
if !fields.insert(__FieldTag::__partial_match) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for partial_match",
));
}
result.partial_match = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__place_id => {
if !fields.insert(__FieldTag::__place_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for place_id",
));
}
result.place_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::LocalizedTime {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__time,
__time_zone,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for LocalizedTime")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"time" => Ok(__FieldTag::__time),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LocalizedTime;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LocalizedTime")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__time => {
if !fields.insert(__FieldTag::__time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time",
));
}
result.time = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__time_zone => {
if !fields.insert(__FieldTag::__time_zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_zone",
));
}
result.time_zone = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Location {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__lat_lng,
__heading,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Location")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"latLng" => Ok(__FieldTag::__lat_lng),
"lat_lng" => Ok(__FieldTag::__lat_lng),
"heading" => Ok(__FieldTag::__heading),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Location;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Location")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__lat_lng => {
if !fields.insert(__FieldTag::__lat_lng) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for lat_lng",
));
}
result.lat_lng = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
;
}
__FieldTag::__heading => {
if !fields.insert(__FieldTag::__heading) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for heading",
));
}
struct __With(std::option::Option<wkt::Int32Value>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.heading = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::NavigationInstruction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__maneuver,
__instructions,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for NavigationInstruction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"maneuver" => Ok(__FieldTag::__maneuver),
"instructions" => Ok(__FieldTag::__instructions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NavigationInstruction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NavigationInstruction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__maneuver => {
if !fields.insert(__FieldTag::__maneuver) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for maneuver",
));
}
result.maneuver = map
.next_value::<std::option::Option<crate::model::Maneuver>>()?
.unwrap_or_default();
}
__FieldTag::__instructions => {
if !fields.insert(__FieldTag::__instructions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instructions",
));
}
result.instructions = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Polyline {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__encoded_polyline,
__geo_json_linestring,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Polyline")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"encodedPolyline" => Ok(__FieldTag::__encoded_polyline),
"encoded_polyline" => Ok(__FieldTag::__encoded_polyline),
"geoJsonLinestring" => Ok(__FieldTag::__geo_json_linestring),
"geo_json_linestring" => Ok(__FieldTag::__geo_json_linestring),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Polyline;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Polyline")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__encoded_polyline => {
if !fields.insert(__FieldTag::__encoded_polyline) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for encoded_polyline",
));
}
if result.polyline_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `polyline_type`, a oneof with full ID .google.maps.routing.v2.Polyline.encoded_polyline, latest field was encodedPolyline",
));
}
result.polyline_type = std::option::Option::Some(
crate::model::polyline::PolylineType::EncodedPolyline(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__geo_json_linestring => {
if !fields.insert(__FieldTag::__geo_json_linestring) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for geo_json_linestring",
));
}
if result.polyline_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `polyline_type`, a oneof with full ID .google.maps.routing.v2.Polyline.geo_json_linestring, latest field was geoJsonLinestring",
));
}
result.polyline_type = std::option::Option::Some(
crate::model::polyline::PolylineType::GeoJsonLinestring(
map.next_value::<std::option::Option<std::boxed::Box<wkt::Struct>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PolylineDetails {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__tunnel_info,
__flyover_info,
__narrow_road_info,
__bridge_info,
__skyway_info,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PolylineDetails")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"tunnelInfo" => Ok(__FieldTag::__tunnel_info),
"tunnel_info" => Ok(__FieldTag::__tunnel_info),
"flyoverInfo" => Ok(__FieldTag::__flyover_info),
"flyover_info" => Ok(__FieldTag::__flyover_info),
"narrowRoadInfo" => Ok(__FieldTag::__narrow_road_info),
"narrow_road_info" => Ok(__FieldTag::__narrow_road_info),
"bridgeInfo" => Ok(__FieldTag::__bridge_info),
"bridge_info" => Ok(__FieldTag::__bridge_info),
"skywayInfo" => Ok(__FieldTag::__skyway_info),
"skyway_info" => Ok(__FieldTag::__skyway_info),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PolylineDetails;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PolylineDetails")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__tunnel_info => {
if !fields.insert(__FieldTag::__tunnel_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tunnel_info",
));
}
result.tunnel_info = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::polyline_details::TunnelInfo>,
>>()?
.unwrap_or_default();
}
__FieldTag::__flyover_info => {
if !fields.insert(__FieldTag::__flyover_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for flyover_info",
));
}
result.flyover_info = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::polyline_details::FlyoverInfo>,
>>()?
.unwrap_or_default();
}
__FieldTag::__narrow_road_info => {
if !fields.insert(__FieldTag::__narrow_road_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for narrow_road_info",
));
}
result.narrow_road_info = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::polyline_details::NarrowRoadInfo>,
>>()?
.unwrap_or_default();
}
__FieldTag::__bridge_info => {
if !fields.insert(__FieldTag::__bridge_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bridge_info",
));
}
result.bridge_info = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::polyline_details::BridgeInfo>,
>>()?
.unwrap_or_default();
}
__FieldTag::__skyway_info => {
if !fields.insert(__FieldTag::__skyway_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for skyway_info",
));
}
result.skyway_info = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::polyline_details::SkywayInfo>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::polyline_details::PolylinePointIndex {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_index,
__end_index,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PolylinePointIndex")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startIndex" => Ok(__FieldTag::__start_index),
"start_index" => Ok(__FieldTag::__start_index),
"endIndex" => Ok(__FieldTag::__end_index),
"end_index" => Ok(__FieldTag::__end_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::polyline_details::PolylinePointIndex;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PolylinePointIndex")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_index => {
if !fields.insert(__FieldTag::__start_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.start_index = map.next_value::<__With>()?.0;
}
__FieldTag::__end_index => {
if !fields.insert(__FieldTag::__end_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.end_index = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::polyline_details::TunnelInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__tunnel_presence,
__polyline_point_index,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TunnelInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"tunnelPresence" => Ok(__FieldTag::__tunnel_presence),
"tunnel_presence" => Ok(__FieldTag::__tunnel_presence),
"polylinePointIndex" => Ok(__FieldTag::__polyline_point_index),
"polyline_point_index" => Ok(__FieldTag::__polyline_point_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::polyline_details::TunnelInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TunnelInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__tunnel_presence => {
if !fields.insert(__FieldTag::__tunnel_presence) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tunnel_presence",
));
}
result.tunnel_presence = map
.next_value::<std::option::Option<
crate::model::polyline_details::RoadFeatureState,
>>()?
.unwrap_or_default();
}
__FieldTag::__polyline_point_index => {
if !fields.insert(__FieldTag::__polyline_point_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_point_index",
));
}
result.polyline_point_index = map.next_value::<std::option::Option<
crate::model::polyline_details::PolylinePointIndex,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::polyline_details::BridgeInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__bridge_presence,
__polyline_point_index,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BridgeInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"bridgePresence" => Ok(__FieldTag::__bridge_presence),
"bridge_presence" => Ok(__FieldTag::__bridge_presence),
"polylinePointIndex" => Ok(__FieldTag::__polyline_point_index),
"polyline_point_index" => Ok(__FieldTag::__polyline_point_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::polyline_details::BridgeInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BridgeInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__bridge_presence => {
if !fields.insert(__FieldTag::__bridge_presence) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bridge_presence",
));
}
result.bridge_presence = map
.next_value::<std::option::Option<
crate::model::polyline_details::RoadFeatureState,
>>()?
.unwrap_or_default();
}
__FieldTag::__polyline_point_index => {
if !fields.insert(__FieldTag::__polyline_point_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_point_index",
));
}
result.polyline_point_index = map.next_value::<std::option::Option<
crate::model::polyline_details::PolylinePointIndex,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::polyline_details::SkywayInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__skyway_presence,
__polyline_point_index,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SkywayInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"skywayPresence" => Ok(__FieldTag::__skyway_presence),
"skyway_presence" => Ok(__FieldTag::__skyway_presence),
"polylinePointIndex" => Ok(__FieldTag::__polyline_point_index),
"polyline_point_index" => Ok(__FieldTag::__polyline_point_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::polyline_details::SkywayInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SkywayInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__skyway_presence => {
if !fields.insert(__FieldTag::__skyway_presence) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for skyway_presence",
));
}
result.skyway_presence = map
.next_value::<std::option::Option<
crate::model::polyline_details::RoadFeatureState,
>>()?
.unwrap_or_default();
}
__FieldTag::__polyline_point_index => {
if !fields.insert(__FieldTag::__polyline_point_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_point_index",
));
}
result.polyline_point_index = map.next_value::<std::option::Option<
crate::model::polyline_details::PolylinePointIndex,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::polyline_details::FlyoverInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__flyover_presence,
__polyline_point_index,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FlyoverInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"flyoverPresence" => Ok(__FieldTag::__flyover_presence),
"flyover_presence" => Ok(__FieldTag::__flyover_presence),
"polylinePointIndex" => Ok(__FieldTag::__polyline_point_index),
"polyline_point_index" => Ok(__FieldTag::__polyline_point_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::polyline_details::FlyoverInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FlyoverInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__flyover_presence => {
if !fields.insert(__FieldTag::__flyover_presence) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for flyover_presence",
));
}
result.flyover_presence = map
.next_value::<std::option::Option<
crate::model::polyline_details::RoadFeatureState,
>>()?
.unwrap_or_default();
}
__FieldTag::__polyline_point_index => {
if !fields.insert(__FieldTag::__polyline_point_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_point_index",
));
}
result.polyline_point_index = map.next_value::<std::option::Option<
crate::model::polyline_details::PolylinePointIndex,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::polyline_details::NarrowRoadInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__narrow_road_presence,
__polyline_point_index,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for NarrowRoadInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"narrowRoadPresence" => Ok(__FieldTag::__narrow_road_presence),
"narrow_road_presence" => Ok(__FieldTag::__narrow_road_presence),
"polylinePointIndex" => Ok(__FieldTag::__polyline_point_index),
"polyline_point_index" => Ok(__FieldTag::__polyline_point_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::polyline_details::NarrowRoadInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NarrowRoadInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__narrow_road_presence => {
if !fields.insert(__FieldTag::__narrow_road_presence) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for narrow_road_presence",
));
}
result.narrow_road_presence = map
.next_value::<std::option::Option<
crate::model::polyline_details::RoadFeatureState,
>>()?
.unwrap_or_default();
}
__FieldTag::__polyline_point_index => {
if !fields.insert(__FieldTag::__polyline_point_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_point_index",
));
}
result.polyline_point_index = map.next_value::<std::option::Option<
crate::model::polyline_details::PolylinePointIndex,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Route {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__route_labels,
__legs,
__distance_meters,
__duration,
__static_duration,
__polyline,
__description,
__warnings,
__viewport,
__travel_advisory,
__optimized_intermediate_waypoint_index,
__localized_values,
__route_token,
__polyline_details,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Route")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"routeLabels" => Ok(__FieldTag::__route_labels),
"route_labels" => Ok(__FieldTag::__route_labels),
"legs" => Ok(__FieldTag::__legs),
"distanceMeters" => Ok(__FieldTag::__distance_meters),
"distance_meters" => Ok(__FieldTag::__distance_meters),
"duration" => Ok(__FieldTag::__duration),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
"polyline" => Ok(__FieldTag::__polyline),
"description" => Ok(__FieldTag::__description),
"warnings" => Ok(__FieldTag::__warnings),
"viewport" => Ok(__FieldTag::__viewport),
"travelAdvisory" => Ok(__FieldTag::__travel_advisory),
"travel_advisory" => Ok(__FieldTag::__travel_advisory),
"optimizedIntermediateWaypointIndex" => {
Ok(__FieldTag::__optimized_intermediate_waypoint_index)
}
"optimized_intermediate_waypoint_index" => {
Ok(__FieldTag::__optimized_intermediate_waypoint_index)
}
"localizedValues" => Ok(__FieldTag::__localized_values),
"localized_values" => Ok(__FieldTag::__localized_values),
"routeToken" => Ok(__FieldTag::__route_token),
"route_token" => Ok(__FieldTag::__route_token),
"polylineDetails" => Ok(__FieldTag::__polyline_details),
"polyline_details" => Ok(__FieldTag::__polyline_details),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Route;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Route")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__route_labels => {
if !fields.insert(__FieldTag::__route_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for route_labels",
));
}
result.route_labels = map.next_value::<std::option::Option<std::vec::Vec<crate::model::RouteLabel>>>()?.unwrap_or_default();
}
__FieldTag::__legs => {
if !fields.insert(__FieldTag::__legs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for legs",
));
}
result.legs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::RouteLeg>>>()?.unwrap_or_default();
}
__FieldTag::__distance_meters => {
if !fields.insert(__FieldTag::__distance_meters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance_meters",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.distance_meters =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__duration => {
if !fields.insert(__FieldTag::__duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for duration",
));
}
result.duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__polyline => {
if !fields.insert(__FieldTag::__polyline) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline",
));
}
result.polyline =
map.next_value::<std::option::Option<crate::model::Polyline>>()?;
}
__FieldTag::__description => {
if !fields.insert(__FieldTag::__description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for description",
));
}
result.description = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__warnings => {
if !fields.insert(__FieldTag::__warnings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for warnings",
));
}
result.warnings = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__viewport => {
if !fields.insert(__FieldTag::__viewport) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for viewport",
));
}
result.viewport = map.next_value::<std::option::Option<google_geo_type::model::Viewport>>()?
;
}
__FieldTag::__travel_advisory => {
if !fields.insert(__FieldTag::__travel_advisory) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_advisory",
));
}
result.travel_advisory = map.next_value::<std::option::Option<crate::model::RouteTravelAdvisory>>()?
;
}
__FieldTag::__optimized_intermediate_waypoint_index => {
if !fields.insert(__FieldTag::__optimized_intermediate_waypoint_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for optimized_intermediate_waypoint_index",
));
}
struct __With(std::option::Option<std::vec::Vec<i32>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::I32>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.optimized_intermediate_waypoint_index =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__localized_values => {
if !fields.insert(__FieldTag::__localized_values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for localized_values",
));
}
result.localized_values = map.next_value::<std::option::Option<crate::model::route::RouteLocalizedValues>>()?
;
}
__FieldTag::__route_token => {
if !fields.insert(__FieldTag::__route_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for route_token",
));
}
result.route_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__polyline_details => {
if !fields.insert(__FieldTag::__polyline_details) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_details",
));
}
result.polyline_details = map
.next_value::<std::option::Option<crate::model::PolylineDetails>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::route::RouteLocalizedValues {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__distance,
__duration,
__static_duration,
__transit_fare,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLocalizedValues")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"distance" => Ok(__FieldTag::__distance),
"duration" => Ok(__FieldTag::__duration),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
"transitFare" => Ok(__FieldTag::__transit_fare),
"transit_fare" => Ok(__FieldTag::__transit_fare),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route::RouteLocalizedValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLocalizedValues")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__distance => {
if !fields.insert(__FieldTag::__distance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance",
));
}
result.distance = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__duration => {
if !fields.insert(__FieldTag::__duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for duration",
));
}
result.duration = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__transit_fare => {
if !fields.insert(__FieldTag::__transit_fare) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transit_fare",
));
}
result.transit_fare = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteTravelAdvisory {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__toll_info,
__speed_reading_intervals,
__fuel_consumption_microliters,
__route_restrictions_partially_ignored,
__transit_fare,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteTravelAdvisory")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"tollInfo" => Ok(__FieldTag::__toll_info),
"toll_info" => Ok(__FieldTag::__toll_info),
"speedReadingIntervals" => Ok(__FieldTag::__speed_reading_intervals),
"speed_reading_intervals" => Ok(__FieldTag::__speed_reading_intervals),
"fuelConsumptionMicroliters" => {
Ok(__FieldTag::__fuel_consumption_microliters)
}
"fuel_consumption_microliters" => {
Ok(__FieldTag::__fuel_consumption_microliters)
}
"routeRestrictionsPartiallyIgnored" => {
Ok(__FieldTag::__route_restrictions_partially_ignored)
}
"route_restrictions_partially_ignored" => {
Ok(__FieldTag::__route_restrictions_partially_ignored)
}
"transitFare" => Ok(__FieldTag::__transit_fare),
"transit_fare" => Ok(__FieldTag::__transit_fare),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteTravelAdvisory;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteTravelAdvisory")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__toll_info => {
if !fields.insert(__FieldTag::__toll_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for toll_info",
));
}
result.toll_info =
map.next_value::<std::option::Option<crate::model::TollInfo>>()?;
}
__FieldTag::__speed_reading_intervals => {
if !fields.insert(__FieldTag::__speed_reading_intervals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for speed_reading_intervals",
));
}
result.speed_reading_intervals = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::SpeedReadingInterval>,
>>()?
.unwrap_or_default();
}
__FieldTag::__fuel_consumption_microliters => {
if !fields.insert(__FieldTag::__fuel_consumption_microliters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fuel_consumption_microliters",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.fuel_consumption_microliters =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__route_restrictions_partially_ignored => {
if !fields.insert(__FieldTag::__route_restrictions_partially_ignored) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for route_restrictions_partially_ignored",
));
}
result.route_restrictions_partially_ignored = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__transit_fare => {
if !fields.insert(__FieldTag::__transit_fare) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transit_fare",
));
}
result.transit_fare = map
.next_value::<std::option::Option<google_cloud_type::model::Money>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteLegTravelAdvisory {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__toll_info,
__speed_reading_intervals,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLegTravelAdvisory")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"tollInfo" => Ok(__FieldTag::__toll_info),
"toll_info" => Ok(__FieldTag::__toll_info),
"speedReadingIntervals" => Ok(__FieldTag::__speed_reading_intervals),
"speed_reading_intervals" => Ok(__FieldTag::__speed_reading_intervals),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteLegTravelAdvisory;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLegTravelAdvisory")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__toll_info => {
if !fields.insert(__FieldTag::__toll_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for toll_info",
));
}
result.toll_info =
map.next_value::<std::option::Option<crate::model::TollInfo>>()?;
}
__FieldTag::__speed_reading_intervals => {
if !fields.insert(__FieldTag::__speed_reading_intervals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for speed_reading_intervals",
));
}
result.speed_reading_intervals = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::SpeedReadingInterval>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteLegStepTravelAdvisory {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__speed_reading_intervals,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLegStepTravelAdvisory")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"speedReadingIntervals" => Ok(__FieldTag::__speed_reading_intervals),
"speed_reading_intervals" => Ok(__FieldTag::__speed_reading_intervals),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteLegStepTravelAdvisory;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLegStepTravelAdvisory")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__speed_reading_intervals => {
if !fields.insert(__FieldTag::__speed_reading_intervals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for speed_reading_intervals",
));
}
result.speed_reading_intervals = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::SpeedReadingInterval>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteLeg {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__distance_meters,
__duration,
__static_duration,
__polyline,
__start_location,
__end_location,
__steps,
__travel_advisory,
__localized_values,
__steps_overview,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLeg")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"distanceMeters" => Ok(__FieldTag::__distance_meters),
"distance_meters" => Ok(__FieldTag::__distance_meters),
"duration" => Ok(__FieldTag::__duration),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
"polyline" => Ok(__FieldTag::__polyline),
"startLocation" => Ok(__FieldTag::__start_location),
"start_location" => Ok(__FieldTag::__start_location),
"endLocation" => Ok(__FieldTag::__end_location),
"end_location" => Ok(__FieldTag::__end_location),
"steps" => Ok(__FieldTag::__steps),
"travelAdvisory" => Ok(__FieldTag::__travel_advisory),
"travel_advisory" => Ok(__FieldTag::__travel_advisory),
"localizedValues" => Ok(__FieldTag::__localized_values),
"localized_values" => Ok(__FieldTag::__localized_values),
"stepsOverview" => Ok(__FieldTag::__steps_overview),
"steps_overview" => Ok(__FieldTag::__steps_overview),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteLeg;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLeg")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__distance_meters => {
if !fields.insert(__FieldTag::__distance_meters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance_meters",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.distance_meters =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__duration => {
if !fields.insert(__FieldTag::__duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for duration",
));
}
result.duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__polyline => {
if !fields.insert(__FieldTag::__polyline) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline",
));
}
result.polyline =
map.next_value::<std::option::Option<crate::model::Polyline>>()?;
}
__FieldTag::__start_location => {
if !fields.insert(__FieldTag::__start_location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_location",
));
}
result.start_location =
map.next_value::<std::option::Option<crate::model::Location>>()?;
}
__FieldTag::__end_location => {
if !fields.insert(__FieldTag::__end_location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_location",
));
}
result.end_location =
map.next_value::<std::option::Option<crate::model::Location>>()?;
}
__FieldTag::__steps => {
if !fields.insert(__FieldTag::__steps) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for steps",
));
}
result.steps = map.next_value::<std::option::Option<std::vec::Vec<crate::model::RouteLegStep>>>()?.unwrap_or_default();
}
__FieldTag::__travel_advisory => {
if !fields.insert(__FieldTag::__travel_advisory) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_advisory",
));
}
result.travel_advisory = map.next_value::<std::option::Option<crate::model::RouteLegTravelAdvisory>>()?
;
}
__FieldTag::__localized_values => {
if !fields.insert(__FieldTag::__localized_values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for localized_values",
));
}
result.localized_values = map.next_value::<std::option::Option<
crate::model::route_leg::RouteLegLocalizedValues,
>>()?;
}
__FieldTag::__steps_overview => {
if !fields.insert(__FieldTag::__steps_overview) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for steps_overview",
));
}
result.steps_overview = map.next_value::<std::option::Option<crate::model::route_leg::StepsOverview>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::route_leg::RouteLegLocalizedValues {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__distance,
__duration,
__static_duration,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLegLocalizedValues")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"distance" => Ok(__FieldTag::__distance),
"duration" => Ok(__FieldTag::__duration),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route_leg::RouteLegLocalizedValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLegLocalizedValues")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__distance => {
if !fields.insert(__FieldTag::__distance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance",
));
}
result.distance = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__duration => {
if !fields.insert(__FieldTag::__duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for duration",
));
}
result.duration = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::route_leg::StepsOverview {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__multi_modal_segments,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StepsOverview")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"multiModalSegments" => Ok(__FieldTag::__multi_modal_segments),
"multi_modal_segments" => Ok(__FieldTag::__multi_modal_segments),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route_leg::StepsOverview;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StepsOverview")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__multi_modal_segments => {
if !fields.insert(__FieldTag::__multi_modal_segments) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for multi_modal_segments",
));
}
result.multi_modal_segments = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::route_leg::steps_overview::MultiModalSegment,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::route_leg::steps_overview::MultiModalSegment {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__step_start_index,
__step_end_index,
__navigation_instruction,
__travel_mode,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for MultiModalSegment")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"stepStartIndex" => Ok(__FieldTag::__step_start_index),
"step_start_index" => Ok(__FieldTag::__step_start_index),
"stepEndIndex" => Ok(__FieldTag::__step_end_index),
"step_end_index" => Ok(__FieldTag::__step_end_index),
"navigationInstruction" => Ok(__FieldTag::__navigation_instruction),
"navigation_instruction" => Ok(__FieldTag::__navigation_instruction),
"travelMode" => Ok(__FieldTag::__travel_mode),
"travel_mode" => Ok(__FieldTag::__travel_mode),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route_leg::steps_overview::MultiModalSegment;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MultiModalSegment")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__step_start_index => {
if !fields.insert(__FieldTag::__step_start_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for step_start_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.step_start_index = map.next_value::<__With>()?.0;
}
__FieldTag::__step_end_index => {
if !fields.insert(__FieldTag::__step_end_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for step_end_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.step_end_index = map.next_value::<__With>()?.0;
}
__FieldTag::__navigation_instruction => {
if !fields.insert(__FieldTag::__navigation_instruction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for navigation_instruction",
));
}
result.navigation_instruction = map.next_value::<std::option::Option<crate::model::NavigationInstruction>>()?
;
}
__FieldTag::__travel_mode => {
if !fields.insert(__FieldTag::__travel_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_mode",
));
}
result.travel_mode = map
.next_value::<std::option::Option<crate::model::RouteTravelMode>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteLegStep {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__distance_meters,
__static_duration,
__polyline,
__start_location,
__end_location,
__navigation_instruction,
__travel_advisory,
__localized_values,
__transit_details,
__travel_mode,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLegStep")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"distanceMeters" => Ok(__FieldTag::__distance_meters),
"distance_meters" => Ok(__FieldTag::__distance_meters),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
"polyline" => Ok(__FieldTag::__polyline),
"startLocation" => Ok(__FieldTag::__start_location),
"start_location" => Ok(__FieldTag::__start_location),
"endLocation" => Ok(__FieldTag::__end_location),
"end_location" => Ok(__FieldTag::__end_location),
"navigationInstruction" => Ok(__FieldTag::__navigation_instruction),
"navigation_instruction" => Ok(__FieldTag::__navigation_instruction),
"travelAdvisory" => Ok(__FieldTag::__travel_advisory),
"travel_advisory" => Ok(__FieldTag::__travel_advisory),
"localizedValues" => Ok(__FieldTag::__localized_values),
"localized_values" => Ok(__FieldTag::__localized_values),
"transitDetails" => Ok(__FieldTag::__transit_details),
"transit_details" => Ok(__FieldTag::__transit_details),
"travelMode" => Ok(__FieldTag::__travel_mode),
"travel_mode" => Ok(__FieldTag::__travel_mode),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteLegStep;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLegStep")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__distance_meters => {
if !fields.insert(__FieldTag::__distance_meters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance_meters",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.distance_meters =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__polyline => {
if !fields.insert(__FieldTag::__polyline) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline",
));
}
result.polyline =
map.next_value::<std::option::Option<crate::model::Polyline>>()?;
}
__FieldTag::__start_location => {
if !fields.insert(__FieldTag::__start_location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_location",
));
}
result.start_location =
map.next_value::<std::option::Option<crate::model::Location>>()?;
}
__FieldTag::__end_location => {
if !fields.insert(__FieldTag::__end_location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_location",
));
}
result.end_location =
map.next_value::<std::option::Option<crate::model::Location>>()?;
}
__FieldTag::__navigation_instruction => {
if !fields.insert(__FieldTag::__navigation_instruction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for navigation_instruction",
));
}
result.navigation_instruction = map.next_value::<std::option::Option<crate::model::NavigationInstruction>>()?
;
}
__FieldTag::__travel_advisory => {
if !fields.insert(__FieldTag::__travel_advisory) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_advisory",
));
}
result.travel_advisory = map.next_value::<std::option::Option<crate::model::RouteLegStepTravelAdvisory>>()?
;
}
__FieldTag::__localized_values => {
if !fields.insert(__FieldTag::__localized_values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for localized_values",
));
}
result.localized_values = map.next_value::<std::option::Option<
crate::model::route_leg_step::RouteLegStepLocalizedValues,
>>()?;
}
__FieldTag::__transit_details => {
if !fields.insert(__FieldTag::__transit_details) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transit_details",
));
}
result.transit_details = map.next_value::<std::option::Option<crate::model::RouteLegStepTransitDetails>>()?
;
}
__FieldTag::__travel_mode => {
if !fields.insert(__FieldTag::__travel_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_mode",
));
}
result.travel_mode = map
.next_value::<std::option::Option<crate::model::RouteTravelMode>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::route_leg_step::RouteLegStepLocalizedValues {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__distance,
__static_duration,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLegStepLocalizedValues")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"distance" => Ok(__FieldTag::__distance),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route_leg_step::RouteLegStepLocalizedValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLegStepLocalizedValues")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__distance => {
if !fields.insert(__FieldTag::__distance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance",
));
}
result.distance = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteLegStepTransitDetails {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__stop_details,
__localized_values,
__headsign,
__headway,
__transit_line,
__stop_count,
__trip_short_text,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteLegStepTransitDetails")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"stopDetails" => Ok(__FieldTag::__stop_details),
"stop_details" => Ok(__FieldTag::__stop_details),
"localizedValues" => Ok(__FieldTag::__localized_values),
"localized_values" => Ok(__FieldTag::__localized_values),
"headsign" => Ok(__FieldTag::__headsign),
"headway" => Ok(__FieldTag::__headway),
"transitLine" => Ok(__FieldTag::__transit_line),
"transit_line" => Ok(__FieldTag::__transit_line),
"stopCount" => Ok(__FieldTag::__stop_count),
"stop_count" => Ok(__FieldTag::__stop_count),
"tripShortText" => Ok(__FieldTag::__trip_short_text),
"trip_short_text" => Ok(__FieldTag::__trip_short_text),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteLegStepTransitDetails;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteLegStepTransitDetails")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__stop_details => {
if !fields.insert(__FieldTag::__stop_details) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for stop_details",
));
}
result.stop_details = map.next_value::<std::option::Option<
crate::model::route_leg_step_transit_details::TransitStopDetails,
>>()?;
}
__FieldTag::__localized_values => {
if !fields.insert(__FieldTag::__localized_values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for localized_values",
));
}
result.localized_values = map.next_value::<std::option::Option<crate::model::route_leg_step_transit_details::TransitDetailsLocalizedValues>>()?
;
}
__FieldTag::__headsign => {
if !fields.insert(__FieldTag::__headsign) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for headsign",
));
}
result.headsign = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__headway => {
if !fields.insert(__FieldTag::__headway) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for headway",
));
}
result.headway =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__transit_line => {
if !fields.insert(__FieldTag::__transit_line) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transit_line",
));
}
result.transit_line =
map.next_value::<std::option::Option<crate::model::TransitLine>>()?;
}
__FieldTag::__stop_count => {
if !fields.insert(__FieldTag::__stop_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for stop_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.stop_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__trip_short_text => {
if !fields.insert(__FieldTag::__trip_short_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for trip_short_text",
));
}
result.trip_short_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::route_leg_step_transit_details::TransitStopDetails
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__arrival_stop,
__arrival_time,
__departure_stop,
__departure_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransitStopDetails")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"arrivalStop" => Ok(__FieldTag::__arrival_stop),
"arrival_stop" => Ok(__FieldTag::__arrival_stop),
"arrivalTime" => Ok(__FieldTag::__arrival_time),
"arrival_time" => Ok(__FieldTag::__arrival_time),
"departureStop" => Ok(__FieldTag::__departure_stop),
"departure_stop" => Ok(__FieldTag::__departure_stop),
"departureTime" => Ok(__FieldTag::__departure_time),
"departure_time" => Ok(__FieldTag::__departure_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route_leg_step_transit_details::TransitStopDetails;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransitStopDetails")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__arrival_stop => {
if !fields.insert(__FieldTag::__arrival_stop) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for arrival_stop",
));
}
result.arrival_stop =
map.next_value::<std::option::Option<crate::model::TransitStop>>()?;
}
__FieldTag::__arrival_time => {
if !fields.insert(__FieldTag::__arrival_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for arrival_time",
));
}
result.arrival_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__departure_stop => {
if !fields.insert(__FieldTag::__departure_stop) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for departure_stop",
));
}
result.departure_stop =
map.next_value::<std::option::Option<crate::model::TransitStop>>()?;
}
__FieldTag::__departure_time => {
if !fields.insert(__FieldTag::__departure_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for departure_time",
));
}
result.departure_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::route_leg_step_transit_details::TransitDetailsLocalizedValues
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__arrival_time,
__departure_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransitDetailsLocalizedValues")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"arrivalTime" => Ok(__FieldTag::__arrival_time),
"arrival_time" => Ok(__FieldTag::__arrival_time),
"departureTime" => Ok(__FieldTag::__departure_time),
"departure_time" => Ok(__FieldTag::__departure_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route_leg_step_transit_details::TransitDetailsLocalizedValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransitDetailsLocalizedValues")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__arrival_time => {
if !fields.insert(__FieldTag::__arrival_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for arrival_time",
));
}
result.arrival_time = map
.next_value::<std::option::Option<crate::model::LocalizedTime>>()?;
}
__FieldTag::__departure_time => {
if !fields.insert(__FieldTag::__departure_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for departure_time",
));
}
result.departure_time = map
.next_value::<std::option::Option<crate::model::LocalizedTime>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteModifiers {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__avoid_tolls,
__avoid_highways,
__avoid_ferries,
__avoid_indoor,
__vehicle_info,
__toll_passes,
__avoid_tunnels,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteModifiers")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"avoidTolls" => Ok(__FieldTag::__avoid_tolls),
"avoid_tolls" => Ok(__FieldTag::__avoid_tolls),
"avoidHighways" => Ok(__FieldTag::__avoid_highways),
"avoid_highways" => Ok(__FieldTag::__avoid_highways),
"avoidFerries" => Ok(__FieldTag::__avoid_ferries),
"avoid_ferries" => Ok(__FieldTag::__avoid_ferries),
"avoidIndoor" => Ok(__FieldTag::__avoid_indoor),
"avoid_indoor" => Ok(__FieldTag::__avoid_indoor),
"vehicleInfo" => Ok(__FieldTag::__vehicle_info),
"vehicle_info" => Ok(__FieldTag::__vehicle_info),
"tollPasses" => Ok(__FieldTag::__toll_passes),
"toll_passes" => Ok(__FieldTag::__toll_passes),
"avoidTunnels" => Ok(__FieldTag::__avoid_tunnels),
"avoid_tunnels" => Ok(__FieldTag::__avoid_tunnels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteModifiers;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteModifiers")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__avoid_tolls => {
if !fields.insert(__FieldTag::__avoid_tolls) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for avoid_tolls",
));
}
result.avoid_tolls = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__avoid_highways => {
if !fields.insert(__FieldTag::__avoid_highways) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for avoid_highways",
));
}
result.avoid_highways = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__avoid_ferries => {
if !fields.insert(__FieldTag::__avoid_ferries) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for avoid_ferries",
));
}
result.avoid_ferries = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__avoid_indoor => {
if !fields.insert(__FieldTag::__avoid_indoor) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for avoid_indoor",
));
}
result.avoid_indoor = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__vehicle_info => {
if !fields.insert(__FieldTag::__vehicle_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for vehicle_info",
));
}
result.vehicle_info =
map.next_value::<std::option::Option<crate::model::VehicleInfo>>()?;
}
__FieldTag::__toll_passes => {
if !fields.insert(__FieldTag::__toll_passes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for toll_passes",
));
}
result.toll_passes = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TollPass>>>()?.unwrap_or_default();
}
__FieldTag::__avoid_tunnels => {
if !fields.insert(__FieldTag::__avoid_tunnels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for avoid_tunnels",
));
}
result.avoid_tunnels = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ComputeRoutesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__origin,
__destination,
__intermediates,
__travel_mode,
__routing_preference,
__polyline_quality,
__polyline_encoding,
__departure_time,
__arrival_time,
__compute_alternative_routes,
__route_modifiers,
__language_code,
__region_code,
__units,
__optimize_waypoint_order,
__requested_reference_routes,
__extra_computations,
__traffic_model,
__transit_preferences,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ComputeRoutesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"origin" => Ok(__FieldTag::__origin),
"destination" => Ok(__FieldTag::__destination),
"intermediates" => Ok(__FieldTag::__intermediates),
"travelMode" => Ok(__FieldTag::__travel_mode),
"travel_mode" => Ok(__FieldTag::__travel_mode),
"routingPreference" => Ok(__FieldTag::__routing_preference),
"routing_preference" => Ok(__FieldTag::__routing_preference),
"polylineQuality" => Ok(__FieldTag::__polyline_quality),
"polyline_quality" => Ok(__FieldTag::__polyline_quality),
"polylineEncoding" => Ok(__FieldTag::__polyline_encoding),
"polyline_encoding" => Ok(__FieldTag::__polyline_encoding),
"departureTime" => Ok(__FieldTag::__departure_time),
"departure_time" => Ok(__FieldTag::__departure_time),
"arrivalTime" => Ok(__FieldTag::__arrival_time),
"arrival_time" => Ok(__FieldTag::__arrival_time),
"computeAlternativeRoutes" => {
Ok(__FieldTag::__compute_alternative_routes)
}
"compute_alternative_routes" => {
Ok(__FieldTag::__compute_alternative_routes)
}
"routeModifiers" => Ok(__FieldTag::__route_modifiers),
"route_modifiers" => Ok(__FieldTag::__route_modifiers),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"regionCode" => Ok(__FieldTag::__region_code),
"region_code" => Ok(__FieldTag::__region_code),
"units" => Ok(__FieldTag::__units),
"optimizeWaypointOrder" => Ok(__FieldTag::__optimize_waypoint_order),
"optimize_waypoint_order" => Ok(__FieldTag::__optimize_waypoint_order),
"requestedReferenceRoutes" => {
Ok(__FieldTag::__requested_reference_routes)
}
"requested_reference_routes" => {
Ok(__FieldTag::__requested_reference_routes)
}
"extraComputations" => Ok(__FieldTag::__extra_computations),
"extra_computations" => Ok(__FieldTag::__extra_computations),
"trafficModel" => Ok(__FieldTag::__traffic_model),
"traffic_model" => Ok(__FieldTag::__traffic_model),
"transitPreferences" => Ok(__FieldTag::__transit_preferences),
"transit_preferences" => Ok(__FieldTag::__transit_preferences),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ComputeRoutesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ComputeRoutesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__origin => {
if !fields.insert(__FieldTag::__origin) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for origin",
));
}
result.origin =
map.next_value::<std::option::Option<crate::model::Waypoint>>()?;
}
__FieldTag::__destination => {
if !fields.insert(__FieldTag::__destination) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for destination",
));
}
result.destination =
map.next_value::<std::option::Option<crate::model::Waypoint>>()?;
}
__FieldTag::__intermediates => {
if !fields.insert(__FieldTag::__intermediates) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for intermediates",
));
}
result.intermediates = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Waypoint>>>()?.unwrap_or_default();
}
__FieldTag::__travel_mode => {
if !fields.insert(__FieldTag::__travel_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_mode",
));
}
result.travel_mode = map
.next_value::<std::option::Option<crate::model::RouteTravelMode>>()?
.unwrap_or_default();
}
__FieldTag::__routing_preference => {
if !fields.insert(__FieldTag::__routing_preference) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for routing_preference",
));
}
result.routing_preference = map
.next_value::<std::option::Option<crate::model::RoutingPreference>>(
)?
.unwrap_or_default();
}
__FieldTag::__polyline_quality => {
if !fields.insert(__FieldTag::__polyline_quality) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_quality",
));
}
result.polyline_quality = map
.next_value::<std::option::Option<crate::model::PolylineQuality>>()?
.unwrap_or_default();
}
__FieldTag::__polyline_encoding => {
if !fields.insert(__FieldTag::__polyline_encoding) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polyline_encoding",
));
}
result.polyline_encoding = map
.next_value::<std::option::Option<crate::model::PolylineEncoding>>(
)?
.unwrap_or_default();
}
__FieldTag::__departure_time => {
if !fields.insert(__FieldTag::__departure_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for departure_time",
));
}
result.departure_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__arrival_time => {
if !fields.insert(__FieldTag::__arrival_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for arrival_time",
));
}
result.arrival_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__compute_alternative_routes => {
if !fields.insert(__FieldTag::__compute_alternative_routes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for compute_alternative_routes",
));
}
result.compute_alternative_routes = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__route_modifiers => {
if !fields.insert(__FieldTag::__route_modifiers) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for route_modifiers",
));
}
result.route_modifiers = map
.next_value::<std::option::Option<crate::model::RouteModifiers>>(
)?;
}
__FieldTag::__language_code => {
if !fields.insert(__FieldTag::__language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for language_code",
));
}
result.language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__region_code => {
if !fields.insert(__FieldTag::__region_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for region_code",
));
}
result.region_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__units => {
if !fields.insert(__FieldTag::__units) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for units",
));
}
result.units = map
.next_value::<std::option::Option<crate::model::Units>>()?
.unwrap_or_default();
}
__FieldTag::__optimize_waypoint_order => {
if !fields.insert(__FieldTag::__optimize_waypoint_order) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for optimize_waypoint_order",
));
}
result.optimize_waypoint_order = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__requested_reference_routes => {
if !fields.insert(__FieldTag::__requested_reference_routes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for requested_reference_routes",
));
}
result.requested_reference_routes = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::compute_routes_request::ReferenceRoute,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__extra_computations => {
if !fields.insert(__FieldTag::__extra_computations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for extra_computations",
));
}
result.extra_computations = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::compute_routes_request::ExtraComputation,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__traffic_model => {
if !fields.insert(__FieldTag::__traffic_model) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for traffic_model",
));
}
result.traffic_model = map
.next_value::<std::option::Option<crate::model::TrafficModel>>()?
.unwrap_or_default();
}
__FieldTag::__transit_preferences => {
if !fields.insert(__FieldTag::__transit_preferences) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transit_preferences",
));
}
result.transit_preferences = map.next_value::<std::option::Option<crate::model::TransitPreferences>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ComputeRoutesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__routes,
__fallback_info,
__geocoding_results,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ComputeRoutesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"routes" => Ok(__FieldTag::__routes),
"fallbackInfo" => Ok(__FieldTag::__fallback_info),
"fallback_info" => Ok(__FieldTag::__fallback_info),
"geocodingResults" => Ok(__FieldTag::__geocoding_results),
"geocoding_results" => Ok(__FieldTag::__geocoding_results),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ComputeRoutesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ComputeRoutesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__routes => {
if !fields.insert(__FieldTag::__routes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for routes",
));
}
result.routes = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Route>>>()?.unwrap_or_default();
}
__FieldTag::__fallback_info => {
if !fields.insert(__FieldTag::__fallback_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fallback_info",
));
}
result.fallback_info = map
.next_value::<std::option::Option<crate::model::FallbackInfo>>()?;
}
__FieldTag::__geocoding_results => {
if !fields.insert(__FieldTag::__geocoding_results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for geocoding_results",
));
}
result.geocoding_results = map
.next_value::<std::option::Option<crate::model::GeocodingResults>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ComputeRouteMatrixRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__origins,
__destinations,
__travel_mode,
__routing_preference,
__departure_time,
__arrival_time,
__language_code,
__region_code,
__units,
__extra_computations,
__traffic_model,
__transit_preferences,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ComputeRouteMatrixRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"origins" => Ok(__FieldTag::__origins),
"destinations" => Ok(__FieldTag::__destinations),
"travelMode" => Ok(__FieldTag::__travel_mode),
"travel_mode" => Ok(__FieldTag::__travel_mode),
"routingPreference" => Ok(__FieldTag::__routing_preference),
"routing_preference" => Ok(__FieldTag::__routing_preference),
"departureTime" => Ok(__FieldTag::__departure_time),
"departure_time" => Ok(__FieldTag::__departure_time),
"arrivalTime" => Ok(__FieldTag::__arrival_time),
"arrival_time" => Ok(__FieldTag::__arrival_time),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"regionCode" => Ok(__FieldTag::__region_code),
"region_code" => Ok(__FieldTag::__region_code),
"units" => Ok(__FieldTag::__units),
"extraComputations" => Ok(__FieldTag::__extra_computations),
"extra_computations" => Ok(__FieldTag::__extra_computations),
"trafficModel" => Ok(__FieldTag::__traffic_model),
"traffic_model" => Ok(__FieldTag::__traffic_model),
"transitPreferences" => Ok(__FieldTag::__transit_preferences),
"transit_preferences" => Ok(__FieldTag::__transit_preferences),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ComputeRouteMatrixRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ComputeRouteMatrixRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__origins => {
if !fields.insert(__FieldTag::__origins) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for origins",
));
}
result.origins =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::RouteMatrixOrigin>,
>>()?
.unwrap_or_default();
}
__FieldTag::__destinations => {
if !fields.insert(__FieldTag::__destinations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for destinations",
));
}
result.destinations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::RouteMatrixDestination>,
>>()?
.unwrap_or_default();
}
__FieldTag::__travel_mode => {
if !fields.insert(__FieldTag::__travel_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_mode",
));
}
result.travel_mode = map
.next_value::<std::option::Option<crate::model::RouteTravelMode>>()?
.unwrap_or_default();
}
__FieldTag::__routing_preference => {
if !fields.insert(__FieldTag::__routing_preference) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for routing_preference",
));
}
result.routing_preference = map
.next_value::<std::option::Option<crate::model::RoutingPreference>>(
)?
.unwrap_or_default();
}
__FieldTag::__departure_time => {
if !fields.insert(__FieldTag::__departure_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for departure_time",
));
}
result.departure_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__arrival_time => {
if !fields.insert(__FieldTag::__arrival_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for arrival_time",
));
}
result.arrival_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__language_code => {
if !fields.insert(__FieldTag::__language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for language_code",
));
}
result.language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__region_code => {
if !fields.insert(__FieldTag::__region_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for region_code",
));
}
result.region_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__units => {
if !fields.insert(__FieldTag::__units) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for units",
));
}
result.units = map
.next_value::<std::option::Option<crate::model::Units>>()?
.unwrap_or_default();
}
__FieldTag::__extra_computations => {
if !fields.insert(__FieldTag::__extra_computations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for extra_computations",
));
}
result.extra_computations = map.next_value::<std::option::Option<std::vec::Vec<crate::model::compute_route_matrix_request::ExtraComputation>>>()?.unwrap_or_default();
}
__FieldTag::__traffic_model => {
if !fields.insert(__FieldTag::__traffic_model) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for traffic_model",
));
}
result.traffic_model = map
.next_value::<std::option::Option<crate::model::TrafficModel>>()?
.unwrap_or_default();
}
__FieldTag::__transit_preferences => {
if !fields.insert(__FieldTag::__transit_preferences) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transit_preferences",
));
}
result.transit_preferences = map.next_value::<std::option::Option<crate::model::TransitPreferences>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteMatrixOrigin {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__waypoint,
__route_modifiers,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteMatrixOrigin")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"waypoint" => Ok(__FieldTag::__waypoint),
"routeModifiers" => Ok(__FieldTag::__route_modifiers),
"route_modifiers" => Ok(__FieldTag::__route_modifiers),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteMatrixOrigin;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteMatrixOrigin")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__waypoint => {
if !fields.insert(__FieldTag::__waypoint) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for waypoint",
));
}
result.waypoint =
map.next_value::<std::option::Option<crate::model::Waypoint>>()?;
}
__FieldTag::__route_modifiers => {
if !fields.insert(__FieldTag::__route_modifiers) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for route_modifiers",
));
}
result.route_modifiers = map
.next_value::<std::option::Option<crate::model::RouteModifiers>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteMatrixDestination {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__waypoint,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteMatrixDestination")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"waypoint" => Ok(__FieldTag::__waypoint),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteMatrixDestination;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteMatrixDestination")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__waypoint => {
if !fields.insert(__FieldTag::__waypoint) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for waypoint",
));
}
result.waypoint =
map.next_value::<std::option::Option<crate::model::Waypoint>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RouteMatrixElement {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__origin_index,
__destination_index,
__status,
__condition,
__distance_meters,
__duration,
__static_duration,
__travel_advisory,
__fallback_info,
__localized_values,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RouteMatrixElement")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"originIndex" => Ok(__FieldTag::__origin_index),
"origin_index" => Ok(__FieldTag::__origin_index),
"destinationIndex" => Ok(__FieldTag::__destination_index),
"destination_index" => Ok(__FieldTag::__destination_index),
"status" => Ok(__FieldTag::__status),
"condition" => Ok(__FieldTag::__condition),
"distanceMeters" => Ok(__FieldTag::__distance_meters),
"distance_meters" => Ok(__FieldTag::__distance_meters),
"duration" => Ok(__FieldTag::__duration),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
"travelAdvisory" => Ok(__FieldTag::__travel_advisory),
"travel_advisory" => Ok(__FieldTag::__travel_advisory),
"fallbackInfo" => Ok(__FieldTag::__fallback_info),
"fallback_info" => Ok(__FieldTag::__fallback_info),
"localizedValues" => Ok(__FieldTag::__localized_values),
"localized_values" => Ok(__FieldTag::__localized_values),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RouteMatrixElement;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RouteMatrixElement")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__origin_index => {
if !fields.insert(__FieldTag::__origin_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for origin_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.origin_index = map.next_value::<__With>()?.0;
}
__FieldTag::__destination_index => {
if !fields.insert(__FieldTag::__destination_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for destination_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.destination_index = map.next_value::<__With>()?.0;
}
__FieldTag::__status => {
if !fields.insert(__FieldTag::__status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status",
));
}
result.status = map
.next_value::<std::option::Option<google_cloud_rpc::model::Status>>(
)?;
}
__FieldTag::__condition => {
if !fields.insert(__FieldTag::__condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for condition",
));
}
result.condition = map.next_value::<std::option::Option<crate::model::RouteMatrixElementCondition>>()?.unwrap_or_default();
}
__FieldTag::__distance_meters => {
if !fields.insert(__FieldTag::__distance_meters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance_meters",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.distance_meters =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__duration => {
if !fields.insert(__FieldTag::__duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for duration",
));
}
result.duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__travel_advisory => {
if !fields.insert(__FieldTag::__travel_advisory) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_advisory",
));
}
result.travel_advisory = map.next_value::<std::option::Option<crate::model::RouteTravelAdvisory>>()?
;
}
__FieldTag::__fallback_info => {
if !fields.insert(__FieldTag::__fallback_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fallback_info",
));
}
result.fallback_info = map
.next_value::<std::option::Option<crate::model::FallbackInfo>>()?;
}
__FieldTag::__localized_values => {
if !fields.insert(__FieldTag::__localized_values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for localized_values",
));
}
result.localized_values = map.next_value::<std::option::Option<
crate::model::route_matrix_element::LocalizedValues,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::route_matrix_element::LocalizedValues {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__distance,
__duration,
__static_duration,
__transit_fare,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for LocalizedValues")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"distance" => Ok(__FieldTag::__distance),
"duration" => Ok(__FieldTag::__duration),
"staticDuration" => Ok(__FieldTag::__static_duration),
"static_duration" => Ok(__FieldTag::__static_duration),
"transitFare" => Ok(__FieldTag::__transit_fare),
"transit_fare" => Ok(__FieldTag::__transit_fare),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::route_matrix_element::LocalizedValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LocalizedValues")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__distance => {
if !fields.insert(__FieldTag::__distance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for distance",
));
}
result.distance = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__duration => {
if !fields.insert(__FieldTag::__duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for duration",
));
}
result.duration = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__static_duration => {
if !fields.insert(__FieldTag::__static_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for static_duration",
));
}
result.static_duration = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__transit_fare => {
if !fields.insert(__FieldTag::__transit_fare) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transit_fare",
));
}
result.transit_fare = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SpeedReadingInterval {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_polyline_point_index,
__end_polyline_point_index,
__speed,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SpeedReadingInterval")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startPolylinePointIndex" => {
Ok(__FieldTag::__start_polyline_point_index)
}
"start_polyline_point_index" => {
Ok(__FieldTag::__start_polyline_point_index)
}
"endPolylinePointIndex" => Ok(__FieldTag::__end_polyline_point_index),
"end_polyline_point_index" => {
Ok(__FieldTag::__end_polyline_point_index)
}
"speed" => Ok(__FieldTag::__speed),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SpeedReadingInterval;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SpeedReadingInterval")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_polyline_point_index => {
if !fields.insert(__FieldTag::__start_polyline_point_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_polyline_point_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.start_polyline_point_index = map.next_value::<__With>()?.0;
}
__FieldTag::__end_polyline_point_index => {
if !fields.insert(__FieldTag::__end_polyline_point_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_polyline_point_index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.end_polyline_point_index = map.next_value::<__With>()?.0;
}
__FieldTag::__speed => {
if !fields.insert(__FieldTag::__speed) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for speed",
));
}
if result.speed_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `speed_type`, a oneof with full ID .google.maps.routing.v2.SpeedReadingInterval.speed, latest field was speed",
));
}
result.speed_type = std::option::Option::Some(
crate::model::speed_reading_interval::SpeedType::Speed(
map.next_value::<std::option::Option<
crate::model::speed_reading_interval::Speed,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TollInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__estimated_price,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TollInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"estimatedPrice" => Ok(__FieldTag::__estimated_price),
"estimated_price" => Ok(__FieldTag::__estimated_price),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TollInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TollInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__estimated_price => {
if !fields.insert(__FieldTag::__estimated_price) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for estimated_price",
));
}
result.estimated_price =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_type::model::Money>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TransitAgency {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__phone_number,
__uri,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransitAgency")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"phoneNumber" => Ok(__FieldTag::__phone_number),
"phone_number" => Ok(__FieldTag::__phone_number),
"uri" => Ok(__FieldTag::__uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TransitAgency;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransitAgency")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__phone_number => {
if !fields.insert(__FieldTag::__phone_number) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for phone_number",
));
}
result.phone_number = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TransitLine {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__agencies,
__name,
__uri,
__color,
__icon_uri,
__name_short,
__text_color,
__vehicle,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransitLine")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"agencies" => Ok(__FieldTag::__agencies),
"name" => Ok(__FieldTag::__name),
"uri" => Ok(__FieldTag::__uri),
"color" => Ok(__FieldTag::__color),
"iconUri" => Ok(__FieldTag::__icon_uri),
"icon_uri" => Ok(__FieldTag::__icon_uri),
"nameShort" => Ok(__FieldTag::__name_short),
"name_short" => Ok(__FieldTag::__name_short),
"textColor" => Ok(__FieldTag::__text_color),
"text_color" => Ok(__FieldTag::__text_color),
"vehicle" => Ok(__FieldTag::__vehicle),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TransitLine;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransitLine")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__agencies => {
if !fields.insert(__FieldTag::__agencies) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for agencies",
));
}
result.agencies = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TransitAgency>>>()?.unwrap_or_default();
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__color => {
if !fields.insert(__FieldTag::__color) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for color",
));
}
result.color = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__icon_uri => {
if !fields.insert(__FieldTag::__icon_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for icon_uri",
));
}
result.icon_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__name_short => {
if !fields.insert(__FieldTag::__name_short) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name_short",
));
}
result.name_short = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__text_color => {
if !fields.insert(__FieldTag::__text_color) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for text_color",
));
}
result.text_color = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__vehicle => {
if !fields.insert(__FieldTag::__vehicle) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for vehicle",
));
}
result.vehicle = map
.next_value::<std::option::Option<crate::model::TransitVehicle>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TransitStop {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__location,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransitStop")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"location" => Ok(__FieldTag::__location),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TransitStop;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransitStop")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
result.location =
map.next_value::<std::option::Option<crate::model::Location>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TransitVehicle {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__type,
__icon_uri,
__local_icon_uri,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransitVehicle")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"type" => Ok(__FieldTag::__type),
"iconUri" => Ok(__FieldTag::__icon_uri),
"icon_uri" => Ok(__FieldTag::__icon_uri),
"localIconUri" => Ok(__FieldTag::__local_icon_uri),
"local_icon_uri" => Ok(__FieldTag::__local_icon_uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TransitVehicle;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransitVehicle")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<
crate::model::transit_vehicle::TransitVehicleType,
>>()?
.unwrap_or_default();
}
__FieldTag::__icon_uri => {
if !fields.insert(__FieldTag::__icon_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for icon_uri",
));
}
result.icon_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__local_icon_uri => {
if !fields.insert(__FieldTag::__local_icon_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for local_icon_uri",
));
}
result.local_icon_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TransitPreferences {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__allowed_travel_modes,
__routing_preference,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransitPreferences")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"allowedTravelModes" => Ok(__FieldTag::__allowed_travel_modes),
"allowed_travel_modes" => Ok(__FieldTag::__allowed_travel_modes),
"routingPreference" => Ok(__FieldTag::__routing_preference),
"routing_preference" => Ok(__FieldTag::__routing_preference),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TransitPreferences;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransitPreferences")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__allowed_travel_modes => {
if !fields.insert(__FieldTag::__allowed_travel_modes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allowed_travel_modes",
));
}
result.allowed_travel_modes = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::transit_preferences::TransitTravelMode,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__routing_preference => {
if !fields.insert(__FieldTag::__routing_preference) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for routing_preference",
));
}
result.routing_preference = map
.next_value::<std::option::Option<
crate::model::transit_preferences::TransitRoutingPreference,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::VehicleInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__emission_type,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for VehicleInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"emissionType" => Ok(__FieldTag::__emission_type),
"emission_type" => Ok(__FieldTag::__emission_type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::VehicleInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct VehicleInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__emission_type => {
if !fields.insert(__FieldTag::__emission_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for emission_type",
));
}
result.emission_type = map.next_value::<std::option::Option<crate::model::VehicleEmissionType>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Waypoint {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__location,
__place_id,
__address,
__navigation_point_token,
__via,
__vehicle_stopover,
__side_of_road,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Waypoint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"location" => Ok(__FieldTag::__location),
"placeId" => Ok(__FieldTag::__place_id),
"place_id" => Ok(__FieldTag::__place_id),
"address" => Ok(__FieldTag::__address),
"navigationPointToken" => Ok(__FieldTag::__navigation_point_token),
"navigation_point_token" => Ok(__FieldTag::__navigation_point_token),
"via" => Ok(__FieldTag::__via),
"vehicleStopover" => Ok(__FieldTag::__vehicle_stopover),
"vehicle_stopover" => Ok(__FieldTag::__vehicle_stopover),
"sideOfRoad" => Ok(__FieldTag::__side_of_road),
"side_of_road" => Ok(__FieldTag::__side_of_road),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Waypoint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Waypoint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
if result.location_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `location_type`, a oneof with full ID .google.maps.routing.v2.Waypoint.location, latest field was location",
));
}
result.location_type = std::option::Option::Some(
crate::model::waypoint::LocationType::Location(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::Location>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__place_id => {
if !fields.insert(__FieldTag::__place_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for place_id",
));
}
if result.location_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `location_type`, a oneof with full ID .google.maps.routing.v2.Waypoint.place_id, latest field was placeId",
));
}
result.location_type = std::option::Option::Some(
crate::model::waypoint::LocationType::PlaceId(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__address => {
if !fields.insert(__FieldTag::__address) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for address",
));
}
if result.location_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `location_type`, a oneof with full ID .google.maps.routing.v2.Waypoint.address, latest field was address",
));
}
result.location_type = std::option::Option::Some(
crate::model::waypoint::LocationType::Address(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__navigation_point_token => {
if !fields.insert(__FieldTag::__navigation_point_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for navigation_point_token",
));
}
if result.location_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `location_type`, a oneof with full ID .google.maps.routing.v2.Waypoint.navigation_point_token, latest field was navigationPointToken",
));
}
result.location_type = std::option::Option::Some(
crate::model::waypoint::LocationType::NavigationPointToken(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__via => {
if !fields.insert(__FieldTag::__via) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for via",
));
}
result.via = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__vehicle_stopover => {
if !fields.insert(__FieldTag::__vehicle_stopover) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for vehicle_stopover",
));
}
result.vehicle_stopover = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__side_of_road => {
if !fields.insert(__FieldTag::__side_of_road) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for side_of_road",
));
}
result.side_of_road = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}