#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AirPressure {
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 {
__mean_sea_level_millibars,
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 AirPressure")
}
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 {
"meanSeaLevelMillibars" => Ok(__FieldTag::__mean_sea_level_millibars),
"mean_sea_level_millibars" => {
Ok(__FieldTag::__mean_sea_level_millibars)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AirPressure;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AirPressure")
}
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::__mean_sea_level_millibars => {
if !fields.insert(__FieldTag::__mean_sea_level_millibars) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mean_sea_level_millibars",
));
}
struct __With(std::option::Option<f32>);
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::F32> >::deserialize(deserializer).map(__With)
}
}
result.mean_sea_level_millibars = 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::SunEvents {
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 {
__sunrise_time,
__sunset_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 SunEvents")
}
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 {
"sunriseTime" => Ok(__FieldTag::__sunrise_time),
"sunrise_time" => Ok(__FieldTag::__sunrise_time),
"sunsetTime" => Ok(__FieldTag::__sunset_time),
"sunset_time" => Ok(__FieldTag::__sunset_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SunEvents;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SunEvents")
}
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::__sunrise_time => {
if !fields.insert(__FieldTag::__sunrise_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sunrise_time",
));
}
result.sunrise_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__sunset_time => {
if !fields.insert(__FieldTag::__sunset_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sunset_time",
));
}
result.sunset_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::MoonEvents {
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 {
__moon_phase,
__moonrise_times,
__moonset_times,
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 MoonEvents")
}
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 {
"moonPhase" => Ok(__FieldTag::__moon_phase),
"moon_phase" => Ok(__FieldTag::__moon_phase),
"moonriseTimes" => Ok(__FieldTag::__moonrise_times),
"moonrise_times" => Ok(__FieldTag::__moonrise_times),
"moonsetTimes" => Ok(__FieldTag::__moonset_times),
"moonset_times" => Ok(__FieldTag::__moonset_times),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MoonEvents;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MoonEvents")
}
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::__moon_phase => {
if !fields.insert(__FieldTag::__moon_phase) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for moon_phase",
));
}
result.moon_phase = map.next_value::<std::option::Option<crate::model::moon_events::Phase>>()?.unwrap_or_default();
}
__FieldTag::__moonrise_times => {
if !fields.insert(__FieldTag::__moonrise_times) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for moonrise_times",
));
}
result.moonrise_times = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Timestamp>>>()?
.unwrap_or_default();
}
__FieldTag::__moonset_times => {
if !fields.insert(__FieldTag::__moonset_times) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for moonset_times",
));
}
result.moonset_times = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Timestamp>>>()?
.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::ForecastDay {
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 {
__interval,
__display_date,
__daytime_forecast,
__nighttime_forecast,
__max_temperature,
__min_temperature,
__feels_like_max_temperature,
__feels_like_min_temperature,
__sun_events,
__moon_events,
__max_heat_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 ForecastDay")
}
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 {
"interval" => Ok(__FieldTag::__interval),
"displayDate" => Ok(__FieldTag::__display_date),
"display_date" => Ok(__FieldTag::__display_date),
"daytimeForecast" => Ok(__FieldTag::__daytime_forecast),
"daytime_forecast" => Ok(__FieldTag::__daytime_forecast),
"nighttimeForecast" => Ok(__FieldTag::__nighttime_forecast),
"nighttime_forecast" => Ok(__FieldTag::__nighttime_forecast),
"maxTemperature" => Ok(__FieldTag::__max_temperature),
"max_temperature" => Ok(__FieldTag::__max_temperature),
"minTemperature" => Ok(__FieldTag::__min_temperature),
"min_temperature" => Ok(__FieldTag::__min_temperature),
"feelsLikeMaxTemperature" => {
Ok(__FieldTag::__feels_like_max_temperature)
}
"feels_like_max_temperature" => {
Ok(__FieldTag::__feels_like_max_temperature)
}
"feelsLikeMinTemperature" => {
Ok(__FieldTag::__feels_like_min_temperature)
}
"feels_like_min_temperature" => {
Ok(__FieldTag::__feels_like_min_temperature)
}
"sunEvents" => Ok(__FieldTag::__sun_events),
"sun_events" => Ok(__FieldTag::__sun_events),
"moonEvents" => Ok(__FieldTag::__moon_events),
"moon_events" => Ok(__FieldTag::__moon_events),
"maxHeatIndex" => Ok(__FieldTag::__max_heat_index),
"max_heat_index" => Ok(__FieldTag::__max_heat_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ForecastDay;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ForecastDay")
}
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::__interval => {
if !fields.insert(__FieldTag::__interval) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interval",
));
}
result.interval = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__FieldTag::__display_date => {
if !fields.insert(__FieldTag::__display_date) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_date",
));
}
result.display_date = map
.next_value::<std::option::Option<google_cloud_type::model::Date>>(
)?;
}
__FieldTag::__daytime_forecast => {
if !fields.insert(__FieldTag::__daytime_forecast) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for daytime_forecast",
));
}
result.daytime_forecast = map
.next_value::<std::option::Option<crate::model::ForecastDayPart>>(
)?;
}
__FieldTag::__nighttime_forecast => {
if !fields.insert(__FieldTag::__nighttime_forecast) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for nighttime_forecast",
));
}
result.nighttime_forecast = map
.next_value::<std::option::Option<crate::model::ForecastDayPart>>(
)?;
}
__FieldTag::__max_temperature => {
if !fields.insert(__FieldTag::__max_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_temperature",
));
}
result.max_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__min_temperature => {
if !fields.insert(__FieldTag::__min_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_temperature",
));
}
result.min_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__feels_like_max_temperature => {
if !fields.insert(__FieldTag::__feels_like_max_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for feels_like_max_temperature",
));
}
result.feels_like_max_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__feels_like_min_temperature => {
if !fields.insert(__FieldTag::__feels_like_min_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for feels_like_min_temperature",
));
}
result.feels_like_min_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__sun_events => {
if !fields.insert(__FieldTag::__sun_events) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sun_events",
));
}
result.sun_events =
map.next_value::<std::option::Option<crate::model::SunEvents>>()?;
}
__FieldTag::__moon_events => {
if !fields.insert(__FieldTag::__moon_events) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for moon_events",
));
}
result.moon_events =
map.next_value::<std::option::Option<crate::model::MoonEvents>>()?;
}
__FieldTag::__max_heat_index => {
if !fields.insert(__FieldTag::__max_heat_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_heat_index",
));
}
result.max_heat_index =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__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::ForecastDayPart {
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 {
__interval,
__weather_condition,
__relative_humidity,
__uv_index,
__precipitation,
__thunderstorm_probability,
__wind,
__cloud_cover,
__ice_thickness,
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 ForecastDayPart")
}
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 {
"interval" => Ok(__FieldTag::__interval),
"weatherCondition" => Ok(__FieldTag::__weather_condition),
"weather_condition" => Ok(__FieldTag::__weather_condition),
"relativeHumidity" => Ok(__FieldTag::__relative_humidity),
"relative_humidity" => Ok(__FieldTag::__relative_humidity),
"uvIndex" => Ok(__FieldTag::__uv_index),
"uv_index" => Ok(__FieldTag::__uv_index),
"precipitation" => Ok(__FieldTag::__precipitation),
"thunderstormProbability" => Ok(__FieldTag::__thunderstorm_probability),
"thunderstorm_probability" => {
Ok(__FieldTag::__thunderstorm_probability)
}
"wind" => Ok(__FieldTag::__wind),
"cloudCover" => Ok(__FieldTag::__cloud_cover),
"cloud_cover" => Ok(__FieldTag::__cloud_cover),
"iceThickness" => Ok(__FieldTag::__ice_thickness),
"ice_thickness" => Ok(__FieldTag::__ice_thickness),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ForecastDayPart;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ForecastDayPart")
}
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::__interval => {
if !fields.insert(__FieldTag::__interval) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interval",
));
}
result.interval = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__FieldTag::__weather_condition => {
if !fields.insert(__FieldTag::__weather_condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for weather_condition",
));
}
result.weather_condition = map
.next_value::<std::option::Option<crate::model::WeatherCondition>>(
)?;
}
__FieldTag::__relative_humidity => {
if !fields.insert(__FieldTag::__relative_humidity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relative_humidity",
));
}
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.relative_humidity = map.next_value::<__With>()?.0;
}
__FieldTag::__uv_index => {
if !fields.insert(__FieldTag::__uv_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uv_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.uv_index = map.next_value::<__With>()?.0;
}
__FieldTag::__precipitation => {
if !fields.insert(__FieldTag::__precipitation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for precipitation",
));
}
result.precipitation = map
.next_value::<std::option::Option<crate::model::Precipitation>>()?;
}
__FieldTag::__thunderstorm_probability => {
if !fields.insert(__FieldTag::__thunderstorm_probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thunderstorm_probability",
));
}
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.thunderstorm_probability = map.next_value::<__With>()?.0;
}
__FieldTag::__wind => {
if !fields.insert(__FieldTag::__wind) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wind",
));
}
result.wind =
map.next_value::<std::option::Option<crate::model::Wind>>()?;
}
__FieldTag::__cloud_cover => {
if !fields.insert(__FieldTag::__cloud_cover) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_cover",
));
}
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.cloud_cover = map.next_value::<__With>()?.0;
}
__FieldTag::__ice_thickness => {
if !fields.insert(__FieldTag::__ice_thickness) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ice_thickness",
));
}
result.ice_thickness = map
.next_value::<std::option::Option<crate::model::IceThickness>>()?;
}
__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::ForecastHour {
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 {
__interval,
__display_date_time,
__is_daytime,
__weather_condition,
__temperature,
__feels_like_temperature,
__dew_point,
__heat_index,
__wind_chill,
__wet_bulb_temperature,
__relative_humidity,
__uv_index,
__precipitation,
__thunderstorm_probability,
__air_pressure,
__wind,
__visibility,
__cloud_cover,
__ice_thickness,
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 ForecastHour")
}
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 {
"interval" => Ok(__FieldTag::__interval),
"displayDateTime" => Ok(__FieldTag::__display_date_time),
"display_date_time" => Ok(__FieldTag::__display_date_time),
"isDaytime" => Ok(__FieldTag::__is_daytime),
"is_daytime" => Ok(__FieldTag::__is_daytime),
"weatherCondition" => Ok(__FieldTag::__weather_condition),
"weather_condition" => Ok(__FieldTag::__weather_condition),
"temperature" => Ok(__FieldTag::__temperature),
"feelsLikeTemperature" => Ok(__FieldTag::__feels_like_temperature),
"feels_like_temperature" => Ok(__FieldTag::__feels_like_temperature),
"dewPoint" => Ok(__FieldTag::__dew_point),
"dew_point" => Ok(__FieldTag::__dew_point),
"heatIndex" => Ok(__FieldTag::__heat_index),
"heat_index" => Ok(__FieldTag::__heat_index),
"windChill" => Ok(__FieldTag::__wind_chill),
"wind_chill" => Ok(__FieldTag::__wind_chill),
"wetBulbTemperature" => Ok(__FieldTag::__wet_bulb_temperature),
"wet_bulb_temperature" => Ok(__FieldTag::__wet_bulb_temperature),
"relativeHumidity" => Ok(__FieldTag::__relative_humidity),
"relative_humidity" => Ok(__FieldTag::__relative_humidity),
"uvIndex" => Ok(__FieldTag::__uv_index),
"uv_index" => Ok(__FieldTag::__uv_index),
"precipitation" => Ok(__FieldTag::__precipitation),
"thunderstormProbability" => Ok(__FieldTag::__thunderstorm_probability),
"thunderstorm_probability" => {
Ok(__FieldTag::__thunderstorm_probability)
}
"airPressure" => Ok(__FieldTag::__air_pressure),
"air_pressure" => Ok(__FieldTag::__air_pressure),
"wind" => Ok(__FieldTag::__wind),
"visibility" => Ok(__FieldTag::__visibility),
"cloudCover" => Ok(__FieldTag::__cloud_cover),
"cloud_cover" => Ok(__FieldTag::__cloud_cover),
"iceThickness" => Ok(__FieldTag::__ice_thickness),
"ice_thickness" => Ok(__FieldTag::__ice_thickness),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ForecastHour;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ForecastHour")
}
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::__interval => {
if !fields.insert(__FieldTag::__interval) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interval",
));
}
result.interval = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__FieldTag::__display_date_time => {
if !fields.insert(__FieldTag::__display_date_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_date_time",
));
}
result.display_date_time = map.next_value::<std::option::Option<google_cloud_type::model::DateTime>>()?
;
}
__FieldTag::__is_daytime => {
if !fields.insert(__FieldTag::__is_daytime) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for is_daytime",
));
}
result.is_daytime = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__weather_condition => {
if !fields.insert(__FieldTag::__weather_condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for weather_condition",
));
}
result.weather_condition = map
.next_value::<std::option::Option<crate::model::WeatherCondition>>(
)?;
}
__FieldTag::__temperature => {
if !fields.insert(__FieldTag::__temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for temperature",
));
}
result.temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__feels_like_temperature => {
if !fields.insert(__FieldTag::__feels_like_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for feels_like_temperature",
));
}
result.feels_like_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__dew_point => {
if !fields.insert(__FieldTag::__dew_point) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dew_point",
));
}
result.dew_point =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__heat_index => {
if !fields.insert(__FieldTag::__heat_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for heat_index",
));
}
result.heat_index =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__wind_chill => {
if !fields.insert(__FieldTag::__wind_chill) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wind_chill",
));
}
result.wind_chill =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__wet_bulb_temperature => {
if !fields.insert(__FieldTag::__wet_bulb_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wet_bulb_temperature",
));
}
result.wet_bulb_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__relative_humidity => {
if !fields.insert(__FieldTag::__relative_humidity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relative_humidity",
));
}
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.relative_humidity = map.next_value::<__With>()?.0;
}
__FieldTag::__uv_index => {
if !fields.insert(__FieldTag::__uv_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uv_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.uv_index = map.next_value::<__With>()?.0;
}
__FieldTag::__precipitation => {
if !fields.insert(__FieldTag::__precipitation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for precipitation",
));
}
result.precipitation = map
.next_value::<std::option::Option<crate::model::Precipitation>>()?;
}
__FieldTag::__thunderstorm_probability => {
if !fields.insert(__FieldTag::__thunderstorm_probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thunderstorm_probability",
));
}
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.thunderstorm_probability = map.next_value::<__With>()?.0;
}
__FieldTag::__air_pressure => {
if !fields.insert(__FieldTag::__air_pressure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for air_pressure",
));
}
result.air_pressure =
map.next_value::<std::option::Option<crate::model::AirPressure>>()?;
}
__FieldTag::__wind => {
if !fields.insert(__FieldTag::__wind) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wind",
));
}
result.wind =
map.next_value::<std::option::Option<crate::model::Wind>>()?;
}
__FieldTag::__visibility => {
if !fields.insert(__FieldTag::__visibility) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for visibility",
));
}
result.visibility =
map.next_value::<std::option::Option<crate::model::Visibility>>()?;
}
__FieldTag::__cloud_cover => {
if !fields.insert(__FieldTag::__cloud_cover) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_cover",
));
}
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.cloud_cover = map.next_value::<__With>()?.0;
}
__FieldTag::__ice_thickness => {
if !fields.insert(__FieldTag::__ice_thickness) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ice_thickness",
));
}
result.ice_thickness = map
.next_value::<std::option::Option<crate::model::IceThickness>>()?;
}
__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::PrecipitationSegment {
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_frame,
__type,
__probability,
__qpf,
__snowfall_amount,
__intensity,
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 PrecipitationSegment")
}
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 {
"timeFrame" => Ok(__FieldTag::__time_frame),
"time_frame" => Ok(__FieldTag::__time_frame),
"type" => Ok(__FieldTag::__type),
"probability" => Ok(__FieldTag::__probability),
"qpf" => Ok(__FieldTag::__qpf),
"snowfallAmount" => Ok(__FieldTag::__snowfall_amount),
"snowfall_amount" => Ok(__FieldTag::__snowfall_amount),
"intensity" => Ok(__FieldTag::__intensity),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PrecipitationSegment;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PrecipitationSegment")
}
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_frame => {
if !fields.insert(__FieldTag::__time_frame) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_frame",
));
}
result.time_frame = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__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::precipitation_segment::DominantPrecipitationType,
>>()?
.unwrap_or_default();
}
__FieldTag::__probability => {
if !fields.insert(__FieldTag::__probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for probability",
));
}
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.probability = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__qpf => {
if !fields.insert(__FieldTag::__qpf) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for qpf",
));
}
result.qpf = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__FieldTag::__snowfall_amount => {
if !fields.insert(__FieldTag::__snowfall_amount) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snowfall_amount",
));
}
result.snowfall_amount = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__FieldTag::__intensity => {
if !fields.insert(__FieldTag::__intensity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for intensity",
));
}
result.intensity = map
.next_value::<std::option::Option<
crate::model::precipitation_segment::PrecipitationIntensity,
>>()?
.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::PrecipitationEvent {
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 {
__title,
__subtitle,
__time_frame,
__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 PrecipitationEvent")
}
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 {
"title" => Ok(__FieldTag::__title),
"subtitle" => Ok(__FieldTag::__subtitle),
"timeFrame" => Ok(__FieldTag::__time_frame),
"time_frame" => Ok(__FieldTag::__time_frame),
"intervals" => Ok(__FieldTag::__intervals),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PrecipitationEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PrecipitationEvent")
}
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::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__subtitle => {
if !fields.insert(__FieldTag::__subtitle) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subtitle",
));
}
result.subtitle = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__time_frame => {
if !fields.insert(__FieldTag::__time_frame) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_frame",
));
}
result.time_frame = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__FieldTag::__intervals => {
if !fields.insert(__FieldTag::__intervals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for intervals",
));
}
result.intervals = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::PrecipitationsInterval>,
>>()?
.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::PrecipitationsInterval {
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_frame,
__type,
__probability,
__qpf,
__snow_qpf,
__intensity,
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 PrecipitationsInterval")
}
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 {
"timeFrame" => Ok(__FieldTag::__time_frame),
"time_frame" => Ok(__FieldTag::__time_frame),
"type" => Ok(__FieldTag::__type),
"probability" => Ok(__FieldTag::__probability),
"qpf" => Ok(__FieldTag::__qpf),
"snowQpf" => Ok(__FieldTag::__snow_qpf),
"snow_qpf" => Ok(__FieldTag::__snow_qpf),
"intensity" => Ok(__FieldTag::__intensity),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PrecipitationsInterval;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PrecipitationsInterval")
}
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_frame => {
if !fields.insert(__FieldTag::__time_frame) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_frame",
));
}
result.time_frame = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__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::precipitations_interval::PrecipitationIntervalType>>()?.unwrap_or_default();
}
__FieldTag::__probability => {
if !fields.insert(__FieldTag::__probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for probability",
));
}
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.probability = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__qpf => {
if !fields.insert(__FieldTag::__qpf) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for qpf",
));
}
result.qpf = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__FieldTag::__snow_qpf => {
if !fields.insert(__FieldTag::__snow_qpf) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snow_qpf",
));
}
result.snow_qpf = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__FieldTag::__intensity => {
if !fields.insert(__FieldTag::__intensity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for intensity",
));
}
result.intensity = map.next_value::<std::option::Option<crate::model::precipitations_interval::IntervalPrecipitationIntensity>>()?.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::HistoryHour {
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 {
__interval,
__display_date_time,
__is_daytime,
__weather_condition,
__temperature,
__feels_like_temperature,
__dew_point,
__heat_index,
__wind_chill,
__wet_bulb_temperature,
__relative_humidity,
__uv_index,
__precipitation,
__thunderstorm_probability,
__air_pressure,
__wind,
__visibility,
__cloud_cover,
__ice_thickness,
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 HistoryHour")
}
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 {
"interval" => Ok(__FieldTag::__interval),
"displayDateTime" => Ok(__FieldTag::__display_date_time),
"display_date_time" => Ok(__FieldTag::__display_date_time),
"isDaytime" => Ok(__FieldTag::__is_daytime),
"is_daytime" => Ok(__FieldTag::__is_daytime),
"weatherCondition" => Ok(__FieldTag::__weather_condition),
"weather_condition" => Ok(__FieldTag::__weather_condition),
"temperature" => Ok(__FieldTag::__temperature),
"feelsLikeTemperature" => Ok(__FieldTag::__feels_like_temperature),
"feels_like_temperature" => Ok(__FieldTag::__feels_like_temperature),
"dewPoint" => Ok(__FieldTag::__dew_point),
"dew_point" => Ok(__FieldTag::__dew_point),
"heatIndex" => Ok(__FieldTag::__heat_index),
"heat_index" => Ok(__FieldTag::__heat_index),
"windChill" => Ok(__FieldTag::__wind_chill),
"wind_chill" => Ok(__FieldTag::__wind_chill),
"wetBulbTemperature" => Ok(__FieldTag::__wet_bulb_temperature),
"wet_bulb_temperature" => Ok(__FieldTag::__wet_bulb_temperature),
"relativeHumidity" => Ok(__FieldTag::__relative_humidity),
"relative_humidity" => Ok(__FieldTag::__relative_humidity),
"uvIndex" => Ok(__FieldTag::__uv_index),
"uv_index" => Ok(__FieldTag::__uv_index),
"precipitation" => Ok(__FieldTag::__precipitation),
"thunderstormProbability" => Ok(__FieldTag::__thunderstorm_probability),
"thunderstorm_probability" => {
Ok(__FieldTag::__thunderstorm_probability)
}
"airPressure" => Ok(__FieldTag::__air_pressure),
"air_pressure" => Ok(__FieldTag::__air_pressure),
"wind" => Ok(__FieldTag::__wind),
"visibility" => Ok(__FieldTag::__visibility),
"cloudCover" => Ok(__FieldTag::__cloud_cover),
"cloud_cover" => Ok(__FieldTag::__cloud_cover),
"iceThickness" => Ok(__FieldTag::__ice_thickness),
"ice_thickness" => Ok(__FieldTag::__ice_thickness),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::HistoryHour;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct HistoryHour")
}
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::__interval => {
if !fields.insert(__FieldTag::__interval) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interval",
));
}
result.interval = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__FieldTag::__display_date_time => {
if !fields.insert(__FieldTag::__display_date_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_date_time",
));
}
result.display_date_time = map.next_value::<std::option::Option<google_cloud_type::model::DateTime>>()?
;
}
__FieldTag::__is_daytime => {
if !fields.insert(__FieldTag::__is_daytime) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for is_daytime",
));
}
result.is_daytime = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__weather_condition => {
if !fields.insert(__FieldTag::__weather_condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for weather_condition",
));
}
result.weather_condition = map
.next_value::<std::option::Option<crate::model::WeatherCondition>>(
)?;
}
__FieldTag::__temperature => {
if !fields.insert(__FieldTag::__temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for temperature",
));
}
result.temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__feels_like_temperature => {
if !fields.insert(__FieldTag::__feels_like_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for feels_like_temperature",
));
}
result.feels_like_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__dew_point => {
if !fields.insert(__FieldTag::__dew_point) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dew_point",
));
}
result.dew_point =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__heat_index => {
if !fields.insert(__FieldTag::__heat_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for heat_index",
));
}
result.heat_index =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__wind_chill => {
if !fields.insert(__FieldTag::__wind_chill) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wind_chill",
));
}
result.wind_chill =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__wet_bulb_temperature => {
if !fields.insert(__FieldTag::__wet_bulb_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wet_bulb_temperature",
));
}
result.wet_bulb_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__relative_humidity => {
if !fields.insert(__FieldTag::__relative_humidity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relative_humidity",
));
}
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.relative_humidity = map.next_value::<__With>()?.0;
}
__FieldTag::__uv_index => {
if !fields.insert(__FieldTag::__uv_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uv_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.uv_index = map.next_value::<__With>()?.0;
}
__FieldTag::__precipitation => {
if !fields.insert(__FieldTag::__precipitation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for precipitation",
));
}
result.precipitation = map
.next_value::<std::option::Option<crate::model::Precipitation>>()?;
}
__FieldTag::__thunderstorm_probability => {
if !fields.insert(__FieldTag::__thunderstorm_probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thunderstorm_probability",
));
}
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.thunderstorm_probability = map.next_value::<__With>()?.0;
}
__FieldTag::__air_pressure => {
if !fields.insert(__FieldTag::__air_pressure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for air_pressure",
));
}
result.air_pressure =
map.next_value::<std::option::Option<crate::model::AirPressure>>()?;
}
__FieldTag::__wind => {
if !fields.insert(__FieldTag::__wind) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wind",
));
}
result.wind =
map.next_value::<std::option::Option<crate::model::Wind>>()?;
}
__FieldTag::__visibility => {
if !fields.insert(__FieldTag::__visibility) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for visibility",
));
}
result.visibility =
map.next_value::<std::option::Option<crate::model::Visibility>>()?;
}
__FieldTag::__cloud_cover => {
if !fields.insert(__FieldTag::__cloud_cover) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_cover",
));
}
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.cloud_cover = map.next_value::<__With>()?.0;
}
__FieldTag::__ice_thickness => {
if !fields.insert(__FieldTag::__ice_thickness) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ice_thickness",
));
}
result.ice_thickness = map
.next_value::<std::option::Option<crate::model::IceThickness>>()?;
}
__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::IceThickness {
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 {
__thickness,
__unit,
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 IceThickness")
}
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 {
"thickness" => Ok(__FieldTag::__thickness),
"unit" => Ok(__FieldTag::__unit),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::IceThickness;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct IceThickness")
}
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::__thickness => {
if !fields.insert(__FieldTag::__thickness) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thickness",
));
}
struct __With(std::option::Option<f32>);
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::F32> >::deserialize(deserializer).map(__With)
}
}
result.thickness = map.next_value::<__With>()?.0;
}
__FieldTag::__unit => {
if !fields.insert(__FieldTag::__unit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unit",
));
}
result.unit = map.next_value::<std::option::Option<crate::model::ice_thickness::Unit>>()?.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::Precipitation {
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 {
__probability,
__snow_qpf,
__qpf,
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 Precipitation")
}
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 {
"probability" => Ok(__FieldTag::__probability),
"snowQpf" => Ok(__FieldTag::__snow_qpf),
"snow_qpf" => Ok(__FieldTag::__snow_qpf),
"qpf" => Ok(__FieldTag::__qpf),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Precipitation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Precipitation")
}
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::__probability => {
if !fields.insert(__FieldTag::__probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for probability",
));
}
result.probability = map.next_value::<std::option::Option<crate::model::PrecipitationProbability>>()?
;
}
__FieldTag::__snow_qpf => {
if !fields.insert(__FieldTag::__snow_qpf) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snow_qpf",
));
}
result.snow_qpf = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__FieldTag::__qpf => {
if !fields.insert(__FieldTag::__qpf) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for qpf",
));
}
result.qpf = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__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::PrecipitationProbability {
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 {
__percent,
__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 PrecipitationProbability")
}
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 {
"percent" => Ok(__FieldTag::__percent),
"type" => Ok(__FieldTag::__type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PrecipitationProbability;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PrecipitationProbability")
}
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::__percent => {
if !fields.insert(__FieldTag::__percent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for percent",
));
}
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.percent = 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<
crate::model::precipitation_probability::Type,
>>()?
.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::QuantitativePrecipitationForecast {
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 {
__quantity,
__unit,
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 QuantitativePrecipitationForecast")
}
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 {
"quantity" => Ok(__FieldTag::__quantity),
"unit" => Ok(__FieldTag::__unit),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::QuantitativePrecipitationForecast;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QuantitativePrecipitationForecast")
}
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::__quantity => {
if !fields.insert(__FieldTag::__quantity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for quantity",
));
}
struct __With(std::option::Option<f32>);
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::F32> >::deserialize(deserializer).map(__With)
}
}
result.quantity = map.next_value::<__With>()?.0;
}
__FieldTag::__unit => {
if !fields.insert(__FieldTag::__unit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unit",
));
}
result.unit = map
.next_value::<std::option::Option<
crate::model::quantitative_precipitation_forecast::Unit,
>>()?
.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::DataSource {
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 {
__publisher,
__name,
__authority_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 DataSource")
}
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 {
"publisher" => Ok(__FieldTag::__publisher),
"name" => Ok(__FieldTag::__name),
"authorityUri" => Ok(__FieldTag::__authority_uri),
"authority_uri" => Ok(__FieldTag::__authority_uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataSource")
}
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::__publisher => {
if !fields.insert(__FieldTag::__publisher) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for publisher",
));
}
result.publisher = map.next_value::<std::option::Option<crate::model::data_source::Publisher>>()?.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::__authority_uri => {
if !fields.insert(__FieldTag::__authority_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for authority_uri",
));
}
result.authority_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::SafetyRecommendation {
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 {
__directive,
__subtext,
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 SafetyRecommendation")
}
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 {
"directive" => Ok(__FieldTag::__directive),
"subtext" => Ok(__FieldTag::__subtext),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SafetyRecommendation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SafetyRecommendation")
}
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::__directive => {
if !fields.insert(__FieldTag::__directive) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for directive",
));
}
result.directive = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__subtext => {
if !fields.insert(__FieldTag::__subtext) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subtext",
));
}
result.subtext =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__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::PublicAlerts {
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 {
__alert_id,
__alert_title,
__event_type,
__area_name,
__polygon,
__description,
__severity,
__certainty,
__urgency,
__instruction,
__safety_recommendations,
__timezone_offset,
__start_time,
__expiration_time,
__data_source,
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 PublicAlerts")
}
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 {
"alertId" => Ok(__FieldTag::__alert_id),
"alert_id" => Ok(__FieldTag::__alert_id),
"alertTitle" => Ok(__FieldTag::__alert_title),
"alert_title" => Ok(__FieldTag::__alert_title),
"eventType" => Ok(__FieldTag::__event_type),
"event_type" => Ok(__FieldTag::__event_type),
"areaName" => Ok(__FieldTag::__area_name),
"area_name" => Ok(__FieldTag::__area_name),
"polygon" => Ok(__FieldTag::__polygon),
"description" => Ok(__FieldTag::__description),
"severity" => Ok(__FieldTag::__severity),
"certainty" => Ok(__FieldTag::__certainty),
"urgency" => Ok(__FieldTag::__urgency),
"instruction" => Ok(__FieldTag::__instruction),
"safetyRecommendations" => Ok(__FieldTag::__safety_recommendations),
"safety_recommendations" => Ok(__FieldTag::__safety_recommendations),
"timezoneOffset" => Ok(__FieldTag::__timezone_offset),
"timezone_offset" => Ok(__FieldTag::__timezone_offset),
"startTime" => Ok(__FieldTag::__start_time),
"start_time" => Ok(__FieldTag::__start_time),
"expirationTime" => Ok(__FieldTag::__expiration_time),
"expiration_time" => Ok(__FieldTag::__expiration_time),
"dataSource" => Ok(__FieldTag::__data_source),
"data_source" => Ok(__FieldTag::__data_source),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PublicAlerts;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PublicAlerts")
}
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::__alert_id => {
if !fields.insert(__FieldTag::__alert_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alert_id",
));
}
result.alert_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__alert_title => {
if !fields.insert(__FieldTag::__alert_title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alert_title",
));
}
result.alert_title = map.next_value::<std::option::Option<google_cloud_type::model::LocalizedText>>()?
;
}
__FieldTag::__event_type => {
if !fields.insert(__FieldTag::__event_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for event_type",
));
}
result.event_type = map.next_value::<std::option::Option<crate::model::public_alerts::EventType>>()?.unwrap_or_default();
}
__FieldTag::__area_name => {
if !fields.insert(__FieldTag::__area_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for area_name",
));
}
result.area_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__polygon => {
if !fields.insert(__FieldTag::__polygon) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for polygon",
));
}
result.polygon =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__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>>()?;
}
__FieldTag::__severity => {
if !fields.insert(__FieldTag::__severity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for severity",
));
}
result.severity = map.next_value::<std::option::Option<crate::model::public_alerts::Severity>>()?
;
}
__FieldTag::__certainty => {
if !fields.insert(__FieldTag::__certainty) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for certainty",
));
}
result.certainty = map.next_value::<std::option::Option<crate::model::public_alerts::Certainty>>()?
;
}
__FieldTag::__urgency => {
if !fields.insert(__FieldTag::__urgency) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for urgency",
));
}
result.urgency = map.next_value::<std::option::Option<crate::model::public_alerts::Urgency>>()?
;
}
__FieldTag::__instruction => {
if !fields.insert(__FieldTag::__instruction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instruction",
));
}
result.instruction = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__safety_recommendations => {
if !fields.insert(__FieldTag::__safety_recommendations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safety_recommendations",
));
}
result.safety_recommendations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::SafetyRecommendation>,
>>()?
.unwrap_or_default();
}
__FieldTag::__timezone_offset => {
if !fields.insert(__FieldTag::__timezone_offset) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for timezone_offset",
));
}
result.timezone_offset = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__start_time => {
if !fields.insert(__FieldTag::__start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_time",
));
}
result.start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__expiration_time => {
if !fields.insert(__FieldTag::__expiration_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for expiration_time",
));
}
result.expiration_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__data_source => {
if !fields.insert(__FieldTag::__data_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source",
));
}
result.data_source =
map.next_value::<std::option::Option<crate::model::DataSource>>()?;
}
__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::Temperature {
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 {
__degrees,
__unit,
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 Temperature")
}
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 {
"degrees" => Ok(__FieldTag::__degrees),
"unit" => Ok(__FieldTag::__unit),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Temperature;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Temperature")
}
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::__degrees => {
if !fields.insert(__FieldTag::__degrees) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for degrees",
));
}
struct __With(std::option::Option<f32>);
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::F32> >::deserialize(deserializer).map(__With)
}
}
result.degrees = map.next_value::<__With>()?.0;
}
__FieldTag::__unit => {
if !fields.insert(__FieldTag::__unit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unit",
));
}
result.unit = map
.next_value::<std::option::Option<crate::model::temperature::Unit>>(
)?
.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::Visibility {
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,
__unit,
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 Visibility")
}
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),
"unit" => Ok(__FieldTag::__unit),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Visibility;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Visibility")
}
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",
));
}
struct __With(std::option::Option<f32>);
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::F32> >::deserialize(deserializer).map(__With)
}
}
result.distance = map.next_value::<__With>()?.0;
}
__FieldTag::__unit => {
if !fields.insert(__FieldTag::__unit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unit",
));
}
result.unit = map
.next_value::<std::option::Option<crate::model::visibility::Unit>>(
)?
.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::WeatherCondition {
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 {
__icon_base_uri,
__description,
__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 WeatherCondition")
}
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 {
"iconBaseUri" => Ok(__FieldTag::__icon_base_uri),
"icon_base_uri" => Ok(__FieldTag::__icon_base_uri),
"description" => Ok(__FieldTag::__description),
"type" => Ok(__FieldTag::__type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WeatherCondition;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WeatherCondition")
}
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::__icon_base_uri => {
if !fields.insert(__FieldTag::__icon_base_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for icon_base_uri",
));
}
result.icon_base_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__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<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::weather_condition::Type>>()?.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::LookupCurrentConditionsRequest {
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,
__units_system,
__language_code,
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 LookupCurrentConditionsRequest")
}
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),
"unitsSystem" => Ok(__FieldTag::__units_system),
"units_system" => Ok(__FieldTag::__units_system),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupCurrentConditionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupCurrentConditionsRequest")
}
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",
));
}
result.location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
;
}
__FieldTag::__units_system => {
if !fields.insert(__FieldTag::__units_system) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for units_system",
));
}
result.units_system = map
.next_value::<std::option::Option<crate::model::UnitsSystem>>()?
.unwrap_or_default();
}
__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>>()?;
}
__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::LookupCurrentConditionsResponse {
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 {
__current_time,
__time_zone,
__is_daytime,
__weather_condition,
__temperature,
__feels_like_temperature,
__dew_point,
__heat_index,
__wind_chill,
__relative_humidity,
__uv_index,
__precipitation,
__thunderstorm_probability,
__air_pressure,
__wind,
__visibility,
__cloud_cover,
__current_conditions_history,
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 LookupCurrentConditionsResponse")
}
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 {
"currentTime" => Ok(__FieldTag::__current_time),
"current_time" => Ok(__FieldTag::__current_time),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
"isDaytime" => Ok(__FieldTag::__is_daytime),
"is_daytime" => Ok(__FieldTag::__is_daytime),
"weatherCondition" => Ok(__FieldTag::__weather_condition),
"weather_condition" => Ok(__FieldTag::__weather_condition),
"temperature" => Ok(__FieldTag::__temperature),
"feelsLikeTemperature" => Ok(__FieldTag::__feels_like_temperature),
"feels_like_temperature" => Ok(__FieldTag::__feels_like_temperature),
"dewPoint" => Ok(__FieldTag::__dew_point),
"dew_point" => Ok(__FieldTag::__dew_point),
"heatIndex" => Ok(__FieldTag::__heat_index),
"heat_index" => Ok(__FieldTag::__heat_index),
"windChill" => Ok(__FieldTag::__wind_chill),
"wind_chill" => Ok(__FieldTag::__wind_chill),
"relativeHumidity" => Ok(__FieldTag::__relative_humidity),
"relative_humidity" => Ok(__FieldTag::__relative_humidity),
"uvIndex" => Ok(__FieldTag::__uv_index),
"uv_index" => Ok(__FieldTag::__uv_index),
"precipitation" => Ok(__FieldTag::__precipitation),
"thunderstormProbability" => Ok(__FieldTag::__thunderstorm_probability),
"thunderstorm_probability" => {
Ok(__FieldTag::__thunderstorm_probability)
}
"airPressure" => Ok(__FieldTag::__air_pressure),
"air_pressure" => Ok(__FieldTag::__air_pressure),
"wind" => Ok(__FieldTag::__wind),
"visibility" => Ok(__FieldTag::__visibility),
"cloudCover" => Ok(__FieldTag::__cloud_cover),
"cloud_cover" => Ok(__FieldTag::__cloud_cover),
"currentConditionsHistory" => {
Ok(__FieldTag::__current_conditions_history)
}
"current_conditions_history" => {
Ok(__FieldTag::__current_conditions_history)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupCurrentConditionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupCurrentConditionsResponse")
}
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::__current_time => {
if !fields.insert(__FieldTag::__current_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for current_time",
));
}
result.current_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__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<google_cloud_type::model::TimeZone>>()?
;
}
__FieldTag::__is_daytime => {
if !fields.insert(__FieldTag::__is_daytime) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for is_daytime",
));
}
result.is_daytime = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__weather_condition => {
if !fields.insert(__FieldTag::__weather_condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for weather_condition",
));
}
result.weather_condition = map
.next_value::<std::option::Option<crate::model::WeatherCondition>>(
)?;
}
__FieldTag::__temperature => {
if !fields.insert(__FieldTag::__temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for temperature",
));
}
result.temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__feels_like_temperature => {
if !fields.insert(__FieldTag::__feels_like_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for feels_like_temperature",
));
}
result.feels_like_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__dew_point => {
if !fields.insert(__FieldTag::__dew_point) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dew_point",
));
}
result.dew_point =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__heat_index => {
if !fields.insert(__FieldTag::__heat_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for heat_index",
));
}
result.heat_index =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__wind_chill => {
if !fields.insert(__FieldTag::__wind_chill) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wind_chill",
));
}
result.wind_chill =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__relative_humidity => {
if !fields.insert(__FieldTag::__relative_humidity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relative_humidity",
));
}
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.relative_humidity = map.next_value::<__With>()?.0;
}
__FieldTag::__uv_index => {
if !fields.insert(__FieldTag::__uv_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uv_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.uv_index = map.next_value::<__With>()?.0;
}
__FieldTag::__precipitation => {
if !fields.insert(__FieldTag::__precipitation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for precipitation",
));
}
result.precipitation = map
.next_value::<std::option::Option<crate::model::Precipitation>>()?;
}
__FieldTag::__thunderstorm_probability => {
if !fields.insert(__FieldTag::__thunderstorm_probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thunderstorm_probability",
));
}
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.thunderstorm_probability = map.next_value::<__With>()?.0;
}
__FieldTag::__air_pressure => {
if !fields.insert(__FieldTag::__air_pressure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for air_pressure",
));
}
result.air_pressure =
map.next_value::<std::option::Option<crate::model::AirPressure>>()?;
}
__FieldTag::__wind => {
if !fields.insert(__FieldTag::__wind) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for wind",
));
}
result.wind =
map.next_value::<std::option::Option<crate::model::Wind>>()?;
}
__FieldTag::__visibility => {
if !fields.insert(__FieldTag::__visibility) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for visibility",
));
}
result.visibility =
map.next_value::<std::option::Option<crate::model::Visibility>>()?;
}
__FieldTag::__cloud_cover => {
if !fields.insert(__FieldTag::__cloud_cover) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_cover",
));
}
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.cloud_cover = map.next_value::<__With>()?.0;
}
__FieldTag::__current_conditions_history => {
if !fields.insert(__FieldTag::__current_conditions_history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for current_conditions_history",
));
}
result.current_conditions_history = map.next_value::<std::option::Option<crate::model::lookup_current_conditions_response::CurrentConditionsHistory>>()?
;
}
__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::lookup_current_conditions_response::CurrentConditionsHistory
{
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 {
__temperature_change,
__max_temperature,
__min_temperature,
__snow_qpf,
__qpf,
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 CurrentConditionsHistory")
}
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 {
"temperatureChange" => Ok(__FieldTag::__temperature_change),
"temperature_change" => Ok(__FieldTag::__temperature_change),
"maxTemperature" => Ok(__FieldTag::__max_temperature),
"max_temperature" => Ok(__FieldTag::__max_temperature),
"minTemperature" => Ok(__FieldTag::__min_temperature),
"min_temperature" => Ok(__FieldTag::__min_temperature),
"snowQpf" => Ok(__FieldTag::__snow_qpf),
"snow_qpf" => Ok(__FieldTag::__snow_qpf),
"qpf" => Ok(__FieldTag::__qpf),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::lookup_current_conditions_response::CurrentConditionsHistory;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CurrentConditionsHistory")
}
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::__temperature_change => {
if !fields.insert(__FieldTag::__temperature_change) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for temperature_change",
));
}
result.temperature_change =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__max_temperature => {
if !fields.insert(__FieldTag::__max_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_temperature",
));
}
result.max_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__min_temperature => {
if !fields.insert(__FieldTag::__min_temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_temperature",
));
}
result.min_temperature =
map.next_value::<std::option::Option<crate::model::Temperature>>()?;
}
__FieldTag::__snow_qpf => {
if !fields.insert(__FieldTag::__snow_qpf) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snow_qpf",
));
}
result.snow_qpf = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__FieldTag::__qpf => {
if !fields.insert(__FieldTag::__qpf) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for qpf",
));
}
result.qpf = map.next_value::<std::option::Option<
crate::model::QuantitativePrecipitationForecast,
>>()?;
}
__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::LookupForecastHoursRequest {
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,
__hours,
__units_system,
__language_code,
__page_size,
__page_token,
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 LookupForecastHoursRequest")
}
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),
"hours" => Ok(__FieldTag::__hours),
"unitsSystem" => Ok(__FieldTag::__units_system),
"units_system" => Ok(__FieldTag::__units_system),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupForecastHoursRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupForecastHoursRequest")
}
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",
));
}
result.location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
;
}
__FieldTag::__hours => {
if !fields.insert(__FieldTag::__hours) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hours",
));
}
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.hours = map.next_value::<__With>()?.0;
}
__FieldTag::__units_system => {
if !fields.insert(__FieldTag::__units_system) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for units_system",
));
}
result.units_system = map
.next_value::<std::option::Option<crate::model::UnitsSystem>>()?
.unwrap_or_default();
}
__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>>()?;
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
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.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = 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::LookupForecastHoursResponse {
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 {
__forecast_hours,
__time_zone,
__next_page_token,
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 LookupForecastHoursResponse")
}
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 {
"forecastHours" => Ok(__FieldTag::__forecast_hours),
"forecast_hours" => Ok(__FieldTag::__forecast_hours),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupForecastHoursResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupForecastHoursResponse")
}
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::__forecast_hours => {
if !fields.insert(__FieldTag::__forecast_hours) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for forecast_hours",
));
}
result.forecast_hours = map.next_value::<std::option::Option<std::vec::Vec<crate::model::ForecastHour>>>()?.unwrap_or_default();
}
__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<google_cloud_type::model::TimeZone>>()?
;
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = 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::LookupForecastDaysRequest {
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,
__days,
__units_system,
__language_code,
__page_size,
__page_token,
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 LookupForecastDaysRequest")
}
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),
"days" => Ok(__FieldTag::__days),
"unitsSystem" => Ok(__FieldTag::__units_system),
"units_system" => Ok(__FieldTag::__units_system),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupForecastDaysRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupForecastDaysRequest")
}
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",
));
}
result.location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
;
}
__FieldTag::__days => {
if !fields.insert(__FieldTag::__days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for days",
));
}
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.days = map.next_value::<__With>()?.0;
}
__FieldTag::__units_system => {
if !fields.insert(__FieldTag::__units_system) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for units_system",
));
}
result.units_system = map
.next_value::<std::option::Option<crate::model::UnitsSystem>>()?
.unwrap_or_default();
}
__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>>()?;
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
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.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = 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::LookupForecastDaysResponse {
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 {
__forecast_days,
__time_zone,
__next_page_token,
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 LookupForecastDaysResponse")
}
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 {
"forecastDays" => Ok(__FieldTag::__forecast_days),
"forecast_days" => Ok(__FieldTag::__forecast_days),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupForecastDaysResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupForecastDaysResponse")
}
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::__forecast_days => {
if !fields.insert(__FieldTag::__forecast_days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for forecast_days",
));
}
result.forecast_days = map.next_value::<std::option::Option<std::vec::Vec<crate::model::ForecastDay>>>()?.unwrap_or_default();
}
__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<google_cloud_type::model::TimeZone>>()?
;
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = 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::LookupHistoryHoursRequest {
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,
__hours,
__units_system,
__language_code,
__page_size,
__page_token,
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 LookupHistoryHoursRequest")
}
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),
"hours" => Ok(__FieldTag::__hours),
"unitsSystem" => Ok(__FieldTag::__units_system),
"units_system" => Ok(__FieldTag::__units_system),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupHistoryHoursRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupHistoryHoursRequest")
}
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",
));
}
result.location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
;
}
__FieldTag::__hours => {
if !fields.insert(__FieldTag::__hours) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hours",
));
}
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.hours = map.next_value::<__With>()?.0;
}
__FieldTag::__units_system => {
if !fields.insert(__FieldTag::__units_system) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for units_system",
));
}
result.units_system = map
.next_value::<std::option::Option<crate::model::UnitsSystem>>()?
.unwrap_or_default();
}
__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>>()?;
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
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.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = 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::LookupHistoryHoursResponse {
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 {
__history_hours,
__time_zone,
__next_page_token,
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 LookupHistoryHoursResponse")
}
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 {
"historyHours" => Ok(__FieldTag::__history_hours),
"history_hours" => Ok(__FieldTag::__history_hours),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupHistoryHoursResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupHistoryHoursResponse")
}
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::__history_hours => {
if !fields.insert(__FieldTag::__history_hours) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for history_hours",
));
}
result.history_hours = map.next_value::<std::option::Option<std::vec::Vec<crate::model::HistoryHour>>>()?.unwrap_or_default();
}
__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<google_cloud_type::model::TimeZone>>()?
;
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = 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::LookupPublicAlertsRequest {
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,
__language_code,
__page_size,
__page_token,
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 LookupPublicAlertsRequest")
}
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),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupPublicAlertsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupPublicAlertsRequest")
}
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",
));
}
result.location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
;
}
__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>>()?;
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
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.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = 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::LookupPublicAlertsResponse {
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 {
__weather_alerts,
__region_code,
__next_page_token,
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 LookupPublicAlertsResponse")
}
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 {
"weatherAlerts" => Ok(__FieldTag::__weather_alerts),
"weather_alerts" => Ok(__FieldTag::__weather_alerts),
"regionCode" => Ok(__FieldTag::__region_code),
"region_code" => Ok(__FieldTag::__region_code),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupPublicAlertsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupPublicAlertsResponse")
}
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::__weather_alerts => {
if !fields.insert(__FieldTag::__weather_alerts) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for weather_alerts",
));
}
result.weather_alerts = map.next_value::<std::option::Option<std::vec::Vec<crate::model::PublicAlerts>>>()?.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::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = 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::LookupForecastMinutesRequest {
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,
__units_system,
__page_size,
__page_token,
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 LookupForecastMinutesRequest")
}
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),
"unitsSystem" => Ok(__FieldTag::__units_system),
"units_system" => Ok(__FieldTag::__units_system),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupForecastMinutesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupForecastMinutesRequest")
}
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",
));
}
result.location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
;
}
__FieldTag::__units_system => {
if !fields.insert(__FieldTag::__units_system) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for units_system",
));
}
result.units_system = map
.next_value::<std::option::Option<crate::model::UnitsSystem>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
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.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = 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::LookupForecastMinutesResponse {
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 {
__overall_prediction_timeframe,
__time_zone,
__next_page_token,
__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 LookupForecastMinutesResponse")
}
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 {
"overallPredictionTimeframe" => {
Ok(__FieldTag::__overall_prediction_timeframe)
}
"overall_prediction_timeframe" => {
Ok(__FieldTag::__overall_prediction_timeframe)
}
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"segments" => Ok(__FieldTag::__segments),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupForecastMinutesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupForecastMinutesResponse")
}
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::__overall_prediction_timeframe => {
if !fields.insert(__FieldTag::__overall_prediction_timeframe) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for overall_prediction_timeframe",
));
}
result.overall_prediction_timeframe = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__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<google_cloud_type::model::TimeZone>>()?
;
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__segments => {
if !fields.insert(__FieldTag::__segments) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for segments",
));
}
result.segments = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::PrecipitationSegment>,
>>()?
.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::LookupMapTileRequest {
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 {
__map_type,
__zoom,
__x,
__y,
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 LookupMapTileRequest")
}
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 {
"mapType" => Ok(__FieldTag::__map_type),
"map_type" => Ok(__FieldTag::__map_type),
"zoom" => Ok(__FieldTag::__zoom),
"x" => Ok(__FieldTag::__x),
"y" => Ok(__FieldTag::__y),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LookupMapTileRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LookupMapTileRequest")
}
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::__map_type => {
if !fields.insert(__FieldTag::__map_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for map_type",
));
}
result.map_type = map
.next_value::<std::option::Option<crate::model::MapType>>()?
.unwrap_or_default();
}
__FieldTag::__zoom => {
if !fields.insert(__FieldTag::__zoom) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for zoom",
));
}
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.zoom = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__x => {
if !fields.insert(__FieldTag::__x) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for x",
));
}
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.x = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__y => {
if !fields.insert(__FieldTag::__y) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for y",
));
}
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.y = map.next_value::<__With>()?.0.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::Wind {
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 {
__direction,
__speed,
__gust,
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 Wind")
}
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 {
"direction" => Ok(__FieldTag::__direction),
"speed" => Ok(__FieldTag::__speed),
"gust" => Ok(__FieldTag::__gust),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Wind;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Wind")
}
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::__direction => {
if !fields.insert(__FieldTag::__direction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for direction",
));
}
result.direction = map
.next_value::<std::option::Option<crate::model::WindDirection>>()?;
}
__FieldTag::__speed => {
if !fields.insert(__FieldTag::__speed) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for speed",
));
}
result.speed =
map.next_value::<std::option::Option<crate::model::WindSpeed>>()?;
}
__FieldTag::__gust => {
if !fields.insert(__FieldTag::__gust) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gust",
));
}
result.gust =
map.next_value::<std::option::Option<crate::model::WindSpeed>>()?;
}
__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::WindDirection {
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 {
__degrees,
__cardinal,
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 WindDirection")
}
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 {
"degrees" => Ok(__FieldTag::__degrees),
"cardinal" => Ok(__FieldTag::__cardinal),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WindDirection;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WindDirection")
}
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::__degrees => {
if !fields.insert(__FieldTag::__degrees) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for degrees",
));
}
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.degrees = map.next_value::<__With>()?.0;
}
__FieldTag::__cardinal => {
if !fields.insert(__FieldTag::__cardinal) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cardinal",
));
}
result.cardinal = map.next_value::<std::option::Option<crate::model::wind_direction::Cardinal>>()?.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::WindSpeed {
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 {
__value,
__unit,
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 WindSpeed")
}
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 {
"value" => Ok(__FieldTag::__value),
"unit" => Ok(__FieldTag::__unit),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WindSpeed;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WindSpeed")
}
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::__value => {
if !fields.insert(__FieldTag::__value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value",
));
}
struct __With(std::option::Option<f32>);
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::F32> >::deserialize(deserializer).map(__With)
}
}
result.value = map.next_value::<__With>()?.0;
}
__FieldTag::__unit => {
if !fields.insert(__FieldTag::__unit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unit",
));
}
result.unit = map
.next_value::<std::option::Option<crate::model::wind_speed::Unit>>(
)?
.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)
}
}