#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Authentication {
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 {
__rules,
__providers,
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 Authentication")
}
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 {
"rules" => Ok(__FieldTag::__rules),
"providers" => Ok(__FieldTag::__providers),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Authentication;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Authentication")
}
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::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::AuthenticationRule>,
>>()?
.unwrap_or_default();
}
__FieldTag::__providers => {
if !fields.insert(__FieldTag::__providers) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for providers",
));
}
result.providers = map.next_value::<std::option::Option<std::vec::Vec<crate::model::AuthProvider>>>()?.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::AuthenticationRule {
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 {
__selector,
__oauth,
__allow_without_credential,
__requirements,
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 AuthenticationRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"oauth" => Ok(__FieldTag::__oauth),
"allowWithoutCredential" => Ok(__FieldTag::__allow_without_credential),
"allow_without_credential" => {
Ok(__FieldTag::__allow_without_credential)
}
"requirements" => Ok(__FieldTag::__requirements),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AuthenticationRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AuthenticationRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__oauth => {
if !fields.insert(__FieldTag::__oauth) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for oauth",
));
}
result.oauth = map
.next_value::<std::option::Option<crate::model::OAuthRequirements>>(
)?;
}
__FieldTag::__allow_without_credential => {
if !fields.insert(__FieldTag::__allow_without_credential) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_without_credential",
));
}
result.allow_without_credential = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__requirements => {
if !fields.insert(__FieldTag::__requirements) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for requirements",
));
}
result.requirements =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::AuthRequirement>,
>>()?
.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::JwtLocation {
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 {
__header,
__query,
__cookie,
__value_prefix,
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 JwtLocation")
}
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 {
"header" => Ok(__FieldTag::__header),
"query" => Ok(__FieldTag::__query),
"cookie" => Ok(__FieldTag::__cookie),
"valuePrefix" => Ok(__FieldTag::__value_prefix),
"value_prefix" => Ok(__FieldTag::__value_prefix),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JwtLocation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JwtLocation")
}
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::__header => {
if !fields.insert(__FieldTag::__header) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for header",
));
}
if result.r#in.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `r#in`, a oneof with full ID .google.api.JwtLocation.header, latest field was header",
));
}
result.r#in =
std::option::Option::Some(crate::model::jwt_location::In::Header(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
if result.r#in.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `r#in`, a oneof with full ID .google.api.JwtLocation.query, latest field was query",
));
}
result.r#in =
std::option::Option::Some(crate::model::jwt_location::In::Query(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__cookie => {
if !fields.insert(__FieldTag::__cookie) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cookie",
));
}
if result.r#in.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `r#in`, a oneof with full ID .google.api.JwtLocation.cookie, latest field was cookie",
));
}
result.r#in =
std::option::Option::Some(crate::model::jwt_location::In::Cookie(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__value_prefix => {
if !fields.insert(__FieldTag::__value_prefix) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value_prefix",
));
}
result.value_prefix = 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::AuthProvider {
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 {
__id,
__issuer,
__jwks_uri,
__audiences,
__authorization_url,
__jwt_locations,
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 AuthProvider")
}
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 {
"id" => Ok(__FieldTag::__id),
"issuer" => Ok(__FieldTag::__issuer),
"jwksUri" => Ok(__FieldTag::__jwks_uri),
"jwks_uri" => Ok(__FieldTag::__jwks_uri),
"audiences" => Ok(__FieldTag::__audiences),
"authorizationUrl" => Ok(__FieldTag::__authorization_url),
"authorization_url" => Ok(__FieldTag::__authorization_url),
"jwtLocations" => Ok(__FieldTag::__jwt_locations),
"jwt_locations" => Ok(__FieldTag::__jwt_locations),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AuthProvider;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AuthProvider")
}
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::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__issuer => {
if !fields.insert(__FieldTag::__issuer) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for issuer",
));
}
result.issuer = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__jwks_uri => {
if !fields.insert(__FieldTag::__jwks_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jwks_uri",
));
}
result.jwks_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__audiences => {
if !fields.insert(__FieldTag::__audiences) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for audiences",
));
}
result.audiences = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__authorization_url => {
if !fields.insert(__FieldTag::__authorization_url) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for authorization_url",
));
}
result.authorization_url = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__jwt_locations => {
if !fields.insert(__FieldTag::__jwt_locations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jwt_locations",
));
}
result.jwt_locations = map.next_value::<std::option::Option<std::vec::Vec<crate::model::JwtLocation>>>()?.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::OAuthRequirements {
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 {
__canonical_scopes,
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 OAuthRequirements")
}
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 {
"canonicalScopes" => Ok(__FieldTag::__canonical_scopes),
"canonical_scopes" => Ok(__FieldTag::__canonical_scopes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::OAuthRequirements;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct OAuthRequirements")
}
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::__canonical_scopes => {
if !fields.insert(__FieldTag::__canonical_scopes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for canonical_scopes",
));
}
result.canonical_scopes = 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::AuthRequirement {
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 {
__provider_id,
__audiences,
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 AuthRequirement")
}
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 {
"providerId" => Ok(__FieldTag::__provider_id),
"provider_id" => Ok(__FieldTag::__provider_id),
"audiences" => Ok(__FieldTag::__audiences),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AuthRequirement;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AuthRequirement")
}
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::__provider_id => {
if !fields.insert(__FieldTag::__provider_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provider_id",
));
}
result.provider_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__audiences => {
if !fields.insert(__FieldTag::__audiences) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for audiences",
));
}
result.audiences = 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::Backend {
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 {
__rules,
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 Backend")
}
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 {
"rules" => Ok(__FieldTag::__rules),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Backend;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Backend")
}
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::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules = map.next_value::<std::option::Option<std::vec::Vec<crate::model::BackendRule>>>()?.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::BackendRule {
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 {
__selector,
__address,
__deadline,
__min_deadline,
__operation_deadline,
__path_translation,
__jwt_audience,
__disable_auth,
__protocol,
__overrides_by_request_protocol,
__load_balancing_policy,
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 BackendRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"address" => Ok(__FieldTag::__address),
"deadline" => Ok(__FieldTag::__deadline),
"minDeadline" => Ok(__FieldTag::__min_deadline),
"min_deadline" => Ok(__FieldTag::__min_deadline),
"operationDeadline" => Ok(__FieldTag::__operation_deadline),
"operation_deadline" => Ok(__FieldTag::__operation_deadline),
"pathTranslation" => Ok(__FieldTag::__path_translation),
"path_translation" => Ok(__FieldTag::__path_translation),
"jwtAudience" => Ok(__FieldTag::__jwt_audience),
"jwt_audience" => Ok(__FieldTag::__jwt_audience),
"disableAuth" => Ok(__FieldTag::__disable_auth),
"disable_auth" => Ok(__FieldTag::__disable_auth),
"protocol" => Ok(__FieldTag::__protocol),
"overridesByRequestProtocol" => {
Ok(__FieldTag::__overrides_by_request_protocol)
}
"overrides_by_request_protocol" => {
Ok(__FieldTag::__overrides_by_request_protocol)
}
"loadBalancingPolicy" => Ok(__FieldTag::__load_balancing_policy),
"load_balancing_policy" => Ok(__FieldTag::__load_balancing_policy),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackendRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackendRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__address => {
if !fields.insert(__FieldTag::__address) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for address",
));
}
result.address = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__deadline => {
if !fields.insert(__FieldTag::__deadline) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for deadline",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.deadline = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__min_deadline => {
if !fields.insert(__FieldTag::__min_deadline) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_deadline",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.min_deadline = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__operation_deadline => {
if !fields.insert(__FieldTag::__operation_deadline) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation_deadline",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.operation_deadline =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__path_translation => {
if !fields.insert(__FieldTag::__path_translation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for path_translation",
));
}
result.path_translation =
map.next_value::<std::option::Option<
crate::model::backend_rule::PathTranslation,
>>()?
.unwrap_or_default();
}
__FieldTag::__jwt_audience => {
if !fields.insert(__FieldTag::__jwt_audience) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jwt_audience",
));
}
if result.authentication.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `authentication`, a oneof with full ID .google.api.BackendRule.jwt_audience, latest field was jwtAudience",
));
}
result.authentication = std::option::Option::Some(
crate::model::backend_rule::Authentication::JwtAudience(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__disable_auth => {
if !fields.insert(__FieldTag::__disable_auth) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable_auth",
));
}
if result.authentication.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `authentication`, a oneof with full ID .google.api.BackendRule.disable_auth, latest field was disableAuth",
));
}
result.authentication = std::option::Option::Some(
crate::model::backend_rule::Authentication::DisableAuth(
map.next_value::<std::option::Option<bool>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__protocol => {
if !fields.insert(__FieldTag::__protocol) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for protocol",
));
}
result.protocol = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__overrides_by_request_protocol => {
if !fields.insert(__FieldTag::__overrides_by_request_protocol) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for overrides_by_request_protocol",
));
}
result.overrides_by_request_protocol = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::BackendRule,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__load_balancing_policy => {
if !fields.insert(__FieldTag::__load_balancing_policy) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for load_balancing_policy",
));
}
result.load_balancing_policy = 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::Billing {
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 {
__consumer_destinations,
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 Billing")
}
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 {
"consumerDestinations" => Ok(__FieldTag::__consumer_destinations),
"consumer_destinations" => Ok(__FieldTag::__consumer_destinations),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Billing;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Billing")
}
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::__consumer_destinations => {
if !fields.insert(__FieldTag::__consumer_destinations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for consumer_destinations",
));
}
result.consumer_destinations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::billing::BillingDestination>,
>>()?
.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::billing::BillingDestination {
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 {
__monitored_resource,
__metrics,
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 BillingDestination")
}
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 {
"monitoredResource" => Ok(__FieldTag::__monitored_resource),
"monitored_resource" => Ok(__FieldTag::__monitored_resource),
"metrics" => Ok(__FieldTag::__metrics),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::billing::BillingDestination;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BillingDestination")
}
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::__monitored_resource => {
if !fields.insert(__FieldTag::__monitored_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for monitored_resource",
));
}
result.monitored_resource = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__metrics => {
if !fields.insert(__FieldTag::__metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metrics",
));
}
result.metrics = map.next_value::<std::option::Option<std::vec::Vec<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::CommonLanguageSettings {
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 {
__reference_docs_uri,
__destinations,
__selective_gapic_generation,
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 CommonLanguageSettings")
}
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 {
"referenceDocsUri" => Ok(__FieldTag::__reference_docs_uri),
"reference_docs_uri" => Ok(__FieldTag::__reference_docs_uri),
"destinations" => Ok(__FieldTag::__destinations),
"selectiveGapicGeneration" => {
Ok(__FieldTag::__selective_gapic_generation)
}
"selective_gapic_generation" => {
Ok(__FieldTag::__selective_gapic_generation)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CommonLanguageSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CommonLanguageSettings")
}
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::__reference_docs_uri => {
if !fields.insert(__FieldTag::__reference_docs_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reference_docs_uri",
));
}
result.reference_docs_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__destinations => {
if !fields.insert(__FieldTag::__destinations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for destinations",
));
}
result.destinations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::ClientLibraryDestination>,
>>()?
.unwrap_or_default();
}
__FieldTag::__selective_gapic_generation => {
if !fields.insert(__FieldTag::__selective_gapic_generation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selective_gapic_generation",
));
}
result.selective_gapic_generation = map.next_value::<std::option::Option<crate::model::SelectiveGapicGeneration>>()?
;
}
__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::ClientLibrarySettings {
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 {
__version,
__launch_stage,
__rest_numeric_enums,
__java_settings,
__cpp_settings,
__php_settings,
__python_settings,
__node_settings,
__dotnet_settings,
__ruby_settings,
__go_settings,
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 ClientLibrarySettings")
}
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 {
"version" => Ok(__FieldTag::__version),
"launchStage" => Ok(__FieldTag::__launch_stage),
"launch_stage" => Ok(__FieldTag::__launch_stage),
"restNumericEnums" => Ok(__FieldTag::__rest_numeric_enums),
"rest_numeric_enums" => Ok(__FieldTag::__rest_numeric_enums),
"javaSettings" => Ok(__FieldTag::__java_settings),
"java_settings" => Ok(__FieldTag::__java_settings),
"cppSettings" => Ok(__FieldTag::__cpp_settings),
"cpp_settings" => Ok(__FieldTag::__cpp_settings),
"phpSettings" => Ok(__FieldTag::__php_settings),
"php_settings" => Ok(__FieldTag::__php_settings),
"pythonSettings" => Ok(__FieldTag::__python_settings),
"python_settings" => Ok(__FieldTag::__python_settings),
"nodeSettings" => Ok(__FieldTag::__node_settings),
"node_settings" => Ok(__FieldTag::__node_settings),
"dotnetSettings" => Ok(__FieldTag::__dotnet_settings),
"dotnet_settings" => Ok(__FieldTag::__dotnet_settings),
"rubySettings" => Ok(__FieldTag::__ruby_settings),
"ruby_settings" => Ok(__FieldTag::__ruby_settings),
"goSettings" => Ok(__FieldTag::__go_settings),
"go_settings" => Ok(__FieldTag::__go_settings),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClientLibrarySettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClientLibrarySettings")
}
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::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
result.version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__launch_stage => {
if !fields.insert(__FieldTag::__launch_stage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for launch_stage",
));
}
result.launch_stage = map
.next_value::<std::option::Option<crate::model::LaunchStage>>()?
.unwrap_or_default();
}
__FieldTag::__rest_numeric_enums => {
if !fields.insert(__FieldTag::__rest_numeric_enums) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rest_numeric_enums",
));
}
result.rest_numeric_enums = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__java_settings => {
if !fields.insert(__FieldTag::__java_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for java_settings",
));
}
result.java_settings = map
.next_value::<std::option::Option<crate::model::JavaSettings>>()?;
}
__FieldTag::__cpp_settings => {
if !fields.insert(__FieldTag::__cpp_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cpp_settings",
));
}
result.cpp_settings =
map.next_value::<std::option::Option<crate::model::CppSettings>>()?;
}
__FieldTag::__php_settings => {
if !fields.insert(__FieldTag::__php_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for php_settings",
));
}
result.php_settings =
map.next_value::<std::option::Option<crate::model::PhpSettings>>()?;
}
__FieldTag::__python_settings => {
if !fields.insert(__FieldTag::__python_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for python_settings",
));
}
result.python_settings = map
.next_value::<std::option::Option<crate::model::PythonSettings>>(
)?;
}
__FieldTag::__node_settings => {
if !fields.insert(__FieldTag::__node_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_settings",
));
}
result.node_settings = map
.next_value::<std::option::Option<crate::model::NodeSettings>>()?;
}
__FieldTag::__dotnet_settings => {
if !fields.insert(__FieldTag::__dotnet_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dotnet_settings",
));
}
result.dotnet_settings = map
.next_value::<std::option::Option<crate::model::DotnetSettings>>(
)?;
}
__FieldTag::__ruby_settings => {
if !fields.insert(__FieldTag::__ruby_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ruby_settings",
));
}
result.ruby_settings = map
.next_value::<std::option::Option<crate::model::RubySettings>>()?;
}
__FieldTag::__go_settings => {
if !fields.insert(__FieldTag::__go_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for go_settings",
));
}
result.go_settings =
map.next_value::<std::option::Option<crate::model::GoSettings>>()?;
}
__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::Publishing {
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 {
__method_settings,
__new_issue_uri,
__documentation_uri,
__api_short_name,
__github_label,
__codeowner_github_teams,
__doc_tag_prefix,
__organization,
__library_settings,
__proto_reference_documentation_uri,
__rest_reference_documentation_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 Publishing")
}
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 {
"methodSettings" => Ok(__FieldTag::__method_settings),
"method_settings" => Ok(__FieldTag::__method_settings),
"newIssueUri" => Ok(__FieldTag::__new_issue_uri),
"new_issue_uri" => Ok(__FieldTag::__new_issue_uri),
"documentationUri" => Ok(__FieldTag::__documentation_uri),
"documentation_uri" => Ok(__FieldTag::__documentation_uri),
"apiShortName" => Ok(__FieldTag::__api_short_name),
"api_short_name" => Ok(__FieldTag::__api_short_name),
"githubLabel" => Ok(__FieldTag::__github_label),
"github_label" => Ok(__FieldTag::__github_label),
"codeownerGithubTeams" => Ok(__FieldTag::__codeowner_github_teams),
"codeowner_github_teams" => Ok(__FieldTag::__codeowner_github_teams),
"docTagPrefix" => Ok(__FieldTag::__doc_tag_prefix),
"doc_tag_prefix" => Ok(__FieldTag::__doc_tag_prefix),
"organization" => Ok(__FieldTag::__organization),
"librarySettings" => Ok(__FieldTag::__library_settings),
"library_settings" => Ok(__FieldTag::__library_settings),
"protoReferenceDocumentationUri" => {
Ok(__FieldTag::__proto_reference_documentation_uri)
}
"proto_reference_documentation_uri" => {
Ok(__FieldTag::__proto_reference_documentation_uri)
}
"restReferenceDocumentationUri" => {
Ok(__FieldTag::__rest_reference_documentation_uri)
}
"rest_reference_documentation_uri" => {
Ok(__FieldTag::__rest_reference_documentation_uri)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Publishing;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Publishing")
}
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::__method_settings => {
if !fields.insert(__FieldTag::__method_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for method_settings",
));
}
result.method_settings =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::MethodSettings>,
>>()?
.unwrap_or_default();
}
__FieldTag::__new_issue_uri => {
if !fields.insert(__FieldTag::__new_issue_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for new_issue_uri",
));
}
result.new_issue_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__documentation_uri => {
if !fields.insert(__FieldTag::__documentation_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documentation_uri",
));
}
result.documentation_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__api_short_name => {
if !fields.insert(__FieldTag::__api_short_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for api_short_name",
));
}
result.api_short_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__github_label => {
if !fields.insert(__FieldTag::__github_label) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for github_label",
));
}
result.github_label = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__codeowner_github_teams => {
if !fields.insert(__FieldTag::__codeowner_github_teams) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for codeowner_github_teams",
));
}
result.codeowner_github_teams = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__doc_tag_prefix => {
if !fields.insert(__FieldTag::__doc_tag_prefix) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for doc_tag_prefix",
));
}
result.doc_tag_prefix = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__organization => {
if !fields.insert(__FieldTag::__organization) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for organization",
));
}
result.organization = map.next_value::<std::option::Option<crate::model::ClientLibraryOrganization>>()?.unwrap_or_default();
}
__FieldTag::__library_settings => {
if !fields.insert(__FieldTag::__library_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for library_settings",
));
}
result.library_settings = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::ClientLibrarySettings>,
>>()?
.unwrap_or_default();
}
__FieldTag::__proto_reference_documentation_uri => {
if !fields.insert(__FieldTag::__proto_reference_documentation_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for proto_reference_documentation_uri",
));
}
result.proto_reference_documentation_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__rest_reference_documentation_uri => {
if !fields.insert(__FieldTag::__rest_reference_documentation_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rest_reference_documentation_uri",
));
}
result.rest_reference_documentation_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::JavaSettings {
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 {
__library_package,
__service_class_names,
__common,
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 JavaSettings")
}
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 {
"libraryPackage" => Ok(__FieldTag::__library_package),
"library_package" => Ok(__FieldTag::__library_package),
"serviceClassNames" => Ok(__FieldTag::__service_class_names),
"service_class_names" => Ok(__FieldTag::__service_class_names),
"common" => Ok(__FieldTag::__common),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JavaSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JavaSettings")
}
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::__library_package => {
if !fields.insert(__FieldTag::__library_package) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for library_package",
));
}
result.library_package = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__service_class_names => {
if !fields.insert(__FieldTag::__service_class_names) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_class_names",
));
}
result.service_class_names = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__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::CppSettings {
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 {
__common,
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 CppSettings")
}
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 {
"common" => Ok(__FieldTag::__common),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CppSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CppSettings")
}
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::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__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::PhpSettings {
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 {
__common,
__library_package,
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 PhpSettings")
}
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 {
"common" => Ok(__FieldTag::__common),
"libraryPackage" => Ok(__FieldTag::__library_package),
"library_package" => Ok(__FieldTag::__library_package),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PhpSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PhpSettings")
}
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::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__FieldTag::__library_package => {
if !fields.insert(__FieldTag::__library_package) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for library_package",
));
}
result.library_package = 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::PythonSettings {
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 {
__common,
__experimental_features,
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 PythonSettings")
}
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 {
"common" => Ok(__FieldTag::__common),
"experimentalFeatures" => Ok(__FieldTag::__experimental_features),
"experimental_features" => Ok(__FieldTag::__experimental_features),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PythonSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PythonSettings")
}
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::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__FieldTag::__experimental_features => {
if !fields.insert(__FieldTag::__experimental_features) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for experimental_features",
));
}
result.experimental_features = map.next_value::<std::option::Option<
crate::model::python_settings::ExperimentalFeatures,
>>()?;
}
__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::python_settings::ExperimentalFeatures {
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 {
__rest_async_io_enabled,
__protobuf_pythonic_types_enabled,
__unversioned_package_disabled,
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 ExperimentalFeatures")
}
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 {
"restAsyncIoEnabled" => Ok(__FieldTag::__rest_async_io_enabled),
"rest_async_io_enabled" => Ok(__FieldTag::__rest_async_io_enabled),
"protobufPythonicTypesEnabled" => {
Ok(__FieldTag::__protobuf_pythonic_types_enabled)
}
"protobuf_pythonic_types_enabled" => {
Ok(__FieldTag::__protobuf_pythonic_types_enabled)
}
"unversionedPackageDisabled" => {
Ok(__FieldTag::__unversioned_package_disabled)
}
"unversioned_package_disabled" => {
Ok(__FieldTag::__unversioned_package_disabled)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::python_settings::ExperimentalFeatures;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ExperimentalFeatures")
}
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::__rest_async_io_enabled => {
if !fields.insert(__FieldTag::__rest_async_io_enabled) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rest_async_io_enabled",
));
}
result.rest_async_io_enabled = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__protobuf_pythonic_types_enabled => {
if !fields.insert(__FieldTag::__protobuf_pythonic_types_enabled) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for protobuf_pythonic_types_enabled",
));
}
result.protobuf_pythonic_types_enabled = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__unversioned_package_disabled => {
if !fields.insert(__FieldTag::__unversioned_package_disabled) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unversioned_package_disabled",
));
}
result.unversioned_package_disabled = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::NodeSettings {
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 {
__common,
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 NodeSettings")
}
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 {
"common" => Ok(__FieldTag::__common),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NodeSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NodeSettings")
}
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::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__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::DotnetSettings {
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 {
__common,
__renamed_services,
__renamed_resources,
__ignored_resources,
__forced_namespace_aliases,
__handwritten_signatures,
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 DotnetSettings")
}
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 {
"common" => Ok(__FieldTag::__common),
"renamedServices" => Ok(__FieldTag::__renamed_services),
"renamed_services" => Ok(__FieldTag::__renamed_services),
"renamedResources" => Ok(__FieldTag::__renamed_resources),
"renamed_resources" => Ok(__FieldTag::__renamed_resources),
"ignoredResources" => Ok(__FieldTag::__ignored_resources),
"ignored_resources" => Ok(__FieldTag::__ignored_resources),
"forcedNamespaceAliases" => Ok(__FieldTag::__forced_namespace_aliases),
"forced_namespace_aliases" => {
Ok(__FieldTag::__forced_namespace_aliases)
}
"handwrittenSignatures" => Ok(__FieldTag::__handwritten_signatures),
"handwritten_signatures" => Ok(__FieldTag::__handwritten_signatures),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DotnetSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DotnetSettings")
}
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::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__FieldTag::__renamed_services => {
if !fields.insert(__FieldTag::__renamed_services) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for renamed_services",
));
}
result.renamed_services = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__renamed_resources => {
if !fields.insert(__FieldTag::__renamed_resources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for renamed_resources",
));
}
result.renamed_resources = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__ignored_resources => {
if !fields.insert(__FieldTag::__ignored_resources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignored_resources",
));
}
result.ignored_resources = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__forced_namespace_aliases => {
if !fields.insert(__FieldTag::__forced_namespace_aliases) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for forced_namespace_aliases",
));
}
result.forced_namespace_aliases = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__handwritten_signatures => {
if !fields.insert(__FieldTag::__handwritten_signatures) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for handwritten_signatures",
));
}
result.handwritten_signatures = map.next_value::<std::option::Option<std::vec::Vec<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::RubySettings {
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 {
__common,
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 RubySettings")
}
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 {
"common" => Ok(__FieldTag::__common),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RubySettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RubySettings")
}
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::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__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::GoSettings {
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 {
__common,
__renamed_services,
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 GoSettings")
}
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 {
"common" => Ok(__FieldTag::__common),
"renamedServices" => Ok(__FieldTag::__renamed_services),
"renamed_services" => Ok(__FieldTag::__renamed_services),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GoSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GoSettings")
}
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::__common => {
if !fields.insert(__FieldTag::__common) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common",
));
}
result.common = map.next_value::<std::option::Option<crate::model::CommonLanguageSettings>>()?
;
}
__FieldTag::__renamed_services => {
if !fields.insert(__FieldTag::__renamed_services) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for renamed_services",
));
}
result.renamed_services = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
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::MethodSettings {
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 {
__selector,
__long_running,
__auto_populated_fields,
__batching,
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 MethodSettings")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"longRunning" => Ok(__FieldTag::__long_running),
"long_running" => Ok(__FieldTag::__long_running),
"autoPopulatedFields" => Ok(__FieldTag::__auto_populated_fields),
"auto_populated_fields" => Ok(__FieldTag::__auto_populated_fields),
"batching" => Ok(__FieldTag::__batching),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MethodSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MethodSettings")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__long_running => {
if !fields.insert(__FieldTag::__long_running) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for long_running",
));
}
result.long_running = map.next_value::<std::option::Option<crate::model::method_settings::LongRunning>>()?
;
}
__FieldTag::__auto_populated_fields => {
if !fields.insert(__FieldTag::__auto_populated_fields) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for auto_populated_fields",
));
}
result.auto_populated_fields = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__batching => {
if !fields.insert(__FieldTag::__batching) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batching",
));
}
result.batching = map.next_value::<std::option::Option<crate::model::BatchingConfigProto>>()?
;
}
__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::method_settings::LongRunning {
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 {
__initial_poll_delay,
__poll_delay_multiplier,
__max_poll_delay,
__total_poll_timeout,
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 LongRunning")
}
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 {
"initialPollDelay" => Ok(__FieldTag::__initial_poll_delay),
"initial_poll_delay" => Ok(__FieldTag::__initial_poll_delay),
"pollDelayMultiplier" => Ok(__FieldTag::__poll_delay_multiplier),
"poll_delay_multiplier" => Ok(__FieldTag::__poll_delay_multiplier),
"maxPollDelay" => Ok(__FieldTag::__max_poll_delay),
"max_poll_delay" => Ok(__FieldTag::__max_poll_delay),
"totalPollTimeout" => Ok(__FieldTag::__total_poll_timeout),
"total_poll_timeout" => Ok(__FieldTag::__total_poll_timeout),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::method_settings::LongRunning;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LongRunning")
}
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::__initial_poll_delay => {
if !fields.insert(__FieldTag::__initial_poll_delay) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for initial_poll_delay",
));
}
result.initial_poll_delay =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__poll_delay_multiplier => {
if !fields.insert(__FieldTag::__poll_delay_multiplier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for poll_delay_multiplier",
));
}
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.poll_delay_multiplier =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__max_poll_delay => {
if !fields.insert(__FieldTag::__max_poll_delay) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_poll_delay",
));
}
result.max_poll_delay =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__total_poll_timeout => {
if !fields.insert(__FieldTag::__total_poll_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_poll_timeout",
));
}
result.total_poll_timeout =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__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::SelectiveGapicGeneration {
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 {
__methods,
__generate_omitted_as_internal,
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 SelectiveGapicGeneration")
}
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 {
"methods" => Ok(__FieldTag::__methods),
"generateOmittedAsInternal" => {
Ok(__FieldTag::__generate_omitted_as_internal)
}
"generate_omitted_as_internal" => {
Ok(__FieldTag::__generate_omitted_as_internal)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SelectiveGapicGeneration;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SelectiveGapicGeneration")
}
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::__methods => {
if !fields.insert(__FieldTag::__methods) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for methods",
));
}
result.methods = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__generate_omitted_as_internal => {
if !fields.insert(__FieldTag::__generate_omitted_as_internal) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for generate_omitted_as_internal",
));
}
result.generate_omitted_as_internal = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchingConfigProto {
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 {
__thresholds,
__batch_descriptor,
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 BatchingConfigProto")
}
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 {
"thresholds" => Ok(__FieldTag::__thresholds),
"batchDescriptor" => Ok(__FieldTag::__batch_descriptor),
"batch_descriptor" => Ok(__FieldTag::__batch_descriptor),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchingConfigProto;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchingConfigProto")
}
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::__thresholds => {
if !fields.insert(__FieldTag::__thresholds) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thresholds",
));
}
result.thresholds = map.next_value::<std::option::Option<crate::model::BatchingSettingsProto>>()?
;
}
__FieldTag::__batch_descriptor => {
if !fields.insert(__FieldTag::__batch_descriptor) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batch_descriptor",
));
}
result.batch_descriptor = map.next_value::<std::option::Option<crate::model::BatchingDescriptorProto>>()?
;
}
__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::BatchingSettingsProto {
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 {
__element_count_threshold,
__request_byte_threshold,
__delay_threshold,
__element_count_limit,
__request_byte_limit,
__flow_control_element_limit,
__flow_control_byte_limit,
__flow_control_limit_exceeded_behavior,
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 BatchingSettingsProto")
}
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 {
"elementCountThreshold" => Ok(__FieldTag::__element_count_threshold),
"element_count_threshold" => Ok(__FieldTag::__element_count_threshold),
"requestByteThreshold" => Ok(__FieldTag::__request_byte_threshold),
"request_byte_threshold" => Ok(__FieldTag::__request_byte_threshold),
"delayThreshold" => Ok(__FieldTag::__delay_threshold),
"delay_threshold" => Ok(__FieldTag::__delay_threshold),
"elementCountLimit" => Ok(__FieldTag::__element_count_limit),
"element_count_limit" => Ok(__FieldTag::__element_count_limit),
"requestByteLimit" => Ok(__FieldTag::__request_byte_limit),
"request_byte_limit" => Ok(__FieldTag::__request_byte_limit),
"flowControlElementLimit" => {
Ok(__FieldTag::__flow_control_element_limit)
}
"flow_control_element_limit" => {
Ok(__FieldTag::__flow_control_element_limit)
}
"flowControlByteLimit" => Ok(__FieldTag::__flow_control_byte_limit),
"flow_control_byte_limit" => Ok(__FieldTag::__flow_control_byte_limit),
"flowControlLimitExceededBehavior" => {
Ok(__FieldTag::__flow_control_limit_exceeded_behavior)
}
"flow_control_limit_exceeded_behavior" => {
Ok(__FieldTag::__flow_control_limit_exceeded_behavior)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchingSettingsProto;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchingSettingsProto")
}
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::__element_count_threshold => {
if !fields.insert(__FieldTag::__element_count_threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for element_count_threshold",
));
}
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.element_count_threshold =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__request_byte_threshold => {
if !fields.insert(__FieldTag::__request_byte_threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_byte_threshold",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.request_byte_threshold =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__delay_threshold => {
if !fields.insert(__FieldTag::__delay_threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for delay_threshold",
));
}
result.delay_threshold =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__element_count_limit => {
if !fields.insert(__FieldTag::__element_count_limit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for element_count_limit",
));
}
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.element_count_limit =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__request_byte_limit => {
if !fields.insert(__FieldTag::__request_byte_limit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_byte_limit",
));
}
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.request_byte_limit =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__flow_control_element_limit => {
if !fields.insert(__FieldTag::__flow_control_element_limit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for flow_control_element_limit",
));
}
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.flow_control_element_limit =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__flow_control_byte_limit => {
if !fields.insert(__FieldTag::__flow_control_byte_limit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for flow_control_byte_limit",
));
}
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.flow_control_byte_limit =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__flow_control_limit_exceeded_behavior => {
if !fields.insert(__FieldTag::__flow_control_limit_exceeded_behavior) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for flow_control_limit_exceeded_behavior",
));
}
result.flow_control_limit_exceeded_behavior = map
.next_value::<std::option::Option<
crate::model::FlowControlLimitExceededBehaviorProto,
>>()?
.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::BatchingDescriptorProto {
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 {
__batched_field,
__discriminator_fields,
__subresponse_field,
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 BatchingDescriptorProto")
}
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 {
"batchedField" => Ok(__FieldTag::__batched_field),
"batched_field" => Ok(__FieldTag::__batched_field),
"discriminatorFields" => Ok(__FieldTag::__discriminator_fields),
"discriminator_fields" => Ok(__FieldTag::__discriminator_fields),
"subresponseField" => Ok(__FieldTag::__subresponse_field),
"subresponse_field" => Ok(__FieldTag::__subresponse_field),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchingDescriptorProto;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchingDescriptorProto")
}
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::__batched_field => {
if !fields.insert(__FieldTag::__batched_field) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batched_field",
));
}
result.batched_field = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__discriminator_fields => {
if !fields.insert(__FieldTag::__discriminator_fields) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for discriminator_fields",
));
}
result.discriminator_fields = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__subresponse_field => {
if !fields.insert(__FieldTag::__subresponse_field) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subresponse_field",
));
}
result.subresponse_field = 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::ConfigChange {
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 {
__element,
__old_value,
__new_value,
__change_type,
__advices,
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 ConfigChange")
}
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 {
"element" => Ok(__FieldTag::__element),
"oldValue" => Ok(__FieldTag::__old_value),
"old_value" => Ok(__FieldTag::__old_value),
"newValue" => Ok(__FieldTag::__new_value),
"new_value" => Ok(__FieldTag::__new_value),
"changeType" => Ok(__FieldTag::__change_type),
"change_type" => Ok(__FieldTag::__change_type),
"advices" => Ok(__FieldTag::__advices),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ConfigChange;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ConfigChange")
}
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::__element => {
if !fields.insert(__FieldTag::__element) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for element",
));
}
result.element = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__old_value => {
if !fields.insert(__FieldTag::__old_value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for old_value",
));
}
result.old_value = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__new_value => {
if !fields.insert(__FieldTag::__new_value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for new_value",
));
}
result.new_value = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__change_type => {
if !fields.insert(__FieldTag::__change_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for change_type",
));
}
result.change_type = map
.next_value::<std::option::Option<crate::model::ChangeType>>()?
.unwrap_or_default();
}
__FieldTag::__advices => {
if !fields.insert(__FieldTag::__advices) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for advices",
));
}
result.advices = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Advice>>>()?.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::Advice {
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 {
__description,
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 Advice")
}
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 {
"description" => Ok(__FieldTag::__description),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Advice;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Advice")
}
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::__description => {
if !fields.insert(__FieldTag::__description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for description",
));
}
result.description = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::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::ProjectProperties {
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 {
__properties,
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 ProjectProperties")
}
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 {
"properties" => Ok(__FieldTag::__properties),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ProjectProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ProjectProperties")
}
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::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Property>>>()?.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::Property {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__type,
__description,
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 Property")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"type" => Ok(__FieldTag::__type),
"description" => Ok(__FieldTag::__description),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Property;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Property")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__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::property::PropertyType>>()?.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<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::Context {
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 {
__rules,
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 Context")
}
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 {
"rules" => Ok(__FieldTag::__rules),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Context;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Context")
}
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::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules = map.next_value::<std::option::Option<std::vec::Vec<crate::model::ContextRule>>>()?.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::ContextRule {
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 {
__selector,
__requested,
__provided,
__allowed_request_extensions,
__allowed_response_extensions,
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 ContextRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"requested" => Ok(__FieldTag::__requested),
"provided" => Ok(__FieldTag::__provided),
"allowedRequestExtensions" => {
Ok(__FieldTag::__allowed_request_extensions)
}
"allowed_request_extensions" => {
Ok(__FieldTag::__allowed_request_extensions)
}
"allowedResponseExtensions" => {
Ok(__FieldTag::__allowed_response_extensions)
}
"allowed_response_extensions" => {
Ok(__FieldTag::__allowed_response_extensions)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ContextRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ContextRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__requested => {
if !fields.insert(__FieldTag::__requested) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for requested",
));
}
result.requested = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__provided => {
if !fields.insert(__FieldTag::__provided) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provided",
));
}
result.provided = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__allowed_request_extensions => {
if !fields.insert(__FieldTag::__allowed_request_extensions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allowed_request_extensions",
));
}
result.allowed_request_extensions = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__allowed_response_extensions => {
if !fields.insert(__FieldTag::__allowed_response_extensions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allowed_response_extensions",
));
}
result.allowed_response_extensions = map.next_value::<std::option::Option<std::vec::Vec<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::Control {
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 {
__environment,
__method_policies,
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 Control")
}
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 {
"environment" => Ok(__FieldTag::__environment),
"methodPolicies" => Ok(__FieldTag::__method_policies),
"method_policies" => Ok(__FieldTag::__method_policies),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Control;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Control")
}
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::__environment => {
if !fields.insert(__FieldTag::__environment) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for environment",
));
}
result.environment = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__method_policies => {
if !fields.insert(__FieldTag::__method_policies) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for method_policies",
));
}
result.method_policies = map.next_value::<std::option::Option<std::vec::Vec<crate::model::MethodPolicy>>>()?.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::Distribution {
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 {
__count,
__mean,
__sum_of_squared_deviation,
__range,
__bucket_options,
__bucket_counts,
__exemplars,
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 Distribution")
}
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 {
"count" => Ok(__FieldTag::__count),
"mean" => Ok(__FieldTag::__mean),
"sumOfSquaredDeviation" => Ok(__FieldTag::__sum_of_squared_deviation),
"sum_of_squared_deviation" => {
Ok(__FieldTag::__sum_of_squared_deviation)
}
"range" => Ok(__FieldTag::__range),
"bucketOptions" => Ok(__FieldTag::__bucket_options),
"bucket_options" => Ok(__FieldTag::__bucket_options),
"bucketCounts" => Ok(__FieldTag::__bucket_counts),
"bucket_counts" => Ok(__FieldTag::__bucket_counts),
"exemplars" => Ok(__FieldTag::__exemplars),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Distribution;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Distribution")
}
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::__count => {
if !fields.insert(__FieldTag::__count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__mean => {
if !fields.insert(__FieldTag::__mean) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mean",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.mean = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__sum_of_squared_deviation => {
if !fields.insert(__FieldTag::__sum_of_squared_deviation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sum_of_squared_deviation",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.sum_of_squared_deviation =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__range => {
if !fields.insert(__FieldTag::__range) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for range",
));
}
result.range = map.next_value::<std::option::Option<crate::model::distribution::Range>>()?
;
}
__FieldTag::__bucket_options => {
if !fields.insert(__FieldTag::__bucket_options) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bucket_options",
));
}
result.bucket_options = map.next_value::<std::option::Option<crate::model::distribution::BucketOptions>>()?
;
}
__FieldTag::__bucket_counts => {
if !fields.insert(__FieldTag::__bucket_counts) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bucket_counts",
));
}
struct __With(std::option::Option<std::vec::Vec<i64>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::I64>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.bucket_counts =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__exemplars => {
if !fields.insert(__FieldTag::__exemplars) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exemplars",
));
}
result.exemplars = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::distribution::Exemplar>,
>>()?
.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::distribution::Range {
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 {
__min,
__max,
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 Range")
}
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 {
"min" => Ok(__FieldTag::__min),
"max" => Ok(__FieldTag::__max),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::distribution::Range;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Range")
}
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::__min => {
if !fields.insert(__FieldTag::__min) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.min = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__max => {
if !fields.insert(__FieldTag::__max) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.max = 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::distribution::BucketOptions {
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 {
__linear_buckets,
__exponential_buckets,
__explicit_buckets,
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 BucketOptions")
}
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 {
"linearBuckets" => Ok(__FieldTag::__linear_buckets),
"linear_buckets" => Ok(__FieldTag::__linear_buckets),
"exponentialBuckets" => Ok(__FieldTag::__exponential_buckets),
"exponential_buckets" => Ok(__FieldTag::__exponential_buckets),
"explicitBuckets" => Ok(__FieldTag::__explicit_buckets),
"explicit_buckets" => Ok(__FieldTag::__explicit_buckets),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::distribution::BucketOptions;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BucketOptions")
}
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::__linear_buckets => {
if !fields.insert(__FieldTag::__linear_buckets) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for linear_buckets",
));
}
if result.options.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `options`, a oneof with full ID .google.api.Distribution.BucketOptions.linear_buckets, latest field was linearBuckets",
));
}
result.options = std::option::Option::Some(
crate::model::distribution::bucket_options::Options::LinearBuckets(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::distribution::bucket_options::Linear,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__exponential_buckets => {
if !fields.insert(__FieldTag::__exponential_buckets) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exponential_buckets",
));
}
if result.options.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `options`, a oneof with full ID .google.api.Distribution.BucketOptions.exponential_buckets, latest field was exponentialBuckets",
));
}
result.options = std::option::Option::Some(
crate::model::distribution::bucket_options::Options::ExponentialBuckets(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::distribution::bucket_options::Exponential>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__explicit_buckets => {
if !fields.insert(__FieldTag::__explicit_buckets) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for explicit_buckets",
));
}
if result.options.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `options`, a oneof with full ID .google.api.Distribution.BucketOptions.explicit_buckets, latest field was explicitBuckets",
));
}
result.options = std::option::Option::Some(
crate::model::distribution::bucket_options::Options::ExplicitBuckets(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::distribution::bucket_options::Explicit>>>()?.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::distribution::bucket_options::Linear {
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 {
__num_finite_buckets,
__width,
__offset,
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 Linear")
}
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 {
"numFiniteBuckets" => Ok(__FieldTag::__num_finite_buckets),
"num_finite_buckets" => Ok(__FieldTag::__num_finite_buckets),
"width" => Ok(__FieldTag::__width),
"offset" => Ok(__FieldTag::__offset),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::distribution::bucket_options::Linear;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Linear")
}
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::__num_finite_buckets => {
if !fields.insert(__FieldTag::__num_finite_buckets) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_finite_buckets",
));
}
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.num_finite_buckets =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__width => {
if !fields.insert(__FieldTag::__width) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for width",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.width = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__offset => {
if !fields.insert(__FieldTag::__offset) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for offset",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.offset = 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::distribution::bucket_options::Exponential {
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 {
__num_finite_buckets,
__growth_factor,
__scale,
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 Exponential")
}
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 {
"numFiniteBuckets" => Ok(__FieldTag::__num_finite_buckets),
"num_finite_buckets" => Ok(__FieldTag::__num_finite_buckets),
"growthFactor" => Ok(__FieldTag::__growth_factor),
"growth_factor" => Ok(__FieldTag::__growth_factor),
"scale" => Ok(__FieldTag::__scale),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::distribution::bucket_options::Exponential;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Exponential")
}
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::__num_finite_buckets => {
if !fields.insert(__FieldTag::__num_finite_buckets) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_finite_buckets",
));
}
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.num_finite_buckets =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__growth_factor => {
if !fields.insert(__FieldTag::__growth_factor) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for growth_factor",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.growth_factor =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__scale => {
if !fields.insert(__FieldTag::__scale) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scale",
));
}
struct __With(std::option::Option<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.scale = 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::distribution::bucket_options::Explicit {
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 {
__bounds,
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 Explicit")
}
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 {
"bounds" => Ok(__FieldTag::__bounds),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::distribution::bucket_options::Explicit;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Explicit")
}
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::__bounds => {
if !fields.insert(__FieldTag::__bounds) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bounds",
));
}
struct __With(std::option::Option<std::vec::Vec<f64>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::F64>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.bounds = 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::distribution::Exemplar {
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,
__timestamp,
__attachments,
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 Exemplar")
}
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),
"timestamp" => Ok(__FieldTag::__timestamp),
"attachments" => Ok(__FieldTag::__attachments),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::distribution::Exemplar;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Exemplar")
}
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<f64>);
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::F64> >::deserialize(deserializer).map(__With)
}
}
result.value = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__timestamp => {
if !fields.insert(__FieldTag::__timestamp) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for timestamp",
));
}
result.timestamp =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__attachments => {
if !fields.insert(__FieldTag::__attachments) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attachments",
));
}
result.attachments = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Any>>>()?
.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::Documentation {
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 {
__summary,
__pages,
__rules,
__documentation_root_url,
__service_root_url,
__overview,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Documentation")
}
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 {
"summary" => Ok(__FieldTag::__summary),
"pages" => Ok(__FieldTag::__pages),
"rules" => Ok(__FieldTag::__rules),
"documentationRootUrl" => Ok(__FieldTag::__documentation_root_url),
"documentation_root_url" => Ok(__FieldTag::__documentation_root_url),
"serviceRootUrl" => Ok(__FieldTag::__service_root_url),
"service_root_url" => Ok(__FieldTag::__service_root_url),
"overview" => Ok(__FieldTag::__overview),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Documentation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Documentation")
}
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::__summary => {
if !fields.insert(__FieldTag::__summary) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary",
));
}
result.summary = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__pages => {
if !fields.insert(__FieldTag::__pages) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pages",
));
}
result.pages = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Page>>>()?.unwrap_or_default();
}
__FieldTag::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::DocumentationRule>,
>>()?
.unwrap_or_default();
}
__FieldTag::__documentation_root_url => {
if !fields.insert(__FieldTag::__documentation_root_url) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documentation_root_url",
));
}
result.documentation_root_url = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__service_root_url => {
if !fields.insert(__FieldTag::__service_root_url) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_root_url",
));
}
result.service_root_url = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__overview => {
if !fields.insert(__FieldTag::__overview) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for overview",
));
}
result.overview = 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::DocumentationRule {
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 {
__selector,
__description,
__deprecation_description,
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 DocumentationRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"description" => Ok(__FieldTag::__description),
"deprecationDescription" => Ok(__FieldTag::__deprecation_description),
"deprecation_description" => Ok(__FieldTag::__deprecation_description),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DocumentationRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentationRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = 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<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__deprecation_description => {
if !fields.insert(__FieldTag::__deprecation_description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for deprecation_description",
));
}
result.deprecation_description = 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::Page {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__content,
__subpages,
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 Page")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"content" => Ok(__FieldTag::__content),
"subpages" => Ok(__FieldTag::__subpages),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Page;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Page")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__subpages => {
if !fields.insert(__FieldTag::__subpages) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subpages",
));
}
result.subpages = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Page>>>()?.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::Endpoint {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__aliases,
__target,
__allow_cors,
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 Endpoint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"aliases" => Ok(__FieldTag::__aliases),
"target" => Ok(__FieldTag::__target),
"allowCors" => Ok(__FieldTag::__allow_cors),
"allow_cors" => Ok(__FieldTag::__allow_cors),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Endpoint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Endpoint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__aliases => {
if !fields.insert(__FieldTag::__aliases) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for aliases",
));
}
result.aliases = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__target => {
if !fields.insert(__FieldTag::__target) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target",
));
}
result.target = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__allow_cors => {
if !fields.insert(__FieldTag::__allow_cors) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_cors",
));
}
result.allow_cors = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FieldInfo {
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 {
__format,
__referenced_types,
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 FieldInfo")
}
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 {
"format" => Ok(__FieldTag::__format),
"referencedTypes" => Ok(__FieldTag::__referenced_types),
"referenced_types" => Ok(__FieldTag::__referenced_types),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FieldInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FieldInfo")
}
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::__format => {
if !fields.insert(__FieldTag::__format) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for format",
));
}
result.format = map.next_value::<std::option::Option<crate::model::field_info::Format>>()?.unwrap_or_default();
}
__FieldTag::__referenced_types => {
if !fields.insert(__FieldTag::__referenced_types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for referenced_types",
));
}
result.referenced_types = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TypeReference>>>()?.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::TypeReference {
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 {
__type_name,
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 TypeReference")
}
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 {
"typeName" => Ok(__FieldTag::__type_name),
"type_name" => Ok(__FieldTag::__type_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TypeReference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TypeReference")
}
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::__type_name => {
if !fields.insert(__FieldTag::__type_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type_name",
));
}
result.type_name = 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::Http {
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 {
__rules,
__fully_decode_reserved_expansion,
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 Http")
}
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 {
"rules" => Ok(__FieldTag::__rules),
"fullyDecodeReservedExpansion" => {
Ok(__FieldTag::__fully_decode_reserved_expansion)
}
"fully_decode_reserved_expansion" => {
Ok(__FieldTag::__fully_decode_reserved_expansion)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Http;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Http")
}
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::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules = map.next_value::<std::option::Option<std::vec::Vec<crate::model::HttpRule>>>()?.unwrap_or_default();
}
__FieldTag::__fully_decode_reserved_expansion => {
if !fields.insert(__FieldTag::__fully_decode_reserved_expansion) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fully_decode_reserved_expansion",
));
}
result.fully_decode_reserved_expansion = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::HttpRule {
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 {
__selector,
__get,
__put,
__post,
__delete,
__patch,
__custom,
__body,
__response_body,
__additional_bindings,
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 HttpRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"get" => Ok(__FieldTag::__get),
"put" => Ok(__FieldTag::__put),
"post" => Ok(__FieldTag::__post),
"delete" => Ok(__FieldTag::__delete),
"patch" => Ok(__FieldTag::__patch),
"custom" => Ok(__FieldTag::__custom),
"body" => Ok(__FieldTag::__body),
"responseBody" => Ok(__FieldTag::__response_body),
"response_body" => Ok(__FieldTag::__response_body),
"additionalBindings" => Ok(__FieldTag::__additional_bindings),
"additional_bindings" => Ok(__FieldTag::__additional_bindings),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::HttpRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct HttpRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__get => {
if !fields.insert(__FieldTag::__get) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for get",
));
}
if result.pattern.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `pattern`, a oneof with full ID .google.api.HttpRule.get, latest field was get",
));
}
result.pattern =
std::option::Option::Some(crate::model::http_rule::Pattern::Get(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__put => {
if !fields.insert(__FieldTag::__put) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for put",
));
}
if result.pattern.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `pattern`, a oneof with full ID .google.api.HttpRule.put, latest field was put",
));
}
result.pattern =
std::option::Option::Some(crate::model::http_rule::Pattern::Put(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__post => {
if !fields.insert(__FieldTag::__post) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for post",
));
}
if result.pattern.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `pattern`, a oneof with full ID .google.api.HttpRule.post, latest field was post",
));
}
result.pattern =
std::option::Option::Some(crate::model::http_rule::Pattern::Post(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__delete => {
if !fields.insert(__FieldTag::__delete) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for delete",
));
}
if result.pattern.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `pattern`, a oneof with full ID .google.api.HttpRule.delete, latest field was delete",
));
}
result.pattern = std::option::Option::Some(
crate::model::http_rule::Pattern::Delete(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__patch => {
if !fields.insert(__FieldTag::__patch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for patch",
));
}
if result.pattern.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `pattern`, a oneof with full ID .google.api.HttpRule.patch, latest field was patch",
));
}
result.pattern =
std::option::Option::Some(crate::model::http_rule::Pattern::Patch(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__custom => {
if !fields.insert(__FieldTag::__custom) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for custom",
));
}
if result.pattern.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `pattern`, a oneof with full ID .google.api.HttpRule.custom, latest field was custom",
));
}
result.pattern = std::option::Option::Some(
crate::model::http_rule::Pattern::Custom(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::CustomHttpPattern>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__body => {
if !fields.insert(__FieldTag::__body) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for body",
));
}
result.body = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__response_body => {
if !fields.insert(__FieldTag::__response_body) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for response_body",
));
}
result.response_body = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__additional_bindings => {
if !fields.insert(__FieldTag::__additional_bindings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for additional_bindings",
));
}
result.additional_bindings = map.next_value::<std::option::Option<std::vec::Vec<crate::model::HttpRule>>>()?.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::CustomHttpPattern {
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 {
__kind,
__path,
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 CustomHttpPattern")
}
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 {
"kind" => Ok(__FieldTag::__kind),
"path" => Ok(__FieldTag::__path),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CustomHttpPattern;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CustomHttpPattern")
}
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::__kind => {
if !fields.insert(__FieldTag::__kind) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kind",
));
}
result.kind = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__path => {
if !fields.insert(__FieldTag::__path) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for path",
));
}
result.path = 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::HttpBody {
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 {
__content_type,
__data,
__extensions,
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 HttpBody")
}
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 {
"contentType" => Ok(__FieldTag::__content_type),
"content_type" => Ok(__FieldTag::__content_type),
"data" => Ok(__FieldTag::__data),
"extensions" => Ok(__FieldTag::__extensions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::HttpBody;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct HttpBody")
}
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::__content_type => {
if !fields.insert(__FieldTag::__content_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content_type",
));
}
result.content_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__data => {
if !fields.insert(__FieldTag::__data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data",
));
}
struct __With(std::option::Option<::bytes::Bytes>);
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<serde_with::base64::Base64> >::deserialize(deserializer).map(__With)
}
}
result.data = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__extensions => {
if !fields.insert(__FieldTag::__extensions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for extensions",
));
}
result.extensions = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Any>>>()?
.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::LabelDescriptor {
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 {
__key,
__value_type,
__description,
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 LabelDescriptor")
}
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 {
"key" => Ok(__FieldTag::__key),
"valueType" => Ok(__FieldTag::__value_type),
"value_type" => Ok(__FieldTag::__value_type),
"description" => Ok(__FieldTag::__description),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LabelDescriptor;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LabelDescriptor")
}
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::__key => {
if !fields.insert(__FieldTag::__key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key",
));
}
result.key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__value_type => {
if !fields.insert(__FieldTag::__value_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value_type",
));
}
result.value_type = map.next_value::<std::option::Option<crate::model::label_descriptor::ValueType>>()?.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<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::LogDescriptor {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__labels,
__description,
__display_name,
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 LogDescriptor")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"labels" => Ok(__FieldTag::__labels),
"description" => Ok(__FieldTag::__description),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LogDescriptor;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LogDescriptor")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__labels => {
if !fields.insert(__FieldTag::__labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for labels",
));
}
result.labels =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::LabelDescriptor>,
>>()?
.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<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = 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::Logging {
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 {
__producer_destinations,
__consumer_destinations,
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 Logging")
}
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 {
"producerDestinations" => Ok(__FieldTag::__producer_destinations),
"producer_destinations" => Ok(__FieldTag::__producer_destinations),
"consumerDestinations" => Ok(__FieldTag::__consumer_destinations),
"consumer_destinations" => Ok(__FieldTag::__consumer_destinations),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Logging;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Logging")
}
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::__producer_destinations => {
if !fields.insert(__FieldTag::__producer_destinations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for producer_destinations",
));
}
result.producer_destinations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::logging::LoggingDestination>,
>>()?
.unwrap_or_default();
}
__FieldTag::__consumer_destinations => {
if !fields.insert(__FieldTag::__consumer_destinations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for consumer_destinations",
));
}
result.consumer_destinations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::logging::LoggingDestination>,
>>()?
.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::logging::LoggingDestination {
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 {
__monitored_resource,
__logs,
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 LoggingDestination")
}
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 {
"monitoredResource" => Ok(__FieldTag::__monitored_resource),
"monitored_resource" => Ok(__FieldTag::__monitored_resource),
"logs" => Ok(__FieldTag::__logs),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::logging::LoggingDestination;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LoggingDestination")
}
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::__monitored_resource => {
if !fields.insert(__FieldTag::__monitored_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for monitored_resource",
));
}
result.monitored_resource = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__logs => {
if !fields.insert(__FieldTag::__logs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logs",
));
}
result.logs = map.next_value::<std::option::Option<std::vec::Vec<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::MetricDescriptor {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__type,
__labels,
__metric_kind,
__value_type,
__unit,
__description,
__display_name,
__metadata,
__launch_stage,
__monitored_resource_types,
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 MetricDescriptor")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"type" => Ok(__FieldTag::__type),
"labels" => Ok(__FieldTag::__labels),
"metricKind" => Ok(__FieldTag::__metric_kind),
"metric_kind" => Ok(__FieldTag::__metric_kind),
"valueType" => Ok(__FieldTag::__value_type),
"value_type" => Ok(__FieldTag::__value_type),
"unit" => Ok(__FieldTag::__unit),
"description" => Ok(__FieldTag::__description),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"metadata" => Ok(__FieldTag::__metadata),
"launchStage" => Ok(__FieldTag::__launch_stage),
"launch_stage" => Ok(__FieldTag::__launch_stage),
"monitoredResourceTypes" => Ok(__FieldTag::__monitored_resource_types),
"monitored_resource_types" => {
Ok(__FieldTag::__monitored_resource_types)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MetricDescriptor;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MetricDescriptor")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__labels => {
if !fields.insert(__FieldTag::__labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for labels",
));
}
result.labels =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::LabelDescriptor>,
>>()?
.unwrap_or_default();
}
__FieldTag::__metric_kind => {
if !fields.insert(__FieldTag::__metric_kind) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metric_kind",
));
}
result.metric_kind =
map.next_value::<std::option::Option<
crate::model::metric_descriptor::MetricKind,
>>()?
.unwrap_or_default();
}
__FieldTag::__value_type => {
if !fields.insert(__FieldTag::__value_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value_type",
));
}
result.value_type = map.next_value::<std::option::Option<crate::model::metric_descriptor::ValueType>>()?.unwrap_or_default();
}
__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<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<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__metadata => {
if !fields.insert(__FieldTag::__metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metadata",
));
}
result.metadata = map.next_value::<std::option::Option<
crate::model::metric_descriptor::MetricDescriptorMetadata,
>>()?;
}
__FieldTag::__launch_stage => {
if !fields.insert(__FieldTag::__launch_stage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for launch_stage",
));
}
result.launch_stage = map
.next_value::<std::option::Option<crate::model::LaunchStage>>()?
.unwrap_or_default();
}
__FieldTag::__monitored_resource_types => {
if !fields.insert(__FieldTag::__monitored_resource_types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for monitored_resource_types",
));
}
result.monitored_resource_types = map.next_value::<std::option::Option<std::vec::Vec<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::metric_descriptor::MetricDescriptorMetadata {
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 {
__launch_stage,
__sample_period,
__ingest_delay,
__time_series_resource_hierarchy_level,
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 MetricDescriptorMetadata")
}
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 {
"launchStage" => Ok(__FieldTag::__launch_stage),
"launch_stage" => Ok(__FieldTag::__launch_stage),
"samplePeriod" => Ok(__FieldTag::__sample_period),
"sample_period" => Ok(__FieldTag::__sample_period),
"ingestDelay" => Ok(__FieldTag::__ingest_delay),
"ingest_delay" => Ok(__FieldTag::__ingest_delay),
"timeSeriesResourceHierarchyLevel" => {
Ok(__FieldTag::__time_series_resource_hierarchy_level)
}
"time_series_resource_hierarchy_level" => {
Ok(__FieldTag::__time_series_resource_hierarchy_level)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::metric_descriptor::MetricDescriptorMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MetricDescriptorMetadata")
}
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::__launch_stage => {
if !fields.insert(__FieldTag::__launch_stage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for launch_stage",
));
}
result.launch_stage = map
.next_value::<std::option::Option<crate::model::LaunchStage>>()?
.unwrap_or_default();
}
__FieldTag::__sample_period => {
if !fields.insert(__FieldTag::__sample_period) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sample_period",
));
}
result.sample_period =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__ingest_delay => {
if !fields.insert(__FieldTag::__ingest_delay) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ingest_delay",
));
}
result.ingest_delay =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__time_series_resource_hierarchy_level => {
if !fields.insert(__FieldTag::__time_series_resource_hierarchy_level) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_series_resource_hierarchy_level",
));
}
result.time_series_resource_hierarchy_level = map.next_value::<std::option::Option<std::vec::Vec<crate::model::metric_descriptor::metric_descriptor_metadata::TimeSeriesResourceHierarchyLevel>>>()?.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::Metric {
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 {
__type,
__labels,
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 Metric")
}
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 {
"type" => Ok(__FieldTag::__type),
"labels" => Ok(__FieldTag::__labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Metric;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Metric")
}
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::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__labels => {
if !fields.insert(__FieldTag::__labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for labels",
));
}
result.labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
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::MonitoredResourceDescriptor {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__type,
__display_name,
__description,
__labels,
__launch_stage,
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 MonitoredResourceDescriptor")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"type" => Ok(__FieldTag::__type),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"description" => Ok(__FieldTag::__description),
"labels" => Ok(__FieldTag::__labels),
"launchStage" => Ok(__FieldTag::__launch_stage),
"launch_stage" => Ok(__FieldTag::__launch_stage),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MonitoredResourceDescriptor;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MonitoredResourceDescriptor")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = 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<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__labels => {
if !fields.insert(__FieldTag::__labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for labels",
));
}
result.labels =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::LabelDescriptor>,
>>()?
.unwrap_or_default();
}
__FieldTag::__launch_stage => {
if !fields.insert(__FieldTag::__launch_stage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for launch_stage",
));
}
result.launch_stage = map
.next_value::<std::option::Option<crate::model::LaunchStage>>()?
.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::MonitoredResource {
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 {
__type,
__labels,
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 MonitoredResource")
}
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 {
"type" => Ok(__FieldTag::__type),
"labels" => Ok(__FieldTag::__labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MonitoredResource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MonitoredResource")
}
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::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__labels => {
if !fields.insert(__FieldTag::__labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for labels",
));
}
result.labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
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::MonitoredResourceMetadata {
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 {
__system_labels,
__user_labels,
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 MonitoredResourceMetadata")
}
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 {
"systemLabels" => Ok(__FieldTag::__system_labels),
"system_labels" => Ok(__FieldTag::__system_labels),
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MonitoredResourceMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MonitoredResourceMetadata")
}
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::__system_labels => {
if !fields.insert(__FieldTag::__system_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for system_labels",
));
}
result.system_labels =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
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::Monitoring {
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 {
__producer_destinations,
__consumer_destinations,
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 Monitoring")
}
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 {
"producerDestinations" => Ok(__FieldTag::__producer_destinations),
"producer_destinations" => Ok(__FieldTag::__producer_destinations),
"consumerDestinations" => Ok(__FieldTag::__consumer_destinations),
"consumer_destinations" => Ok(__FieldTag::__consumer_destinations),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Monitoring;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Monitoring")
}
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::__producer_destinations => {
if !fields.insert(__FieldTag::__producer_destinations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for producer_destinations",
));
}
result.producer_destinations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::monitoring::MonitoringDestination>,
>>()?
.unwrap_or_default();
}
__FieldTag::__consumer_destinations => {
if !fields.insert(__FieldTag::__consumer_destinations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for consumer_destinations",
));
}
result.consumer_destinations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::monitoring::MonitoringDestination>,
>>()?
.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::monitoring::MonitoringDestination {
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 {
__monitored_resource,
__metrics,
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 MonitoringDestination")
}
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 {
"monitoredResource" => Ok(__FieldTag::__monitored_resource),
"monitored_resource" => Ok(__FieldTag::__monitored_resource),
"metrics" => Ok(__FieldTag::__metrics),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::monitoring::MonitoringDestination;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MonitoringDestination")
}
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::__monitored_resource => {
if !fields.insert(__FieldTag::__monitored_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for monitored_resource",
));
}
result.monitored_resource = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__metrics => {
if !fields.insert(__FieldTag::__metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metrics",
));
}
result.metrics = map.next_value::<std::option::Option<std::vec::Vec<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::FieldPolicy {
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 {
__selector,
__resource_permission,
__resource_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 FieldPolicy")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"resourcePermission" => Ok(__FieldTag::__resource_permission),
"resource_permission" => Ok(__FieldTag::__resource_permission),
"resourceType" => Ok(__FieldTag::__resource_type),
"resource_type" => Ok(__FieldTag::__resource_type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FieldPolicy;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FieldPolicy")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__resource_permission => {
if !fields.insert(__FieldTag::__resource_permission) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_permission",
));
}
result.resource_permission = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__resource_type => {
if !fields.insert(__FieldTag::__resource_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_type",
));
}
result.resource_type = 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::MethodPolicy {
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 {
__selector,
__request_policies,
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 MethodPolicy")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"requestPolicies" => Ok(__FieldTag::__request_policies),
"request_policies" => Ok(__FieldTag::__request_policies),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MethodPolicy;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MethodPolicy")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__request_policies => {
if !fields.insert(__FieldTag::__request_policies) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_policies",
));
}
result.request_policies = map.next_value::<std::option::Option<std::vec::Vec<crate::model::FieldPolicy>>>()?.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::Quota {
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 {
__limits,
__metric_rules,
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 Quota")
}
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 {
"limits" => Ok(__FieldTag::__limits),
"metricRules" => Ok(__FieldTag::__metric_rules),
"metric_rules" => Ok(__FieldTag::__metric_rules),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Quota;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Quota")
}
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::__limits => {
if !fields.insert(__FieldTag::__limits) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for limits",
));
}
result.limits = map.next_value::<std::option::Option<std::vec::Vec<crate::model::QuotaLimit>>>()?.unwrap_or_default();
}
__FieldTag::__metric_rules => {
if !fields.insert(__FieldTag::__metric_rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metric_rules",
));
}
result.metric_rules = map.next_value::<std::option::Option<std::vec::Vec<crate::model::MetricRule>>>()?.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::MetricRule {
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 {
__selector,
__metric_costs,
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 MetricRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"metricCosts" => Ok(__FieldTag::__metric_costs),
"metric_costs" => Ok(__FieldTag::__metric_costs),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MetricRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MetricRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__metric_costs => {
if !fields.insert(__FieldTag::__metric_costs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metric_costs",
));
}
struct __With(
std::option::Option<
std::collections::HashMap<std::string::String, i64>,
>,
);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<
std::collections::HashMap<
serde_with::Same,
wkt::internal::I64,
>,
>,
>::deserialize(deserializer)
.map(__With)
}
}
result.metric_costs = 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::QuotaLimit {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__description,
__default_limit,
__max_limit,
__free_tier,
__duration,
__metric,
__unit,
__values,
__display_name,
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 QuotaLimit")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"description" => Ok(__FieldTag::__description),
"defaultLimit" => Ok(__FieldTag::__default_limit),
"default_limit" => Ok(__FieldTag::__default_limit),
"maxLimit" => Ok(__FieldTag::__max_limit),
"max_limit" => Ok(__FieldTag::__max_limit),
"freeTier" => Ok(__FieldTag::__free_tier),
"free_tier" => Ok(__FieldTag::__free_tier),
"duration" => Ok(__FieldTag::__duration),
"metric" => Ok(__FieldTag::__metric),
"unit" => Ok(__FieldTag::__unit),
"values" => Ok(__FieldTag::__values),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::QuotaLimit;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QuotaLimit")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__description => {
if !fields.insert(__FieldTag::__description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for description",
));
}
result.description = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__default_limit => {
if !fields.insert(__FieldTag::__default_limit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for default_limit",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.default_limit =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__max_limit => {
if !fields.insert(__FieldTag::__max_limit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_limit",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.max_limit = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__free_tier => {
if !fields.insert(__FieldTag::__free_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for free_tier",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.free_tier = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__duration => {
if !fields.insert(__FieldTag::__duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for duration",
));
}
result.duration = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__metric => {
if !fields.insert(__FieldTag::__metric) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metric",
));
}
result.metric = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__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<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__values => {
if !fields.insert(__FieldTag::__values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for values",
));
}
struct __With(
std::option::Option<
std::collections::HashMap<std::string::String, i64>,
>,
);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<
std::collections::HashMap<
serde_with::Same,
wkt::internal::I64,
>,
>,
>::deserialize(deserializer)
.map(__With)
}
}
result.values = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = 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::ResourceDescriptor {
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 {
__type,
__pattern,
__name_field,
__history,
__plural,
__singular,
__style,
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 ResourceDescriptor")
}
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 {
"type" => Ok(__FieldTag::__type),
"pattern" => Ok(__FieldTag::__pattern),
"nameField" => Ok(__FieldTag::__name_field),
"name_field" => Ok(__FieldTag::__name_field),
"history" => Ok(__FieldTag::__history),
"plural" => Ok(__FieldTag::__plural),
"singular" => Ok(__FieldTag::__singular),
"style" => Ok(__FieldTag::__style),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ResourceDescriptor;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ResourceDescriptor")
}
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::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__pattern => {
if !fields.insert(__FieldTag::__pattern) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pattern",
));
}
result.pattern = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__name_field => {
if !fields.insert(__FieldTag::__name_field) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name_field",
));
}
result.name_field = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__history => {
if !fields.insert(__FieldTag::__history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for history",
));
}
result.history = map.next_value::<std::option::Option<crate::model::resource_descriptor::History>>()?.unwrap_or_default();
}
__FieldTag::__plural => {
if !fields.insert(__FieldTag::__plural) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for plural",
));
}
result.plural = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__singular => {
if !fields.insert(__FieldTag::__singular) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for singular",
));
}
result.singular = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__style => {
if !fields.insert(__FieldTag::__style) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for style",
));
}
result.style = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::resource_descriptor::Style>,
>>()?
.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::ResourceReference {
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 {
__type,
__child_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 ResourceReference")
}
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 {
"type" => Ok(__FieldTag::__type),
"childType" => Ok(__FieldTag::__child_type),
"child_type" => Ok(__FieldTag::__child_type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ResourceReference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ResourceReference")
}
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::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__child_type => {
if !fields.insert(__FieldTag::__child_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for child_type",
));
}
result.child_type = 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::RoutingRule {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__routing_parameters,
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 RoutingRule")
}
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 {
"routingParameters" => Ok(__FieldTag::__routing_parameters),
"routing_parameters" => Ok(__FieldTag::__routing_parameters),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RoutingRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RoutingRule")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__routing_parameters => {
if !fields.insert(__FieldTag::__routing_parameters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for routing_parameters",
));
}
result.routing_parameters =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::RoutingParameter>,
>>()?
.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::RoutingParameter {
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 {
__field,
__path_template,
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 RoutingParameter")
}
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 {
"field" => Ok(__FieldTag::__field),
"pathTemplate" => Ok(__FieldTag::__path_template),
"path_template" => Ok(__FieldTag::__path_template),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RoutingParameter;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RoutingParameter")
}
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::__field => {
if !fields.insert(__FieldTag::__field) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for field",
));
}
result.field = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__path_template => {
if !fields.insert(__FieldTag::__path_template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for path_template",
));
}
result.path_template = 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::Service {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__title,
__producer_project_id,
__id,
__apis,
__types,
__enums,
__documentation,
__backend,
__http,
__quota,
__authentication,
__context,
__usage,
__endpoints,
__control,
__logs,
__metrics,
__monitored_resources,
__billing,
__logging,
__monitoring,
__system_parameters,
__source_info,
__publishing,
__config_version,
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 Service")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"title" => Ok(__FieldTag::__title),
"producerProjectId" => Ok(__FieldTag::__producer_project_id),
"producer_project_id" => Ok(__FieldTag::__producer_project_id),
"id" => Ok(__FieldTag::__id),
"apis" => Ok(__FieldTag::__apis),
"types" => Ok(__FieldTag::__types),
"enums" => Ok(__FieldTag::__enums),
"documentation" => Ok(__FieldTag::__documentation),
"backend" => Ok(__FieldTag::__backend),
"http" => Ok(__FieldTag::__http),
"quota" => Ok(__FieldTag::__quota),
"authentication" => Ok(__FieldTag::__authentication),
"context" => Ok(__FieldTag::__context),
"usage" => Ok(__FieldTag::__usage),
"endpoints" => Ok(__FieldTag::__endpoints),
"control" => Ok(__FieldTag::__control),
"logs" => Ok(__FieldTag::__logs),
"metrics" => Ok(__FieldTag::__metrics),
"monitoredResources" => Ok(__FieldTag::__monitored_resources),
"monitored_resources" => Ok(__FieldTag::__monitored_resources),
"billing" => Ok(__FieldTag::__billing),
"logging" => Ok(__FieldTag::__logging),
"monitoring" => Ok(__FieldTag::__monitoring),
"systemParameters" => Ok(__FieldTag::__system_parameters),
"system_parameters" => Ok(__FieldTag::__system_parameters),
"sourceInfo" => Ok(__FieldTag::__source_info),
"source_info" => Ok(__FieldTag::__source_info),
"publishing" => Ok(__FieldTag::__publishing),
"configVersion" => Ok(__FieldTag::__config_version),
"config_version" => Ok(__FieldTag::__config_version),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Service;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Service")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__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::__producer_project_id => {
if !fields.insert(__FieldTag::__producer_project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for producer_project_id",
));
}
result.producer_project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__apis => {
if !fields.insert(__FieldTag::__apis) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for apis",
));
}
result.apis = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Api>>>()?
.unwrap_or_default();
}
__FieldTag::__types => {
if !fields.insert(__FieldTag::__types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for types",
));
}
result.types = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Type>>>()?
.unwrap_or_default();
}
__FieldTag::__enums => {
if !fields.insert(__FieldTag::__enums) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enums",
));
}
result.enums = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Enum>>>()?
.unwrap_or_default();
}
__FieldTag::__documentation => {
if !fields.insert(__FieldTag::__documentation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documentation",
));
}
result.documentation = map
.next_value::<std::option::Option<crate::model::Documentation>>()?;
}
__FieldTag::__backend => {
if !fields.insert(__FieldTag::__backend) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backend",
));
}
result.backend =
map.next_value::<std::option::Option<crate::model::Backend>>()?;
}
__FieldTag::__http => {
if !fields.insert(__FieldTag::__http) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for http",
));
}
result.http =
map.next_value::<std::option::Option<crate::model::Http>>()?;
}
__FieldTag::__quota => {
if !fields.insert(__FieldTag::__quota) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for quota",
));
}
result.quota =
map.next_value::<std::option::Option<crate::model::Quota>>()?;
}
__FieldTag::__authentication => {
if !fields.insert(__FieldTag::__authentication) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for authentication",
));
}
result.authentication = map
.next_value::<std::option::Option<crate::model::Authentication>>(
)?;
}
__FieldTag::__context => {
if !fields.insert(__FieldTag::__context) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for context",
));
}
result.context =
map.next_value::<std::option::Option<crate::model::Context>>()?;
}
__FieldTag::__usage => {
if !fields.insert(__FieldTag::__usage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for usage",
));
}
result.usage =
map.next_value::<std::option::Option<crate::model::Usage>>()?;
}
__FieldTag::__endpoints => {
if !fields.insert(__FieldTag::__endpoints) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for endpoints",
));
}
result.endpoints = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Endpoint>>>()?.unwrap_or_default();
}
__FieldTag::__control => {
if !fields.insert(__FieldTag::__control) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for control",
));
}
result.control =
map.next_value::<std::option::Option<crate::model::Control>>()?;
}
__FieldTag::__logs => {
if !fields.insert(__FieldTag::__logs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logs",
));
}
result.logs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::LogDescriptor>>>()?.unwrap_or_default();
}
__FieldTag::__metrics => {
if !fields.insert(__FieldTag::__metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metrics",
));
}
result.metrics =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::MetricDescriptor>,
>>()?
.unwrap_or_default();
}
__FieldTag::__monitored_resources => {
if !fields.insert(__FieldTag::__monitored_resources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for monitored_resources",
));
}
result.monitored_resources = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::MonitoredResourceDescriptor>,
>>()?
.unwrap_or_default();
}
__FieldTag::__billing => {
if !fields.insert(__FieldTag::__billing) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for billing",
));
}
result.billing =
map.next_value::<std::option::Option<crate::model::Billing>>()?;
}
__FieldTag::__logging => {
if !fields.insert(__FieldTag::__logging) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging",
));
}
result.logging =
map.next_value::<std::option::Option<crate::model::Logging>>()?;
}
__FieldTag::__monitoring => {
if !fields.insert(__FieldTag::__monitoring) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for monitoring",
));
}
result.monitoring =
map.next_value::<std::option::Option<crate::model::Monitoring>>()?;
}
__FieldTag::__system_parameters => {
if !fields.insert(__FieldTag::__system_parameters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for system_parameters",
));
}
result.system_parameters = map
.next_value::<std::option::Option<crate::model::SystemParameters>>(
)?;
}
__FieldTag::__source_info => {
if !fields.insert(__FieldTag::__source_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source_info",
));
}
result.source_info =
map.next_value::<std::option::Option<crate::model::SourceInfo>>()?;
}
__FieldTag::__publishing => {
if !fields.insert(__FieldTag::__publishing) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for publishing",
));
}
result.publishing =
map.next_value::<std::option::Option<crate::model::Publishing>>()?;
}
__FieldTag::__config_version => {
if !fields.insert(__FieldTag::__config_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for config_version",
));
}
struct __With(std::option::Option<wkt::UInt32Value>);
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::U32> >::deserialize(deserializer).map(__With)
}
}
result.config_version = 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::SourceInfo {
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 {
__source_files,
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 SourceInfo")
}
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 {
"sourceFiles" => Ok(__FieldTag::__source_files),
"source_files" => Ok(__FieldTag::__source_files),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SourceInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SourceInfo")
}
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::__source_files => {
if !fields.insert(__FieldTag::__source_files) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source_files",
));
}
result.source_files = map
.next_value::<std::option::Option<std::vec::Vec<wkt::Any>>>()?
.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::SystemParameters {
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 {
__rules,
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 SystemParameters")
}
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 {
"rules" => Ok(__FieldTag::__rules),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SystemParameters;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SystemParameters")
}
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::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::SystemParameterRule>,
>>()?
.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::SystemParameterRule {
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 {
__selector,
__parameters,
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 SystemParameterRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"parameters" => Ok(__FieldTag::__parameters),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SystemParameterRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SystemParameterRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__parameters => {
if !fields.insert(__FieldTag::__parameters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parameters",
));
}
result.parameters =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::SystemParameter>,
>>()?
.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::SystemParameter {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__http_header,
__url_query_parameter,
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 SystemParameter")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"httpHeader" => Ok(__FieldTag::__http_header),
"http_header" => Ok(__FieldTag::__http_header),
"urlQueryParameter" => Ok(__FieldTag::__url_query_parameter),
"url_query_parameter" => Ok(__FieldTag::__url_query_parameter),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SystemParameter;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SystemParameter")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__http_header => {
if !fields.insert(__FieldTag::__http_header) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for http_header",
));
}
result.http_header = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__url_query_parameter => {
if !fields.insert(__FieldTag::__url_query_parameter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for url_query_parameter",
));
}
result.url_query_parameter = 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::Usage {
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 {
__requirements,
__rules,
__producer_notification_channel,
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 Usage")
}
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 {
"requirements" => Ok(__FieldTag::__requirements),
"rules" => Ok(__FieldTag::__rules),
"producerNotificationChannel" => {
Ok(__FieldTag::__producer_notification_channel)
}
"producer_notification_channel" => {
Ok(__FieldTag::__producer_notification_channel)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Usage;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Usage")
}
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::__requirements => {
if !fields.insert(__FieldTag::__requirements) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for requirements",
));
}
result.requirements = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules = map.next_value::<std::option::Option<std::vec::Vec<crate::model::UsageRule>>>()?.unwrap_or_default();
}
__FieldTag::__producer_notification_channel => {
if !fields.insert(__FieldTag::__producer_notification_channel) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for producer_notification_channel",
));
}
result.producer_notification_channel = 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::UsageRule {
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 {
__selector,
__allow_unregistered_calls,
__skip_service_control,
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 UsageRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"allowUnregisteredCalls" => Ok(__FieldTag::__allow_unregistered_calls),
"allow_unregistered_calls" => {
Ok(__FieldTag::__allow_unregistered_calls)
}
"skipServiceControl" => Ok(__FieldTag::__skip_service_control),
"skip_service_control" => Ok(__FieldTag::__skip_service_control),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UsageRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UsageRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__allow_unregistered_calls => {
if !fields.insert(__FieldTag::__allow_unregistered_calls) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_unregistered_calls",
));
}
result.allow_unregistered_calls = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__skip_service_control => {
if !fields.insert(__FieldTag::__skip_service_control) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for skip_service_control",
));
}
result.skip_service_control = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::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 {
__rules,
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 {
"rules" => Ok(__FieldTag::__rules),
_ => 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::__rules => {
if !fields.insert(__FieldTag::__rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules",
));
}
result.rules =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::VisibilityRule>,
>>()?
.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::VisibilityRule {
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 {
__selector,
__restriction,
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 VisibilityRule")
}
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 {
"selector" => Ok(__FieldTag::__selector),
"restriction" => Ok(__FieldTag::__restriction),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::VisibilityRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct VisibilityRule")
}
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::__selector => {
if !fields.insert(__FieldTag::__selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selector",
));
}
result.selector = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__restriction => {
if !fields.insert(__FieldTag::__restriction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for restriction",
));
}
result.restriction = 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)
}
}