#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GenerateIsochroneRequest {
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,
__travel_duration,
__travel_mode,
__travel_direction,
__routing_preference,
__enable_smoothing,
__polygon_fidelity,
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 GenerateIsochroneRequest")
}
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),
"place" => Ok(__FieldTag::__place),
"travelDuration" => Ok(__FieldTag::__travel_duration),
"travel_duration" => Ok(__FieldTag::__travel_duration),
"travelMode" => Ok(__FieldTag::__travel_mode),
"travel_mode" => Ok(__FieldTag::__travel_mode),
"travelDirection" => Ok(__FieldTag::__travel_direction),
"travel_direction" => Ok(__FieldTag::__travel_direction),
"routingPreference" => Ok(__FieldTag::__routing_preference),
"routing_preference" => Ok(__FieldTag::__routing_preference),
"enableSmoothing" => Ok(__FieldTag::__enable_smoothing),
"enable_smoothing" => Ok(__FieldTag::__enable_smoothing),
"polygonFidelity" => Ok(__FieldTag::__polygon_fidelity),
"polygon_fidelity" => Ok(__FieldTag::__polygon_fidelity),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GenerateIsochroneRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GenerateIsochroneRequest")
}
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.origin.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `origin`, a oneof with full ID .google.maps.isochrones.v1.GenerateIsochroneRequest.location, latest field was location",
));
}
result.origin = std::option::Option::Some(
crate::model::generate_isochrone_request::Origin::Location(
map.next_value::<std::option::Option<
std::boxed::Box<google_cloud_type::model::LatLng>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__place => {
if !fields.insert(__FieldTag::__place) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for place",
));
}
if result.origin.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `origin`, a oneof with full ID .google.maps.isochrones.v1.GenerateIsochroneRequest.place, latest field was place",
));
}
result.origin = std::option::Option::Some(
crate::model::generate_isochrone_request::Origin::Place(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__travel_duration => {
if !fields.insert(__FieldTag::__travel_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_duration",
));
}
result.travel_duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__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::generate_isochrone_request::TravelMode,
>>()?
.unwrap_or_default();
}
__FieldTag::__travel_direction => {
if !fields.insert(__FieldTag::__travel_direction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for travel_direction",
));
}
result.travel_direction = map
.next_value::<std::option::Option<
crate::model::generate_isochrone_request::TravelDirection,
>>()?
.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::generate_isochrone_request::RoutingPreference,
>>()?
.unwrap_or_default();
}
__FieldTag::__enable_smoothing => {
if !fields.insert(__FieldTag::__enable_smoothing) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_smoothing",
));
}
result.enable_smoothing = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__polygon_fidelity => {
if !fields.insert(__FieldTag::__polygon_fidelity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polygon_fidelity",
));
}
result.polygon_fidelity = map
.next_value::<std::option::Option<
crate::model::generate_isochrone_request::PolygonFidelity,
>>()?
.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::GenerateIsochroneResponse {
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 {
__isochrone,
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 GenerateIsochroneResponse")
}
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 {
"isochrone" => Ok(__FieldTag::__isochrone),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GenerateIsochroneResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GenerateIsochroneResponse")
}
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::__isochrone => {
if !fields.insert(__FieldTag::__isochrone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for isochrone",
));
}
result.isochrone =
map.next_value::<std::option::Option<crate::model::Isochrone>>()?;
}
__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::Isochrone {
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 {
__geo_json,
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 Isochrone")
}
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 {
"geoJson" => Ok(__FieldTag::__geo_json),
"geo_json" => Ok(__FieldTag::__geo_json),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Isochrone;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Isochrone")
}
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::__geo_json => {
if !fields.insert(__FieldTag::__geo_json) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for geo_json",
));
}
if result.geometry.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `geometry`, a oneof with full ID .google.maps.isochrones.v1.Isochrone.geo_json, latest field was geoJson",
));
}
result.geometry = std::option::Option::Some(
crate::model::isochrone::Geometry::GeoJson(
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)
}
}