#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::NetworkConfig {
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 {
__network,
__peering_mode,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for NetworkConfig")
}
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 {
"network" => Ok(__FieldTag::__network),
"peeringMode" => Ok(__FieldTag::__peering_mode),
"peering_mode" => Ok(__FieldTag::__peering_mode),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NetworkConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NetworkConfig")
}
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::__network => {
if !fields.insert(__FieldTag::__network) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network",
));
}
result.network = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__peering_mode => {
if !fields.insert(__FieldTag::__peering_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for peering_mode",
));
}
result.peering_mode = map.next_value::<std::option::Option<crate::model::network_config::PeeringMode>>()?.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::ManagementURI {
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 {
__web_ui,
__api,
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 ManagementURI")
}
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 {
"webUi" => Ok(__FieldTag::__web_ui),
"web_ui" => Ok(__FieldTag::__web_ui),
"api" => Ok(__FieldTag::__api),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ManagementURI;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ManagementURI")
}
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::__web_ui => {
if !fields.insert(__FieldTag::__web_ui) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for web_ui",
));
}
result.web_ui = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__api => {
if !fields.insert(__FieldTag::__api) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for api",
));
}
result.api = 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::WorkforceIdentityBasedManagementURI {
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 {
__first_party_management_uri,
__third_party_management_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 WorkforceIdentityBasedManagementURI")
}
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 {
"firstPartyManagementUri" => {
Ok(__FieldTag::__first_party_management_uri)
}
"first_party_management_uri" => {
Ok(__FieldTag::__first_party_management_uri)
}
"thirdPartyManagementUri" => {
Ok(__FieldTag::__third_party_management_uri)
}
"third_party_management_uri" => {
Ok(__FieldTag::__third_party_management_uri)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WorkforceIdentityBasedManagementURI;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkforceIdentityBasedManagementURI")
}
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::__first_party_management_uri => {
if !fields.insert(__FieldTag::__first_party_management_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for first_party_management_uri",
));
}
result.first_party_management_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__third_party_management_uri => {
if !fields.insert(__FieldTag::__third_party_management_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for third_party_management_uri",
));
}
result.third_party_management_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::WorkforceIdentityBasedOAuth2ClientID {
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 {
__first_party_oauth2_client_id,
__third_party_oauth2_client_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WorkforceIdentityBasedOAuth2ClientID")
}
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 {
"firstPartyOauth2ClientId" => {
Ok(__FieldTag::__first_party_oauth2_client_id)
}
"first_party_oauth2_client_id" => {
Ok(__FieldTag::__first_party_oauth2_client_id)
}
"thirdPartyOauth2ClientId" => {
Ok(__FieldTag::__third_party_oauth2_client_id)
}
"third_party_oauth2_client_id" => {
Ok(__FieldTag::__third_party_oauth2_client_id)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WorkforceIdentityBasedOAuth2ClientID;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkforceIdentityBasedOAuth2ClientID")
}
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::__first_party_oauth2_client_id => {
if !fields.insert(__FieldTag::__first_party_oauth2_client_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for first_party_oauth2_client_id",
));
}
result.first_party_oauth2_client_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__third_party_oauth2_client_id => {
if !fields.insert(__FieldTag::__third_party_oauth2_client_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for third_party_oauth2_client_id",
));
}
result.third_party_oauth2_client_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ManagementServer {
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,
__labels,
__create_time,
__update_time,
__type,
__management_uri,
__workforce_identity_based_management_uri,
__state,
__networks,
__etag,
__oauth2_client_id,
__workforce_identity_based_oauth2_client_id,
__ba_proxy_uri,
__satisfies_pzs,
__satisfies_pzi,
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 ManagementServer")
}
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),
"labels" => Ok(__FieldTag::__labels),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"type" => Ok(__FieldTag::__type),
"managementUri" => Ok(__FieldTag::__management_uri),
"management_uri" => Ok(__FieldTag::__management_uri),
"workforceIdentityBasedManagementUri" => {
Ok(__FieldTag::__workforce_identity_based_management_uri)
}
"workforce_identity_based_management_uri" => {
Ok(__FieldTag::__workforce_identity_based_management_uri)
}
"state" => Ok(__FieldTag::__state),
"networks" => Ok(__FieldTag::__networks),
"etag" => Ok(__FieldTag::__etag),
"oauth2ClientId" => Ok(__FieldTag::__oauth2_client_id),
"oauth2_client_id" => Ok(__FieldTag::__oauth2_client_id),
"workforceIdentityBasedOauth2ClientId" => {
Ok(__FieldTag::__workforce_identity_based_oauth2_client_id)
}
"workforce_identity_based_oauth2_client_id" => {
Ok(__FieldTag::__workforce_identity_based_oauth2_client_id)
}
"baProxyUri" => Ok(__FieldTag::__ba_proxy_uri),
"ba_proxy_uri" => Ok(__FieldTag::__ba_proxy_uri),
"satisfiesPzs" => Ok(__FieldTag::__satisfies_pzs),
"satisfies_pzs" => Ok(__FieldTag::__satisfies_pzs),
"satisfiesPzi" => Ok(__FieldTag::__satisfies_pzi),
"satisfies_pzi" => Ok(__FieldTag::__satisfies_pzi),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ManagementServer;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ManagementServer")
}
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::__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::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__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::management_server::InstanceType,
>>()?
.unwrap_or_default();
}
__FieldTag::__management_uri => {
if !fields.insert(__FieldTag::__management_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for management_uri",
));
}
result.management_uri = map
.next_value::<std::option::Option<crate::model::ManagementURI>>()?;
}
__FieldTag::__workforce_identity_based_management_uri => {
if !fields.insert(__FieldTag::__workforce_identity_based_management_uri)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for workforce_identity_based_management_uri",
));
}
result.workforce_identity_based_management_uri =
map.next_value::<std::option::Option<
crate::model::WorkforceIdentityBasedManagementURI,
>>()?;
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state =
map.next_value::<std::option::Option<
crate::model::management_server::InstanceState,
>>()?
.unwrap_or_default();
}
__FieldTag::__networks => {
if !fields.insert(__FieldTag::__networks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for networks",
));
}
result.networks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::NetworkConfig>>>()?.unwrap_or_default();
}
__FieldTag::__etag => {
if !fields.insert(__FieldTag::__etag) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for etag",
));
}
result.etag = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__oauth2_client_id => {
if !fields.insert(__FieldTag::__oauth2_client_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for oauth2_client_id",
));
}
result.oauth2_client_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__workforce_identity_based_oauth2_client_id => {
if !fields
.insert(__FieldTag::__workforce_identity_based_oauth2_client_id)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for workforce_identity_based_oauth2_client_id",
));
}
result.workforce_identity_based_oauth2_client_id =
map.next_value::<std::option::Option<
crate::model::WorkforceIdentityBasedOAuth2ClientID,
>>()?;
}
__FieldTag::__ba_proxy_uri => {
if !fields.insert(__FieldTag::__ba_proxy_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ba_proxy_uri",
));
}
result.ba_proxy_uri = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__satisfies_pzs => {
if !fields.insert(__FieldTag::__satisfies_pzs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for satisfies_pzs",
));
}
result.satisfies_pzs =
map.next_value::<std::option::Option<wkt::BoolValue>>()?;
}
__FieldTag::__satisfies_pzi => {
if !fields.insert(__FieldTag::__satisfies_pzi) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for satisfies_pzi",
));
}
result.satisfies_pzi = 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::ListManagementServersRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
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 ListManagementServersRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListManagementServersRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListManagementServersRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListManagementServersResponse {
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 {
__management_servers,
__next_page_token,
__unreachable,
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 ListManagementServersResponse")
}
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 {
"managementServers" => Ok(__FieldTag::__management_servers),
"management_servers" => Ok(__FieldTag::__management_servers),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListManagementServersResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListManagementServersResponse")
}
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::__management_servers => {
if !fields.insert(__FieldTag::__management_servers) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for management_servers",
));
}
result.management_servers =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::ManagementServer>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::GetManagementServerRequest {
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,
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 GetManagementServerRequest")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetManagementServerRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetManagementServerRequest")
}
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::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::CreateManagementServerRequest {
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 {
__parent,
__management_server_id,
__management_server,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateManagementServerRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"managementServerId" => Ok(__FieldTag::__management_server_id),
"management_server_id" => Ok(__FieldTag::__management_server_id),
"managementServer" => Ok(__FieldTag::__management_server),
"management_server" => Ok(__FieldTag::__management_server),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateManagementServerRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateManagementServerRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__management_server_id => {
if !fields.insert(__FieldTag::__management_server_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for management_server_id",
));
}
result.management_server_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__management_server => {
if !fields.insert(__FieldTag::__management_server) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for management_server",
));
}
result.management_server = map
.next_value::<std::option::Option<crate::model::ManagementServer>>(
)?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteManagementServerRequest {
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,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteManagementServerRequest")
}
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),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteManagementServerRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteManagementServerRequest")
}
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::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::InitializeServiceRequest {
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,
__resource_type,
__request_id,
__cloud_sql_instance_initialization_config,
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 InitializeServiceRequest")
}
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),
"resourceType" => Ok(__FieldTag::__resource_type),
"resource_type" => Ok(__FieldTag::__resource_type),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"cloudSqlInstanceInitializationConfig" => {
Ok(__FieldTag::__cloud_sql_instance_initialization_config)
}
"cloud_sql_instance_initialization_config" => {
Ok(__FieldTag::__cloud_sql_instance_initialization_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InitializeServiceRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InitializeServiceRequest")
}
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::__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::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cloud_sql_instance_initialization_config => {
if !fields
.insert(__FieldTag::__cloud_sql_instance_initialization_config)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_sql_instance_initialization_config",
));
}
if result.initialization_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `initialization_config`, a oneof with full ID .google.cloud.backupdr.v1.InitializeServiceRequest.cloud_sql_instance_initialization_config, latest field was cloudSqlInstanceInitializationConfig",
));
}
result.initialization_config = std::option::Option::Some(
crate::model::initialize_service_request::InitializationConfig::CloudSqlInstanceInitializationConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::CloudSqlInstanceInitializationConfig>>>()?.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::InitializeServiceResponse {
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 {
__backup_vault_name,
__backup_plan_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 InitializeServiceResponse")
}
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 {
"backupVaultName" => Ok(__FieldTag::__backup_vault_name),
"backup_vault_name" => Ok(__FieldTag::__backup_vault_name),
"backupPlanName" => Ok(__FieldTag::__backup_plan_name),
"backup_plan_name" => Ok(__FieldTag::__backup_plan_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InitializeServiceResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InitializeServiceResponse")
}
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::__backup_vault_name => {
if !fields.insert(__FieldTag::__backup_vault_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vault_name",
));
}
result.backup_vault_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_name => {
if !fields.insert(__FieldTag::__backup_plan_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_name",
));
}
result.backup_plan_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::OperationMetadata {
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 {
__create_time,
__end_time,
__target,
__verb,
__status_message,
__requested_cancellation,
__api_version,
__additional_info,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for OperationMetadata")
}
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 {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"endTime" => Ok(__FieldTag::__end_time),
"end_time" => Ok(__FieldTag::__end_time),
"target" => Ok(__FieldTag::__target),
"verb" => Ok(__FieldTag::__verb),
"statusMessage" => Ok(__FieldTag::__status_message),
"status_message" => Ok(__FieldTag::__status_message),
"requestedCancellation" => Ok(__FieldTag::__requested_cancellation),
"requested_cancellation" => Ok(__FieldTag::__requested_cancellation),
"apiVersion" => Ok(__FieldTag::__api_version),
"api_version" => Ok(__FieldTag::__api_version),
"additionalInfo" => Ok(__FieldTag::__additional_info),
"additional_info" => Ok(__FieldTag::__additional_info),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::OperationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct OperationMetadata")
}
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::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__end_time => {
if !fields.insert(__FieldTag::__end_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_time",
));
}
result.end_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__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::__verb => {
if !fields.insert(__FieldTag::__verb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for verb",
));
}
result.verb = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__status_message => {
if !fields.insert(__FieldTag::__status_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status_message",
));
}
result.status_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__requested_cancellation => {
if !fields.insert(__FieldTag::__requested_cancellation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for requested_cancellation",
));
}
result.requested_cancellation = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__api_version => {
if !fields.insert(__FieldTag::__api_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for api_version",
));
}
result.api_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__additional_info => {
if !fields.insert(__FieldTag::__additional_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for additional_info",
));
}
result.additional_info = 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::BackupPlan {
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,
__labels,
__create_time,
__update_time,
__backup_rules,
__state,
__resource_type,
__etag,
__backup_vault,
__backup_vault_service_account,
__log_retention_days,
__supported_resource_types,
__revision_id,
__revision_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 BackupPlan")
}
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),
"labels" => Ok(__FieldTag::__labels),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"backupRules" => Ok(__FieldTag::__backup_rules),
"backup_rules" => Ok(__FieldTag::__backup_rules),
"state" => Ok(__FieldTag::__state),
"resourceType" => Ok(__FieldTag::__resource_type),
"resource_type" => Ok(__FieldTag::__resource_type),
"etag" => Ok(__FieldTag::__etag),
"backupVault" => Ok(__FieldTag::__backup_vault),
"backup_vault" => Ok(__FieldTag::__backup_vault),
"backupVaultServiceAccount" => {
Ok(__FieldTag::__backup_vault_service_account)
}
"backup_vault_service_account" => {
Ok(__FieldTag::__backup_vault_service_account)
}
"logRetentionDays" => Ok(__FieldTag::__log_retention_days),
"log_retention_days" => Ok(__FieldTag::__log_retention_days),
"supportedResourceTypes" => Ok(__FieldTag::__supported_resource_types),
"supported_resource_types" => {
Ok(__FieldTag::__supported_resource_types)
}
"revisionId" => Ok(__FieldTag::__revision_id),
"revision_id" => Ok(__FieldTag::__revision_id),
"revisionName" => Ok(__FieldTag::__revision_name),
"revision_name" => Ok(__FieldTag::__revision_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupPlan;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupPlan")
}
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::__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::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__backup_rules => {
if !fields.insert(__FieldTag::__backup_rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_rules",
));
}
result.backup_rules = map.next_value::<std::option::Option<std::vec::Vec<crate::model::BackupRule>>>()?.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::backup_plan::State>>()?.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::__etag => {
if !fields.insert(__FieldTag::__etag) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for etag",
));
}
result.etag = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_vault => {
if !fields.insert(__FieldTag::__backup_vault) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vault",
));
}
result.backup_vault = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_vault_service_account => {
if !fields.insert(__FieldTag::__backup_vault_service_account) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vault_service_account",
));
}
result.backup_vault_service_account = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__log_retention_days => {
if !fields.insert(__FieldTag::__log_retention_days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for log_retention_days",
));
}
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.log_retention_days =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__supported_resource_types => {
if !fields.insert(__FieldTag::__supported_resource_types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for supported_resource_types",
));
}
result.supported_resource_types = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__revision_id => {
if !fields.insert(__FieldTag::__revision_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for revision_id",
));
}
result.revision_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__revision_name => {
if !fields.insert(__FieldTag::__revision_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for revision_name",
));
}
result.revision_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::BackupRule {
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 {
__rule_id,
__backup_retention_days,
__standard_schedule,
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 BackupRule")
}
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 {
"ruleId" => Ok(__FieldTag::__rule_id),
"rule_id" => Ok(__FieldTag::__rule_id),
"backupRetentionDays" => Ok(__FieldTag::__backup_retention_days),
"backup_retention_days" => Ok(__FieldTag::__backup_retention_days),
"standardSchedule" => Ok(__FieldTag::__standard_schedule),
"standard_schedule" => Ok(__FieldTag::__standard_schedule),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupRule")
}
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::__rule_id => {
if !fields.insert(__FieldTag::__rule_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rule_id",
));
}
result.rule_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_retention_days => {
if !fields.insert(__FieldTag::__backup_retention_days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_retention_days",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.backup_retention_days =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__standard_schedule => {
if !fields.insert(__FieldTag::__standard_schedule) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for standard_schedule",
));
}
if result.backup_schedule_oneof.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_schedule_oneof`, a oneof with full ID .google.cloud.backupdr.v1.BackupRule.standard_schedule, latest field was standardSchedule",
));
}
result.backup_schedule_oneof = std::option::Option::Some(
crate::model::backup_rule::BackupScheduleOneof::StandardSchedule(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::StandardSchedule>,
>>()?
.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::StandardSchedule {
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 {
__recurrence_type,
__hourly_frequency,
__days_of_week,
__days_of_month,
__week_day_of_month,
__months,
__backup_window,
__time_zone,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StandardSchedule")
}
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 {
"recurrenceType" => Ok(__FieldTag::__recurrence_type),
"recurrence_type" => Ok(__FieldTag::__recurrence_type),
"hourlyFrequency" => Ok(__FieldTag::__hourly_frequency),
"hourly_frequency" => Ok(__FieldTag::__hourly_frequency),
"daysOfWeek" => Ok(__FieldTag::__days_of_week),
"days_of_week" => Ok(__FieldTag::__days_of_week),
"daysOfMonth" => Ok(__FieldTag::__days_of_month),
"days_of_month" => Ok(__FieldTag::__days_of_month),
"weekDayOfMonth" => Ok(__FieldTag::__week_day_of_month),
"week_day_of_month" => Ok(__FieldTag::__week_day_of_month),
"months" => Ok(__FieldTag::__months),
"backupWindow" => Ok(__FieldTag::__backup_window),
"backup_window" => Ok(__FieldTag::__backup_window),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::StandardSchedule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StandardSchedule")
}
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::__recurrence_type => {
if !fields.insert(__FieldTag::__recurrence_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for recurrence_type",
));
}
result.recurrence_type = map
.next_value::<std::option::Option<
crate::model::standard_schedule::RecurrenceType,
>>()?
.unwrap_or_default();
}
__FieldTag::__hourly_frequency => {
if !fields.insert(__FieldTag::__hourly_frequency) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hourly_frequency",
));
}
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.hourly_frequency =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__days_of_week => {
if !fields.insert(__FieldTag::__days_of_week) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for days_of_week",
));
}
result.days_of_week = map
.next_value::<std::option::Option<
std::vec::Vec<google_cloud_type::model::DayOfWeek>,
>>()?
.unwrap_or_default();
}
__FieldTag::__days_of_month => {
if !fields.insert(__FieldTag::__days_of_month) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for days_of_month",
));
}
struct __With(std::option::Option<std::vec::Vec<i32>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::I32>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.days_of_month =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__week_day_of_month => {
if !fields.insert(__FieldTag::__week_day_of_month) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for week_day_of_month",
));
}
result.week_day_of_month = map
.next_value::<std::option::Option<crate::model::WeekDayOfMonth>>(
)?;
}
__FieldTag::__months => {
if !fields.insert(__FieldTag::__months) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for months",
));
}
result.months =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_type::model::Month>,
>>()?
.unwrap_or_default();
}
__FieldTag::__backup_window => {
if !fields.insert(__FieldTag::__backup_window) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_window",
));
}
result.backup_window = map
.next_value::<std::option::Option<crate::model::BackupWindow>>()?;
}
__FieldTag::__time_zone => {
if !fields.insert(__FieldTag::__time_zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_zone",
));
}
result.time_zone = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BackupWindow {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_hour_of_day,
__end_hour_of_day,
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 BackupWindow")
}
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 {
"startHourOfDay" => Ok(__FieldTag::__start_hour_of_day),
"start_hour_of_day" => Ok(__FieldTag::__start_hour_of_day),
"endHourOfDay" => Ok(__FieldTag::__end_hour_of_day),
"end_hour_of_day" => Ok(__FieldTag::__end_hour_of_day),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupWindow;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupWindow")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_hour_of_day => {
if !fields.insert(__FieldTag::__start_hour_of_day) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_hour_of_day",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.start_hour_of_day =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__end_hour_of_day => {
if !fields.insert(__FieldTag::__end_hour_of_day) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_hour_of_day",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.end_hour_of_day =
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::WeekDayOfMonth {
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 {
__week_of_month,
__day_of_week,
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 WeekDayOfMonth")
}
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 {
"weekOfMonth" => Ok(__FieldTag::__week_of_month),
"week_of_month" => Ok(__FieldTag::__week_of_month),
"dayOfWeek" => Ok(__FieldTag::__day_of_week),
"day_of_week" => Ok(__FieldTag::__day_of_week),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WeekDayOfMonth;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WeekDayOfMonth")
}
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::__week_of_month => {
if !fields.insert(__FieldTag::__week_of_month) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for week_of_month",
));
}
result.week_of_month =
map.next_value::<std::option::Option<
crate::model::week_day_of_month::WeekOfMonth,
>>()?
.unwrap_or_default();
}
__FieldTag::__day_of_week => {
if !fields.insert(__FieldTag::__day_of_week) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for day_of_week",
));
}
result.day_of_week = map.next_value::<std::option::Option<google_cloud_type::model::DayOfWeek>>()?.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::CreateBackupPlanRequest {
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 {
__parent,
__backup_plan_id,
__backup_plan,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateBackupPlanRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"backupPlanId" => Ok(__FieldTag::__backup_plan_id),
"backup_plan_id" => Ok(__FieldTag::__backup_plan_id),
"backupPlan" => Ok(__FieldTag::__backup_plan),
"backup_plan" => Ok(__FieldTag::__backup_plan),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateBackupPlanRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateBackupPlanRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_id => {
if !fields.insert(__FieldTag::__backup_plan_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_id",
));
}
result.backup_plan_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan => {
if !fields.insert(__FieldTag::__backup_plan) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan",
));
}
result.backup_plan =
map.next_value::<std::option::Option<crate::model::BackupPlan>>()?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListBackupPlansRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
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 ListBackupPlansRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupPlansRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupPlansRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = 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::ListBackupPlansResponse {
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 {
__backup_plans,
__next_page_token,
__unreachable,
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 ListBackupPlansResponse")
}
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 {
"backupPlans" => Ok(__FieldTag::__backup_plans),
"backup_plans" => Ok(__FieldTag::__backup_plans),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupPlansResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupPlansResponse")
}
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::__backup_plans => {
if !fields.insert(__FieldTag::__backup_plans) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plans",
));
}
result.backup_plans = map.next_value::<std::option::Option<std::vec::Vec<crate::model::BackupPlan>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::GetBackupPlanRequest {
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,
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 GetBackupPlanRequest")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetBackupPlanRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetBackupPlanRequest")
}
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::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::DeleteBackupPlanRequest {
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,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteBackupPlanRequest")
}
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),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteBackupPlanRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteBackupPlanRequest")
}
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::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateBackupPlanRequest {
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 {
__backup_plan,
__update_mask,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateBackupPlanRequest")
}
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 {
"backupPlan" => Ok(__FieldTag::__backup_plan),
"backup_plan" => Ok(__FieldTag::__backup_plan),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateBackupPlanRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateBackupPlanRequest")
}
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::__backup_plan => {
if !fields.insert(__FieldTag::__backup_plan) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan",
));
}
result.backup_plan =
map.next_value::<std::option::Option<crate::model::BackupPlan>>()?;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BackupPlanRevision {
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,
__revision_id,
__state,
__backup_plan_snapshot,
__create_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BackupPlanRevision")
}
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),
"revisionId" => Ok(__FieldTag::__revision_id),
"revision_id" => Ok(__FieldTag::__revision_id),
"state" => Ok(__FieldTag::__state),
"backupPlanSnapshot" => Ok(__FieldTag::__backup_plan_snapshot),
"backup_plan_snapshot" => Ok(__FieldTag::__backup_plan_snapshot),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupPlanRevision;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupPlanRevision")
}
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::__revision_id => {
if !fields.insert(__FieldTag::__revision_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for revision_id",
));
}
result.revision_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::backup_plan_revision::State>>()?.unwrap_or_default();
}
__FieldTag::__backup_plan_snapshot => {
if !fields.insert(__FieldTag::__backup_plan_snapshot) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_snapshot",
));
}
result.backup_plan_snapshot =
map.next_value::<std::option::Option<crate::model::BackupPlan>>()?;
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetBackupPlanRevisionRequest {
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,
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 GetBackupPlanRevisionRequest")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetBackupPlanRevisionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetBackupPlanRevisionRequest")
}
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::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::ListBackupPlanRevisionsRequest {
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 {
__parent,
__page_size,
__page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListBackupPlanRevisionsRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupPlanRevisionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupPlanRevisionsRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListBackupPlanRevisionsResponse {
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 {
__backup_plan_revisions,
__next_page_token,
__unreachable,
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 ListBackupPlanRevisionsResponse")
}
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 {
"backupPlanRevisions" => Ok(__FieldTag::__backup_plan_revisions),
"backup_plan_revisions" => Ok(__FieldTag::__backup_plan_revisions),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupPlanRevisionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupPlanRevisionsResponse")
}
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::__backup_plan_revisions => {
if !fields.insert(__FieldTag::__backup_plan_revisions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_revisions",
));
}
result.backup_plan_revisions = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::BackupPlanRevision>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::BackupPlanAssociation {
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,
__resource_type,
__resource,
__backup_plan,
__create_time,
__update_time,
__state,
__rules_config_info,
__data_source,
__cloud_sql_instance_backup_plan_association_properties,
__alloydb_cluster_backup_plan_association_properties,
__backup_plan_revision_id,
__backup_plan_revision_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 BackupPlanAssociation")
}
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),
"resourceType" => Ok(__FieldTag::__resource_type),
"resource_type" => Ok(__FieldTag::__resource_type),
"resource" => Ok(__FieldTag::__resource),
"backupPlan" => Ok(__FieldTag::__backup_plan),
"backup_plan" => Ok(__FieldTag::__backup_plan),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"state" => Ok(__FieldTag::__state),
"rulesConfigInfo" => Ok(__FieldTag::__rules_config_info),
"rules_config_info" => Ok(__FieldTag::__rules_config_info),
"dataSource" => Ok(__FieldTag::__data_source),
"data_source" => Ok(__FieldTag::__data_source),
"cloudSqlInstanceBackupPlanAssociationProperties" => Ok(
__FieldTag::__cloud_sql_instance_backup_plan_association_properties,
),
"cloud_sql_instance_backup_plan_association_properties" => Ok(
__FieldTag::__cloud_sql_instance_backup_plan_association_properties,
),
"alloydbClusterBackupPlanAssociationProperties" => Ok(
__FieldTag::__alloydb_cluster_backup_plan_association_properties,
),
"alloydb_cluster_backup_plan_association_properties" => Ok(
__FieldTag::__alloydb_cluster_backup_plan_association_properties,
),
"backupPlanRevisionId" => Ok(__FieldTag::__backup_plan_revision_id),
"backup_plan_revision_id" => Ok(__FieldTag::__backup_plan_revision_id),
"backupPlanRevisionName" => Ok(__FieldTag::__backup_plan_revision_name),
"backup_plan_revision_name" => {
Ok(__FieldTag::__backup_plan_revision_name)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupPlanAssociation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupPlanAssociation")
}
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::__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::__resource => {
if !fields.insert(__FieldTag::__resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource",
));
}
result.resource = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan => {
if !fields.insert(__FieldTag::__backup_plan) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan",
));
}
result.backup_plan = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state =
map.next_value::<std::option::Option<
crate::model::backup_plan_association::State,
>>()?
.unwrap_or_default();
}
__FieldTag::__rules_config_info => {
if !fields.insert(__FieldTag::__rules_config_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rules_config_info",
));
}
result.rules_config_info =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::RuleConfigInfo>,
>>()?
.unwrap_or_default();
}
__FieldTag::__data_source => {
if !fields.insert(__FieldTag::__data_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source",
));
}
result.data_source = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cloud_sql_instance_backup_plan_association_properties => {
if !fields.insert(
__FieldTag::__cloud_sql_instance_backup_plan_association_properties,
) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_sql_instance_backup_plan_association_properties",
));
}
if result.resource_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `resource_properties`, a oneof with full ID .google.cloud.backupdr.v1.BackupPlanAssociation.cloud_sql_instance_backup_plan_association_properties, latest field was cloudSqlInstanceBackupPlanAssociationProperties",
));
}
result.resource_properties = std::option::Option::Some(
crate::model::backup_plan_association::ResourceProperties::CloudSqlInstanceBackupPlanAssociationProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::CloudSqlInstanceBackupPlanAssociationProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__alloydb_cluster_backup_plan_association_properties => {
if !fields.insert(
__FieldTag::__alloydb_cluster_backup_plan_association_properties,
) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alloydb_cluster_backup_plan_association_properties",
));
}
if result.resource_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `resource_properties`, a oneof with full ID .google.cloud.backupdr.v1.BackupPlanAssociation.alloydb_cluster_backup_plan_association_properties, latest field was alloydbClusterBackupPlanAssociationProperties",
));
}
result.resource_properties = std::option::Option::Some(
crate::model::backup_plan_association::ResourceProperties::AlloydbClusterBackupPlanAssociationProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::AlloyDBClusterBackupPlanAssociationProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__backup_plan_revision_id => {
if !fields.insert(__FieldTag::__backup_plan_revision_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_revision_id",
));
}
result.backup_plan_revision_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_revision_name => {
if !fields.insert(__FieldTag::__backup_plan_revision_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_revision_name",
));
}
result.backup_plan_revision_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::RuleConfigInfo {
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 {
__rule_id,
__last_backup_state,
__last_backup_error,
__last_successful_backup_consistency_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RuleConfigInfo")
}
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 {
"ruleId" => Ok(__FieldTag::__rule_id),
"rule_id" => Ok(__FieldTag::__rule_id),
"lastBackupState" => Ok(__FieldTag::__last_backup_state),
"last_backup_state" => Ok(__FieldTag::__last_backup_state),
"lastBackupError" => Ok(__FieldTag::__last_backup_error),
"last_backup_error" => Ok(__FieldTag::__last_backup_error),
"lastSuccessfulBackupConsistencyTime" => {
Ok(__FieldTag::__last_successful_backup_consistency_time)
}
"last_successful_backup_consistency_time" => {
Ok(__FieldTag::__last_successful_backup_consistency_time)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RuleConfigInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RuleConfigInfo")
}
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::__rule_id => {
if !fields.insert(__FieldTag::__rule_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rule_id",
));
}
result.rule_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__last_backup_state => {
if !fields.insert(__FieldTag::__last_backup_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_backup_state",
));
}
result.last_backup_state = map
.next_value::<std::option::Option<
crate::model::rule_config_info::LastBackupState,
>>()?
.unwrap_or_default();
}
__FieldTag::__last_backup_error => {
if !fields.insert(__FieldTag::__last_backup_error) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_backup_error",
));
}
result.last_backup_error = map
.next_value::<std::option::Option<google_cloud_rpc::model::Status>>(
)?;
}
__FieldTag::__last_successful_backup_consistency_time => {
if !fields.insert(__FieldTag::__last_successful_backup_consistency_time)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_successful_backup_consistency_time",
));
}
result.last_successful_backup_consistency_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateBackupPlanAssociationRequest {
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 {
__parent,
__backup_plan_association_id,
__backup_plan_association,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateBackupPlanAssociationRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"backupPlanAssociationId" => {
Ok(__FieldTag::__backup_plan_association_id)
}
"backup_plan_association_id" => {
Ok(__FieldTag::__backup_plan_association_id)
}
"backupPlanAssociation" => Ok(__FieldTag::__backup_plan_association),
"backup_plan_association" => Ok(__FieldTag::__backup_plan_association),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateBackupPlanAssociationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateBackupPlanAssociationRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_association_id => {
if !fields.insert(__FieldTag::__backup_plan_association_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_association_id",
));
}
result.backup_plan_association_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_association => {
if !fields.insert(__FieldTag::__backup_plan_association) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_association",
));
}
result.backup_plan_association = map.next_value::<std::option::Option<crate::model::BackupPlanAssociation>>()?
;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListBackupPlanAssociationsRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
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 ListBackupPlanAssociationsRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupPlanAssociationsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupPlanAssociationsRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = 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::ListBackupPlanAssociationsResponse {
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 {
__backup_plan_associations,
__next_page_token,
__unreachable,
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 ListBackupPlanAssociationsResponse")
}
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 {
"backupPlanAssociations" => Ok(__FieldTag::__backup_plan_associations),
"backup_plan_associations" => {
Ok(__FieldTag::__backup_plan_associations)
}
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupPlanAssociationsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupPlanAssociationsResponse")
}
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::__backup_plan_associations => {
if !fields.insert(__FieldTag::__backup_plan_associations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_associations",
));
}
result.backup_plan_associations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::BackupPlanAssociation>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::FetchBackupPlanAssociationsForResourceTypeRequest {
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 {
__parent,
__resource_type,
__page_size,
__page_token,
__filter,
__order_by,
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 FetchBackupPlanAssociationsForResourceTypeRequest",
)
}
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 {
"parent" => Ok(__FieldTag::__parent),
"resourceType" => Ok(__FieldTag::__resource_type),
"resource_type" => Ok(__FieldTag::__resource_type),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchBackupPlanAssociationsForResourceTypeRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchBackupPlanAssociationsForResourceTypeRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = 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::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = 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::FetchBackupPlanAssociationsForResourceTypeResponse
{
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 {
__backup_plan_associations,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str(
"a field name for FetchBackupPlanAssociationsForResourceTypeResponse",
)
}
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 {
"backupPlanAssociations" => Ok(__FieldTag::__backup_plan_associations),
"backup_plan_associations" => {
Ok(__FieldTag::__backup_plan_associations)
}
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchBackupPlanAssociationsForResourceTypeResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchBackupPlanAssociationsForResourceTypeResponse")
}
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::__backup_plan_associations => {
if !fields.insert(__FieldTag::__backup_plan_associations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_associations",
));
}
result.backup_plan_associations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::BackupPlanAssociation>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetBackupPlanAssociationRequest {
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,
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 GetBackupPlanAssociationRequest")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetBackupPlanAssociationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetBackupPlanAssociationRequest")
}
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::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::DeleteBackupPlanAssociationRequest {
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,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteBackupPlanAssociationRequest")
}
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),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteBackupPlanAssociationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteBackupPlanAssociationRequest")
}
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::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateBackupPlanAssociationRequest {
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 {
__backup_plan_association,
__update_mask,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateBackupPlanAssociationRequest")
}
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 {
"backupPlanAssociation" => Ok(__FieldTag::__backup_plan_association),
"backup_plan_association" => Ok(__FieldTag::__backup_plan_association),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateBackupPlanAssociationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateBackupPlanAssociationRequest")
}
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::__backup_plan_association => {
if !fields.insert(__FieldTag::__backup_plan_association) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_association",
));
}
result.backup_plan_association = map.next_value::<std::option::Option<crate::model::BackupPlanAssociation>>()?
;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TriggerBackupRequest {
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,
__rule_id,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TriggerBackupRequest")
}
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),
"ruleId" => Ok(__FieldTag::__rule_id),
"rule_id" => Ok(__FieldTag::__rule_id),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TriggerBackupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TriggerBackupRequest")
}
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::__rule_id => {
if !fields.insert(__FieldTag::__rule_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rule_id",
));
}
result.rule_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BackupVault {
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,
__labels,
__create_time,
__update_time,
__backup_minimum_enforced_retention_duration,
__backup_retention_inheritance,
__deletable,
__etag,
__state,
__effective_time,
__backup_count,
__service_account,
__total_stored_bytes,
__uid,
__annotations,
__access_restriction,
__encryption_config,
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 BackupVault")
}
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),
"labels" => Ok(__FieldTag::__labels),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"backupMinimumEnforcedRetentionDuration" => {
Ok(__FieldTag::__backup_minimum_enforced_retention_duration)
}
"backup_minimum_enforced_retention_duration" => {
Ok(__FieldTag::__backup_minimum_enforced_retention_duration)
}
"backupRetentionInheritance" => {
Ok(__FieldTag::__backup_retention_inheritance)
}
"backup_retention_inheritance" => {
Ok(__FieldTag::__backup_retention_inheritance)
}
"deletable" => Ok(__FieldTag::__deletable),
"etag" => Ok(__FieldTag::__etag),
"state" => Ok(__FieldTag::__state),
"effectiveTime" => Ok(__FieldTag::__effective_time),
"effective_time" => Ok(__FieldTag::__effective_time),
"backupCount" => Ok(__FieldTag::__backup_count),
"backup_count" => Ok(__FieldTag::__backup_count),
"serviceAccount" => Ok(__FieldTag::__service_account),
"service_account" => Ok(__FieldTag::__service_account),
"totalStoredBytes" => Ok(__FieldTag::__total_stored_bytes),
"total_stored_bytes" => Ok(__FieldTag::__total_stored_bytes),
"uid" => Ok(__FieldTag::__uid),
"annotations" => Ok(__FieldTag::__annotations),
"accessRestriction" => Ok(__FieldTag::__access_restriction),
"access_restriction" => Ok(__FieldTag::__access_restriction),
"encryptionConfig" => Ok(__FieldTag::__encryption_config),
"encryption_config" => Ok(__FieldTag::__encryption_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupVault;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupVault")
}
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>>()?;
}
__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::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__backup_minimum_enforced_retention_duration => {
if !fields
.insert(__FieldTag::__backup_minimum_enforced_retention_duration)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_minimum_enforced_retention_duration",
));
}
result.backup_minimum_enforced_retention_duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__backup_retention_inheritance => {
if !fields.insert(__FieldTag::__backup_retention_inheritance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_retention_inheritance",
));
}
result.backup_retention_inheritance = map
.next_value::<std::option::Option<
crate::model::backup_vault::BackupRetentionInheritance,
>>()?;
}
__FieldTag::__deletable => {
if !fields.insert(__FieldTag::__deletable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for deletable",
));
}
result.deletable = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__etag => {
if !fields.insert(__FieldTag::__etag) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for etag",
));
}
result.etag =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::backup_vault::State>>()?.unwrap_or_default();
}
__FieldTag::__effective_time => {
if !fields.insert(__FieldTag::__effective_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for effective_time",
));
}
result.effective_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__backup_count => {
if !fields.insert(__FieldTag::__backup_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_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.backup_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__service_account => {
if !fields.insert(__FieldTag::__service_account) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_account",
));
}
result.service_account = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__total_stored_bytes => {
if !fields.insert(__FieldTag::__total_stored_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_stored_bytes",
));
}
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.total_stored_bytes =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__uid => {
if !fields.insert(__FieldTag::__uid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uid",
));
}
result.uid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__annotations => {
if !fields.insert(__FieldTag::__annotations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for annotations",
));
}
result.annotations = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__access_restriction => {
if !fields.insert(__FieldTag::__access_restriction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for access_restriction",
));
}
result.access_restriction =
map.next_value::<std::option::Option<
crate::model::backup_vault::AccessRestriction,
>>()?
.unwrap_or_default();
}
__FieldTag::__encryption_config => {
if !fields.insert(__FieldTag::__encryption_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for encryption_config",
));
}
result.encryption_config =
map.next_value::<std::option::Option<
crate::model::backup_vault::EncryptionConfig,
>>()?;
}
__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::backup_vault::EncryptionConfig {
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 {
__kms_key_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 EncryptionConfig")
}
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 {
"kmsKeyName" => Ok(__FieldTag::__kms_key_name),
"kms_key_name" => Ok(__FieldTag::__kms_key_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::backup_vault::EncryptionConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EncryptionConfig")
}
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::__kms_key_name => {
if !fields.insert(__FieldTag::__kms_key_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_name",
));
}
result.kms_key_name =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DataSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__state,
__labels,
__create_time,
__update_time,
__backup_count,
__etag,
__total_stored_bytes,
__config_state,
__backup_config_info,
__data_source_gcp_resource,
__data_source_backup_appliance_application,
__backup_blocked_by_vault_access_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 DataSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"state" => Ok(__FieldTag::__state),
"labels" => Ok(__FieldTag::__labels),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"backupCount" => Ok(__FieldTag::__backup_count),
"backup_count" => Ok(__FieldTag::__backup_count),
"etag" => Ok(__FieldTag::__etag),
"totalStoredBytes" => Ok(__FieldTag::__total_stored_bytes),
"total_stored_bytes" => Ok(__FieldTag::__total_stored_bytes),
"configState" => Ok(__FieldTag::__config_state),
"config_state" => Ok(__FieldTag::__config_state),
"backupConfigInfo" => Ok(__FieldTag::__backup_config_info),
"backup_config_info" => Ok(__FieldTag::__backup_config_info),
"dataSourceGcpResource" => Ok(__FieldTag::__data_source_gcp_resource),
"data_source_gcp_resource" => {
Ok(__FieldTag::__data_source_gcp_resource)
}
"dataSourceBackupApplianceApplication" => {
Ok(__FieldTag::__data_source_backup_appliance_application)
}
"data_source_backup_appliance_application" => {
Ok(__FieldTag::__data_source_backup_appliance_application)
}
"backupBlockedByVaultAccessRestriction" => {
Ok(__FieldTag::__backup_blocked_by_vault_access_restriction)
}
"backup_blocked_by_vault_access_restriction" => {
Ok(__FieldTag::__backup_blocked_by_vault_access_restriction)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__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::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::data_source::State>>()?.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::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__backup_count => {
if !fields.insert(__FieldTag::__backup_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_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.backup_count = map.next_value::<__With>()?.0;
}
__FieldTag::__etag => {
if !fields.insert(__FieldTag::__etag) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for etag",
));
}
result.etag =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__total_stored_bytes => {
if !fields.insert(__FieldTag::__total_stored_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_stored_bytes",
));
}
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.total_stored_bytes = map.next_value::<__With>()?.0;
}
__FieldTag::__config_state => {
if !fields.insert(__FieldTag::__config_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for config_state",
));
}
result.config_state = map
.next_value::<std::option::Option<crate::model::BackupConfigState>>(
)?
.unwrap_or_default();
}
__FieldTag::__backup_config_info => {
if !fields.insert(__FieldTag::__backup_config_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_config_info",
));
}
result.backup_config_info = map
.next_value::<std::option::Option<crate::model::BackupConfigInfo>>(
)?;
}
__FieldTag::__data_source_gcp_resource => {
if !fields.insert(__FieldTag::__data_source_gcp_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_gcp_resource",
));
}
if result.source_resource.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source_resource`, a oneof with full ID .google.cloud.backupdr.v1.DataSource.data_source_gcp_resource, latest field was dataSourceGcpResource",
));
}
result.source_resource = std::option::Option::Some(
crate::model::data_source::SourceResource::DataSourceGcpResource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::DataSourceGcpResource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__data_source_backup_appliance_application => {
if !fields
.insert(__FieldTag::__data_source_backup_appliance_application)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_backup_appliance_application",
));
}
if result.source_resource.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source_resource`, a oneof with full ID .google.cloud.backupdr.v1.DataSource.data_source_backup_appliance_application, latest field was dataSourceBackupApplianceApplication",
));
}
result.source_resource = std::option::Option::Some(
crate::model::data_source::SourceResource::DataSourceBackupApplianceApplication(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::DataSourceBackupApplianceApplication>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__backup_blocked_by_vault_access_restriction => {
if !fields
.insert(__FieldTag::__backup_blocked_by_vault_access_restriction)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_blocked_by_vault_access_restriction",
));
}
result.backup_blocked_by_vault_access_restriction = 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::BackupConfigInfo {
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 {
__last_backup_state,
__last_successful_backup_consistency_time,
__last_backup_error,
__gcp_backup_config,
__backup_appliance_backup_config,
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 BackupConfigInfo")
}
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 {
"lastBackupState" => Ok(__FieldTag::__last_backup_state),
"last_backup_state" => Ok(__FieldTag::__last_backup_state),
"lastSuccessfulBackupConsistencyTime" => {
Ok(__FieldTag::__last_successful_backup_consistency_time)
}
"last_successful_backup_consistency_time" => {
Ok(__FieldTag::__last_successful_backup_consistency_time)
}
"lastBackupError" => Ok(__FieldTag::__last_backup_error),
"last_backup_error" => Ok(__FieldTag::__last_backup_error),
"gcpBackupConfig" => Ok(__FieldTag::__gcp_backup_config),
"gcp_backup_config" => Ok(__FieldTag::__gcp_backup_config),
"backupApplianceBackupConfig" => {
Ok(__FieldTag::__backup_appliance_backup_config)
}
"backup_appliance_backup_config" => {
Ok(__FieldTag::__backup_appliance_backup_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupConfigInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupConfigInfo")
}
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::__last_backup_state => {
if !fields.insert(__FieldTag::__last_backup_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_backup_state",
));
}
result.last_backup_state = map
.next_value::<std::option::Option<
crate::model::backup_config_info::LastBackupState,
>>()?
.unwrap_or_default();
}
__FieldTag::__last_successful_backup_consistency_time => {
if !fields.insert(__FieldTag::__last_successful_backup_consistency_time)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_successful_backup_consistency_time",
));
}
result.last_successful_backup_consistency_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__last_backup_error => {
if !fields.insert(__FieldTag::__last_backup_error) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_backup_error",
));
}
result.last_backup_error = map
.next_value::<std::option::Option<google_cloud_rpc::model::Status>>(
)?;
}
__FieldTag::__gcp_backup_config => {
if !fields.insert(__FieldTag::__gcp_backup_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_backup_config",
));
}
if result.backup_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_config`, a oneof with full ID .google.cloud.backupdr.v1.BackupConfigInfo.gcp_backup_config, latest field was gcpBackupConfig",
));
}
result.backup_config = std::option::Option::Some(
crate::model::backup_config_info::BackupConfig::GcpBackupConfig(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::GcpBackupConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__backup_appliance_backup_config => {
if !fields.insert(__FieldTag::__backup_appliance_backup_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_backup_config",
));
}
if result.backup_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_config`, a oneof with full ID .google.cloud.backupdr.v1.BackupConfigInfo.backup_appliance_backup_config, latest field was backupApplianceBackupConfig",
));
}
result.backup_config = std::option::Option::Some(
crate::model::backup_config_info::BackupConfig::BackupApplianceBackupConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::BackupApplianceBackupConfig>>>()?.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::GcpBackupConfig {
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 {
__backup_plan,
__backup_plan_description,
__backup_plan_association,
__backup_plan_rules,
__backup_plan_revision_name,
__backup_plan_revision_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GcpBackupConfig")
}
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 {
"backupPlan" => Ok(__FieldTag::__backup_plan),
"backup_plan" => Ok(__FieldTag::__backup_plan),
"backupPlanDescription" => Ok(__FieldTag::__backup_plan_description),
"backup_plan_description" => Ok(__FieldTag::__backup_plan_description),
"backupPlanAssociation" => Ok(__FieldTag::__backup_plan_association),
"backup_plan_association" => Ok(__FieldTag::__backup_plan_association),
"backupPlanRules" => Ok(__FieldTag::__backup_plan_rules),
"backup_plan_rules" => Ok(__FieldTag::__backup_plan_rules),
"backupPlanRevisionName" => Ok(__FieldTag::__backup_plan_revision_name),
"backup_plan_revision_name" => {
Ok(__FieldTag::__backup_plan_revision_name)
}
"backupPlanRevisionId" => Ok(__FieldTag::__backup_plan_revision_id),
"backup_plan_revision_id" => Ok(__FieldTag::__backup_plan_revision_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GcpBackupConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GcpBackupConfig")
}
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::__backup_plan => {
if !fields.insert(__FieldTag::__backup_plan) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan",
));
}
result.backup_plan = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_description => {
if !fields.insert(__FieldTag::__backup_plan_description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_description",
));
}
result.backup_plan_description = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_association => {
if !fields.insert(__FieldTag::__backup_plan_association) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_association",
));
}
result.backup_plan_association = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_rules => {
if !fields.insert(__FieldTag::__backup_plan_rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_rules",
));
}
result.backup_plan_rules = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__backup_plan_revision_name => {
if !fields.insert(__FieldTag::__backup_plan_revision_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_revision_name",
));
}
result.backup_plan_revision_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_revision_id => {
if !fields.insert(__FieldTag::__backup_plan_revision_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_revision_id",
));
}
result.backup_plan_revision_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BackupApplianceBackupConfig {
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 {
__backup_appliance_name,
__backup_appliance_id,
__sla_id,
__application_name,
__host_name,
__slt_name,
__slp_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 BackupApplianceBackupConfig")
}
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 {
"backupApplianceName" => Ok(__FieldTag::__backup_appliance_name),
"backup_appliance_name" => Ok(__FieldTag::__backup_appliance_name),
"backupApplianceId" => Ok(__FieldTag::__backup_appliance_id),
"backup_appliance_id" => Ok(__FieldTag::__backup_appliance_id),
"slaId" => Ok(__FieldTag::__sla_id),
"sla_id" => Ok(__FieldTag::__sla_id),
"applicationName" => Ok(__FieldTag::__application_name),
"application_name" => Ok(__FieldTag::__application_name),
"hostName" => Ok(__FieldTag::__host_name),
"host_name" => Ok(__FieldTag::__host_name),
"sltName" => Ok(__FieldTag::__slt_name),
"slt_name" => Ok(__FieldTag::__slt_name),
"slpName" => Ok(__FieldTag::__slp_name),
"slp_name" => Ok(__FieldTag::__slp_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupApplianceBackupConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupApplianceBackupConfig")
}
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::__backup_appliance_name => {
if !fields.insert(__FieldTag::__backup_appliance_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_name",
));
}
result.backup_appliance_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_appliance_id => {
if !fields.insert(__FieldTag::__backup_appliance_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_id",
));
}
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.backup_appliance_id =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__sla_id => {
if !fields.insert(__FieldTag::__sla_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sla_id",
));
}
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.sla_id = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__application_name => {
if !fields.insert(__FieldTag::__application_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for application_name",
));
}
result.application_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__host_name => {
if !fields.insert(__FieldTag::__host_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for host_name",
));
}
result.host_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__slt_name => {
if !fields.insert(__FieldTag::__slt_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for slt_name",
));
}
result.slt_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__slp_name => {
if !fields.insert(__FieldTag::__slp_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for slp_name",
));
}
result.slp_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::DataSourceGcpResource {
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 {
__gcp_resourcename,
__location,
__type,
__compute_instance_datasource_properties,
__cloud_sql_instance_datasource_properties,
__alloy_db_cluster_datasource_properties,
__disk_datasource_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 DataSourceGcpResource")
}
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 {
"gcpResourcename" => Ok(__FieldTag::__gcp_resourcename),
"gcp_resourcename" => Ok(__FieldTag::__gcp_resourcename),
"location" => Ok(__FieldTag::__location),
"type" => Ok(__FieldTag::__type),
"computeInstanceDatasourceProperties" => {
Ok(__FieldTag::__compute_instance_datasource_properties)
}
"compute_instance_datasource_properties" => {
Ok(__FieldTag::__compute_instance_datasource_properties)
}
"cloudSqlInstanceDatasourceProperties" => {
Ok(__FieldTag::__cloud_sql_instance_datasource_properties)
}
"cloud_sql_instance_datasource_properties" => {
Ok(__FieldTag::__cloud_sql_instance_datasource_properties)
}
"alloyDbClusterDatasourceProperties" => {
Ok(__FieldTag::__alloy_db_cluster_datasource_properties)
}
"alloy_db_cluster_datasource_properties" => {
Ok(__FieldTag::__alloy_db_cluster_datasource_properties)
}
"diskDatasourceProperties" => {
Ok(__FieldTag::__disk_datasource_properties)
}
"disk_datasource_properties" => {
Ok(__FieldTag::__disk_datasource_properties)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataSourceGcpResource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataSourceGcpResource")
}
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::__gcp_resourcename => {
if !fields.insert(__FieldTag::__gcp_resourcename) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_resourcename",
));
}
result.gcp_resourcename = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
result.location = map
.next_value::<std::option::Option<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::__compute_instance_datasource_properties => {
if !fields.insert(__FieldTag::__compute_instance_datasource_properties)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for compute_instance_datasource_properties",
));
}
if result.gcp_resource_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `gcp_resource_properties`, a oneof with full ID .google.cloud.backupdr.v1.DataSourceGcpResource.compute_instance_datasource_properties, latest field was computeInstanceDatasourceProperties",
));
}
result.gcp_resource_properties = std::option::Option::Some(
crate::model::data_source_gcp_resource::GcpResourceProperties::ComputeInstanceDatasourceProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::ComputeInstanceDataSourceProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__cloud_sql_instance_datasource_properties => {
if !fields
.insert(__FieldTag::__cloud_sql_instance_datasource_properties)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_sql_instance_datasource_properties",
));
}
if result.gcp_resource_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `gcp_resource_properties`, a oneof with full ID .google.cloud.backupdr.v1.DataSourceGcpResource.cloud_sql_instance_datasource_properties, latest field was cloudSqlInstanceDatasourceProperties",
));
}
result.gcp_resource_properties = std::option::Option::Some(
crate::model::data_source_gcp_resource::GcpResourceProperties::CloudSqlInstanceDatasourceProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::CloudSqlInstanceDataSourceProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__alloy_db_cluster_datasource_properties => {
if !fields.insert(__FieldTag::__alloy_db_cluster_datasource_properties)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alloy_db_cluster_datasource_properties",
));
}
if result.gcp_resource_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `gcp_resource_properties`, a oneof with full ID .google.cloud.backupdr.v1.DataSourceGcpResource.alloy_db_cluster_datasource_properties, latest field was alloyDbClusterDatasourceProperties",
));
}
result.gcp_resource_properties = std::option::Option::Some(
crate::model::data_source_gcp_resource::GcpResourceProperties::AlloyDbClusterDatasourceProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::AlloyDBClusterDataSourceProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__disk_datasource_properties => {
if !fields.insert(__FieldTag::__disk_datasource_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_datasource_properties",
));
}
if result.gcp_resource_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `gcp_resource_properties`, a oneof with full ID .google.cloud.backupdr.v1.DataSourceGcpResource.disk_datasource_properties, latest field was diskDatasourceProperties",
));
}
result.gcp_resource_properties = std::option::Option::Some(
crate::model::data_source_gcp_resource::GcpResourceProperties::DiskDatasourceProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::DiskDataSourceProperties>>>()?.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::DataSourceBackupApplianceApplication {
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 {
__application_name,
__backup_appliance,
__appliance_id,
__type,
__application_id,
__hostname,
__host_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DataSourceBackupApplianceApplication")
}
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 {
"applicationName" => Ok(__FieldTag::__application_name),
"application_name" => Ok(__FieldTag::__application_name),
"backupAppliance" => Ok(__FieldTag::__backup_appliance),
"backup_appliance" => Ok(__FieldTag::__backup_appliance),
"applianceId" => Ok(__FieldTag::__appliance_id),
"appliance_id" => Ok(__FieldTag::__appliance_id),
"type" => Ok(__FieldTag::__type),
"applicationId" => Ok(__FieldTag::__application_id),
"application_id" => Ok(__FieldTag::__application_id),
"hostname" => Ok(__FieldTag::__hostname),
"hostId" => Ok(__FieldTag::__host_id),
"host_id" => Ok(__FieldTag::__host_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataSourceBackupApplianceApplication;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataSourceBackupApplianceApplication")
}
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::__application_name => {
if !fields.insert(__FieldTag::__application_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for application_name",
));
}
result.application_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_appliance => {
if !fields.insert(__FieldTag::__backup_appliance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance",
));
}
result.backup_appliance = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__appliance_id => {
if !fields.insert(__FieldTag::__appliance_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for appliance_id",
));
}
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.appliance_id = map.next_value::<__With>()?.0.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::__application_id => {
if !fields.insert(__FieldTag::__application_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for application_id",
));
}
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.application_id =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__hostname => {
if !fields.insert(__FieldTag::__hostname) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hostname",
));
}
result.hostname = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__host_id => {
if !fields.insert(__FieldTag::__host_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for host_id",
));
}
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.host_id = 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::ServiceLockInfo {
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 {
__operation,
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 ServiceLockInfo")
}
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 {
"operation" => Ok(__FieldTag::__operation),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ServiceLockInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ServiceLockInfo")
}
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::__operation => {
if !fields.insert(__FieldTag::__operation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation",
));
}
result.operation = 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::BackupApplianceLockInfo {
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 {
__backup_appliance_id,
__backup_appliance_name,
__lock_reason,
__job_name,
__backup_image,
__sla_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BackupApplianceLockInfo")
}
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 {
"backupApplianceId" => Ok(__FieldTag::__backup_appliance_id),
"backup_appliance_id" => Ok(__FieldTag::__backup_appliance_id),
"backupApplianceName" => Ok(__FieldTag::__backup_appliance_name),
"backup_appliance_name" => Ok(__FieldTag::__backup_appliance_name),
"lockReason" => Ok(__FieldTag::__lock_reason),
"lock_reason" => Ok(__FieldTag::__lock_reason),
"jobName" => Ok(__FieldTag::__job_name),
"job_name" => Ok(__FieldTag::__job_name),
"backupImage" => Ok(__FieldTag::__backup_image),
"backup_image" => Ok(__FieldTag::__backup_image),
"slaId" => Ok(__FieldTag::__sla_id),
"sla_id" => Ok(__FieldTag::__sla_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupApplianceLockInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupApplianceLockInfo")
}
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::__backup_appliance_id => {
if !fields.insert(__FieldTag::__backup_appliance_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_id",
));
}
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.backup_appliance_id =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__backup_appliance_name => {
if !fields.insert(__FieldTag::__backup_appliance_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_name",
));
}
result.backup_appliance_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__lock_reason => {
if !fields.insert(__FieldTag::__lock_reason) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for lock_reason",
));
}
result.lock_reason = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__job_name => {
if !fields.insert(__FieldTag::__job_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_name",
));
}
if result.lock_source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `lock_source`, a oneof with full ID .google.cloud.backupdr.v1.BackupApplianceLockInfo.job_name, latest field was jobName",
));
}
result.lock_source = std::option::Option::Some(
crate::model::backup_appliance_lock_info::LockSource::JobName(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__backup_image => {
if !fields.insert(__FieldTag::__backup_image) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_image",
));
}
if result.lock_source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `lock_source`, a oneof with full ID .google.cloud.backupdr.v1.BackupApplianceLockInfo.backup_image, latest field was backupImage",
));
}
result.lock_source = std::option::Option::Some(
crate::model::backup_appliance_lock_info::LockSource::BackupImage(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__sla_id => {
if !fields.insert(__FieldTag::__sla_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sla_id",
));
}
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)
}
}
if result.lock_source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `lock_source`, a oneof with full ID .google.cloud.backupdr.v1.BackupApplianceLockInfo.sla_id, latest field was slaId",
));
}
result.lock_source = std::option::Option::Some(
crate::model::backup_appliance_lock_info::LockSource::SlaId(
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::BackupLock {
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 {
__lock_until_time,
__backup_appliance_lock_info,
__service_lock_info,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BackupLock")
}
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 {
"lockUntilTime" => Ok(__FieldTag::__lock_until_time),
"lock_until_time" => Ok(__FieldTag::__lock_until_time),
"backupApplianceLockInfo" => {
Ok(__FieldTag::__backup_appliance_lock_info)
}
"backup_appliance_lock_info" => {
Ok(__FieldTag::__backup_appliance_lock_info)
}
"serviceLockInfo" => Ok(__FieldTag::__service_lock_info),
"service_lock_info" => Ok(__FieldTag::__service_lock_info),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupLock;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupLock")
}
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::__lock_until_time => {
if !fields.insert(__FieldTag::__lock_until_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for lock_until_time",
));
}
result.lock_until_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__backup_appliance_lock_info => {
if !fields.insert(__FieldTag::__backup_appliance_lock_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_lock_info",
));
}
if result.client_lock_info.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `client_lock_info`, a oneof with full ID .google.cloud.backupdr.v1.BackupLock.backup_appliance_lock_info, latest field was backupApplianceLockInfo",
));
}
result.client_lock_info = std::option::Option::Some(
crate::model::backup_lock::ClientLockInfo::BackupApplianceLockInfo(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::BackupApplianceLockInfo>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__service_lock_info => {
if !fields.insert(__FieldTag::__service_lock_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_lock_info",
));
}
if result.client_lock_info.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `client_lock_info`, a oneof with full ID .google.cloud.backupdr.v1.BackupLock.service_lock_info, latest field was serviceLockInfo",
));
}
result.client_lock_info = std::option::Option::Some(
crate::model::backup_lock::ClientLockInfo::ServiceLockInfo(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::ServiceLockInfo>,
>>()?
.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::Backup {
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,
__create_time,
__update_time,
__labels,
__enforced_retention_end_time,
__backup_retention_inheritance,
__expire_time,
__consistency_time,
__etag,
__state,
__service_locks,
__backup_appliance_locks,
__compute_instance_backup_properties,
__cloud_sql_instance_backup_properties,
__backup_appliance_backup_properties,
__alloy_db_backup_properties,
__disk_backup_properties,
__backup_type,
__gcp_backup_plan_info,
__resource_size_bytes,
__satisfies_pzs,
__satisfies_pzi,
__gcp_resource,
__kms_key_versions,
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 Backup")
}
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),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"labels" => Ok(__FieldTag::__labels),
"enforcedRetentionEndTime" => {
Ok(__FieldTag::__enforced_retention_end_time)
}
"enforced_retention_end_time" => {
Ok(__FieldTag::__enforced_retention_end_time)
}
"backupRetentionInheritance" => {
Ok(__FieldTag::__backup_retention_inheritance)
}
"backup_retention_inheritance" => {
Ok(__FieldTag::__backup_retention_inheritance)
}
"expireTime" => Ok(__FieldTag::__expire_time),
"expire_time" => Ok(__FieldTag::__expire_time),
"consistencyTime" => Ok(__FieldTag::__consistency_time),
"consistency_time" => Ok(__FieldTag::__consistency_time),
"etag" => Ok(__FieldTag::__etag),
"state" => Ok(__FieldTag::__state),
"serviceLocks" => Ok(__FieldTag::__service_locks),
"service_locks" => Ok(__FieldTag::__service_locks),
"backupApplianceLocks" => Ok(__FieldTag::__backup_appliance_locks),
"backup_appliance_locks" => Ok(__FieldTag::__backup_appliance_locks),
"computeInstanceBackupProperties" => {
Ok(__FieldTag::__compute_instance_backup_properties)
}
"compute_instance_backup_properties" => {
Ok(__FieldTag::__compute_instance_backup_properties)
}
"cloudSqlInstanceBackupProperties" => {
Ok(__FieldTag::__cloud_sql_instance_backup_properties)
}
"cloud_sql_instance_backup_properties" => {
Ok(__FieldTag::__cloud_sql_instance_backup_properties)
}
"backupApplianceBackupProperties" => {
Ok(__FieldTag::__backup_appliance_backup_properties)
}
"backup_appliance_backup_properties" => {
Ok(__FieldTag::__backup_appliance_backup_properties)
}
"alloyDbBackupProperties" => {
Ok(__FieldTag::__alloy_db_backup_properties)
}
"alloy_db_backup_properties" => {
Ok(__FieldTag::__alloy_db_backup_properties)
}
"diskBackupProperties" => Ok(__FieldTag::__disk_backup_properties),
"disk_backup_properties" => Ok(__FieldTag::__disk_backup_properties),
"backupType" => Ok(__FieldTag::__backup_type),
"backup_type" => Ok(__FieldTag::__backup_type),
"gcpBackupPlanInfo" => Ok(__FieldTag::__gcp_backup_plan_info),
"gcp_backup_plan_info" => Ok(__FieldTag::__gcp_backup_plan_info),
"resourceSizeBytes" => Ok(__FieldTag::__resource_size_bytes),
"resource_size_bytes" => Ok(__FieldTag::__resource_size_bytes),
"satisfiesPzs" => Ok(__FieldTag::__satisfies_pzs),
"satisfies_pzs" => Ok(__FieldTag::__satisfies_pzs),
"satisfiesPzi" => Ok(__FieldTag::__satisfies_pzi),
"satisfies_pzi" => Ok(__FieldTag::__satisfies_pzi),
"gcpResource" => Ok(__FieldTag::__gcp_resource),
"gcp_resource" => Ok(__FieldTag::__gcp_resource),
"kmsKeyVersions" => Ok(__FieldTag::__kms_key_versions),
"kms_key_versions" => Ok(__FieldTag::__kms_key_versions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Backup;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Backup")
}
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>>()?;
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__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::__enforced_retention_end_time => {
if !fields.insert(__FieldTag::__enforced_retention_end_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enforced_retention_end_time",
));
}
result.enforced_retention_end_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__backup_retention_inheritance => {
if !fields.insert(__FieldTag::__backup_retention_inheritance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_retention_inheritance",
));
}
result.backup_retention_inheritance = map
.next_value::<std::option::Option<
crate::model::backup_vault::BackupRetentionInheritance,
>>()?;
}
__FieldTag::__expire_time => {
if !fields.insert(__FieldTag::__expire_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for expire_time",
));
}
result.expire_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__consistency_time => {
if !fields.insert(__FieldTag::__consistency_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for consistency_time",
));
}
result.consistency_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__etag => {
if !fields.insert(__FieldTag::__etag) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for etag",
));
}
result.etag =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map
.next_value::<std::option::Option<crate::model::backup::State>>()?
.unwrap_or_default();
}
__FieldTag::__service_locks => {
if !fields.insert(__FieldTag::__service_locks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_locks",
));
}
result.service_locks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::BackupLock>>>()?.unwrap_or_default();
}
__FieldTag::__backup_appliance_locks => {
if !fields.insert(__FieldTag::__backup_appliance_locks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_locks",
));
}
result.backup_appliance_locks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::BackupLock>>>()?.unwrap_or_default();
}
__FieldTag::__compute_instance_backup_properties => {
if !fields.insert(__FieldTag::__compute_instance_backup_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for compute_instance_backup_properties",
));
}
if result.backup_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_properties`, a oneof with full ID .google.cloud.backupdr.v1.Backup.compute_instance_backup_properties, latest field was computeInstanceBackupProperties",
));
}
result.backup_properties = std::option::Option::Some(
crate::model::backup::BackupProperties::ComputeInstanceBackupProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::ComputeInstanceBackupProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__cloud_sql_instance_backup_properties => {
if !fields.insert(__FieldTag::__cloud_sql_instance_backup_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_sql_instance_backup_properties",
));
}
if result.backup_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_properties`, a oneof with full ID .google.cloud.backupdr.v1.Backup.cloud_sql_instance_backup_properties, latest field was cloudSqlInstanceBackupProperties",
));
}
result.backup_properties = std::option::Option::Some(
crate::model::backup::BackupProperties::CloudSqlInstanceBackupProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::CloudSqlInstanceBackupProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__backup_appliance_backup_properties => {
if !fields.insert(__FieldTag::__backup_appliance_backup_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_appliance_backup_properties",
));
}
if result.backup_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_properties`, a oneof with full ID .google.cloud.backupdr.v1.Backup.backup_appliance_backup_properties, latest field was backupApplianceBackupProperties",
));
}
result.backup_properties = std::option::Option::Some(
crate::model::backup::BackupProperties::BackupApplianceBackupProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::BackupApplianceBackupProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__alloy_db_backup_properties => {
if !fields.insert(__FieldTag::__alloy_db_backup_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alloy_db_backup_properties",
));
}
if result.backup_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_properties`, a oneof with full ID .google.cloud.backupdr.v1.Backup.alloy_db_backup_properties, latest field was alloyDbBackupProperties",
));
}
result.backup_properties = std::option::Option::Some(
crate::model::backup::BackupProperties::AlloyDbBackupProperties(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::AlloyDbClusterBackupProperties,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__disk_backup_properties => {
if !fields.insert(__FieldTag::__disk_backup_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_backup_properties",
));
}
if result.backup_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `backup_properties`, a oneof with full ID .google.cloud.backupdr.v1.Backup.disk_backup_properties, latest field was diskBackupProperties",
));
}
result.backup_properties = std::option::Option::Some(
crate::model::backup::BackupProperties::DiskBackupProperties(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::DiskBackupProperties>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__backup_type => {
if !fields.insert(__FieldTag::__backup_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_type",
));
}
result.backup_type = map.next_value::<std::option::Option<crate::model::backup::BackupType>>()?.unwrap_or_default();
}
__FieldTag::__gcp_backup_plan_info => {
if !fields.insert(__FieldTag::__gcp_backup_plan_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_backup_plan_info",
));
}
if result.plan_info.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `plan_info`, a oneof with full ID .google.cloud.backupdr.v1.Backup.gcp_backup_plan_info, latest field was gcpBackupPlanInfo",
));
}
result.plan_info = std::option::Option::Some(
crate::model::backup::PlanInfo::GcpBackupPlanInfo(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::backup::GCPBackupPlanInfo>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__resource_size_bytes => {
if !fields.insert(__FieldTag::__resource_size_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_size_bytes",
));
}
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.resource_size_bytes =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__satisfies_pzs => {
if !fields.insert(__FieldTag::__satisfies_pzs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for satisfies_pzs",
));
}
result.satisfies_pzs = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__satisfies_pzi => {
if !fields.insert(__FieldTag::__satisfies_pzi) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for satisfies_pzi",
));
}
result.satisfies_pzi = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__gcp_resource => {
if !fields.insert(__FieldTag::__gcp_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_resource",
));
}
if result.source_resource.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source_resource`, a oneof with full ID .google.cloud.backupdr.v1.Backup.gcp_resource, latest field was gcpResource",
));
}
result.source_resource = std::option::Option::Some(
crate::model::backup::SourceResource::GcpResource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::BackupGcpResource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__kms_key_versions => {
if !fields.insert(__FieldTag::__kms_key_versions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_versions",
));
}
result.kms_key_versions = 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::backup::GCPBackupPlanInfo {
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 {
__backup_plan,
__backup_plan_rule_id,
__backup_plan_revision_name,
__backup_plan_revision_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GCPBackupPlanInfo")
}
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 {
"backupPlan" => Ok(__FieldTag::__backup_plan),
"backup_plan" => Ok(__FieldTag::__backup_plan),
"backupPlanRuleId" => Ok(__FieldTag::__backup_plan_rule_id),
"backup_plan_rule_id" => Ok(__FieldTag::__backup_plan_rule_id),
"backupPlanRevisionName" => Ok(__FieldTag::__backup_plan_revision_name),
"backup_plan_revision_name" => {
Ok(__FieldTag::__backup_plan_revision_name)
}
"backupPlanRevisionId" => Ok(__FieldTag::__backup_plan_revision_id),
"backup_plan_revision_id" => Ok(__FieldTag::__backup_plan_revision_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::backup::GCPBackupPlanInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GCPBackupPlanInfo")
}
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::__backup_plan => {
if !fields.insert(__FieldTag::__backup_plan) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan",
));
}
result.backup_plan = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_rule_id => {
if !fields.insert(__FieldTag::__backup_plan_rule_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_rule_id",
));
}
result.backup_plan_rule_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_revision_name => {
if !fields.insert(__FieldTag::__backup_plan_revision_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_revision_name",
));
}
result.backup_plan_revision_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_plan_revision_id => {
if !fields.insert(__FieldTag::__backup_plan_revision_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_plan_revision_id",
));
}
result.backup_plan_revision_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateBackupVaultRequest {
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 {
__parent,
__backup_vault_id,
__backup_vault,
__request_id,
__validate_only,
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 CreateBackupVaultRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"backupVaultId" => Ok(__FieldTag::__backup_vault_id),
"backup_vault_id" => Ok(__FieldTag::__backup_vault_id),
"backupVault" => Ok(__FieldTag::__backup_vault),
"backup_vault" => Ok(__FieldTag::__backup_vault),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"validateOnly" => Ok(__FieldTag::__validate_only),
"validate_only" => Ok(__FieldTag::__validate_only),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateBackupVaultRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateBackupVaultRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_vault_id => {
if !fields.insert(__FieldTag::__backup_vault_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vault_id",
));
}
result.backup_vault_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_vault => {
if !fields.insert(__FieldTag::__backup_vault) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vault",
));
}
result.backup_vault =
map.next_value::<std::option::Option<crate::model::BackupVault>>()?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__validate_only => {
if !fields.insert(__FieldTag::__validate_only) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for validate_only",
));
}
result.validate_only = 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::ListBackupVaultsRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
__view,
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 ListBackupVaultsRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
"view" => Ok(__FieldTag::__view),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupVaultsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupVaultsRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__view => {
if !fields.insert(__FieldTag::__view) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for view",
));
}
result.view = map
.next_value::<std::option::Option<crate::model::BackupVaultView>>()?
.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::ListBackupVaultsResponse {
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 {
__backup_vaults,
__next_page_token,
__unreachable,
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 ListBackupVaultsResponse")
}
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 {
"backupVaults" => Ok(__FieldTag::__backup_vaults),
"backup_vaults" => Ok(__FieldTag::__backup_vaults),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupVaultsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupVaultsResponse")
}
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::__backup_vaults => {
if !fields.insert(__FieldTag::__backup_vaults) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vaults",
));
}
result.backup_vaults = map.next_value::<std::option::Option<std::vec::Vec<crate::model::BackupVault>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::FetchUsableBackupVaultsRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
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 FetchUsableBackupVaultsRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchUsableBackupVaultsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchUsableBackupVaultsRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = 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::FetchUsableBackupVaultsResponse {
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 {
__backup_vaults,
__next_page_token,
__unreachable,
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 FetchUsableBackupVaultsResponse")
}
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 {
"backupVaults" => Ok(__FieldTag::__backup_vaults),
"backup_vaults" => Ok(__FieldTag::__backup_vaults),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchUsableBackupVaultsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchUsableBackupVaultsResponse")
}
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::__backup_vaults => {
if !fields.insert(__FieldTag::__backup_vaults) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vaults",
));
}
result.backup_vaults = map.next_value::<std::option::Option<std::vec::Vec<crate::model::BackupVault>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::FetchBackupsForResourceTypeRequest {
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 {
__parent,
__resource_type,
__page_size,
__page_token,
__filter,
__order_by,
__view,
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 FetchBackupsForResourceTypeRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"resourceType" => Ok(__FieldTag::__resource_type),
"resource_type" => Ok(__FieldTag::__resource_type),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
"view" => Ok(__FieldTag::__view),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchBackupsForResourceTypeRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchBackupsForResourceTypeRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = 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::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__view => {
if !fields.insert(__FieldTag::__view) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for view",
));
}
result.view = map
.next_value::<std::option::Option<crate::model::BackupView>>()?
.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::FetchBackupsForResourceTypeResponse {
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 {
__backups,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FetchBackupsForResourceTypeResponse")
}
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 {
"backups" => Ok(__FieldTag::__backups),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchBackupsForResourceTypeResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchBackupsForResourceTypeResponse")
}
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::__backups => {
if !fields.insert(__FieldTag::__backups) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backups",
));
}
result.backups = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Backup>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetBackupVaultRequest {
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,
__view,
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 GetBackupVaultRequest")
}
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),
"view" => Ok(__FieldTag::__view),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetBackupVaultRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetBackupVaultRequest")
}
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::__view => {
if !fields.insert(__FieldTag::__view) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for view",
));
}
result.view = map
.next_value::<std::option::Option<crate::model::BackupVaultView>>()?
.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::UpdateBackupVaultRequest {
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 {
__update_mask,
__backup_vault,
__request_id,
__validate_only,
__force,
__force_update_access_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 UpdateBackupVaultRequest")
}
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 {
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
"backupVault" => Ok(__FieldTag::__backup_vault),
"backup_vault" => Ok(__FieldTag::__backup_vault),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"validateOnly" => Ok(__FieldTag::__validate_only),
"validate_only" => Ok(__FieldTag::__validate_only),
"force" => Ok(__FieldTag::__force),
"forceUpdateAccessRestriction" => {
Ok(__FieldTag::__force_update_access_restriction)
}
"force_update_access_restriction" => {
Ok(__FieldTag::__force_update_access_restriction)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateBackupVaultRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateBackupVaultRequest")
}
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::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::__backup_vault => {
if !fields.insert(__FieldTag::__backup_vault) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vault",
));
}
result.backup_vault =
map.next_value::<std::option::Option<crate::model::BackupVault>>()?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__validate_only => {
if !fields.insert(__FieldTag::__validate_only) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for validate_only",
));
}
result.validate_only = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__force => {
if !fields.insert(__FieldTag::__force) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for force",
));
}
result.force = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__force_update_access_restriction => {
if !fields.insert(__FieldTag::__force_update_access_restriction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for force_update_access_restriction",
));
}
result.force_update_access_restriction = 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::DeleteBackupVaultRequest {
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,
__request_id,
__force,
__etag,
__validate_only,
__allow_missing,
__ignore_backup_plan_references,
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 DeleteBackupVaultRequest")
}
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),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"force" => Ok(__FieldTag::__force),
"etag" => Ok(__FieldTag::__etag),
"validateOnly" => Ok(__FieldTag::__validate_only),
"validate_only" => Ok(__FieldTag::__validate_only),
"allowMissing" => Ok(__FieldTag::__allow_missing),
"allow_missing" => Ok(__FieldTag::__allow_missing),
"ignoreBackupPlanReferences" => {
Ok(__FieldTag::__ignore_backup_plan_references)
}
"ignore_backup_plan_references" => {
Ok(__FieldTag::__ignore_backup_plan_references)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteBackupVaultRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteBackupVaultRequest")
}
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::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__force => {
if !fields.insert(__FieldTag::__force) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for force",
));
}
result.force = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__etag => {
if !fields.insert(__FieldTag::__etag) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for etag",
));
}
result.etag = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__validate_only => {
if !fields.insert(__FieldTag::__validate_only) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for validate_only",
));
}
result.validate_only = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__allow_missing => {
if !fields.insert(__FieldTag::__allow_missing) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_missing",
));
}
result.allow_missing = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_backup_plan_references => {
if !fields.insert(__FieldTag::__ignore_backup_plan_references) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_backup_plan_references",
));
}
result.ignore_backup_plan_references = 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::ListDataSourcesRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
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 ListDataSourcesRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDataSourcesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDataSourcesRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = 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::ListDataSourcesResponse {
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 {
__data_sources,
__next_page_token,
__unreachable,
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 ListDataSourcesResponse")
}
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 {
"dataSources" => Ok(__FieldTag::__data_sources),
"data_sources" => Ok(__FieldTag::__data_sources),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDataSourcesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDataSourcesResponse")
}
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::__data_sources => {
if !fields.insert(__FieldTag::__data_sources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_sources",
));
}
result.data_sources = map.next_value::<std::option::Option<std::vec::Vec<crate::model::DataSource>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::GetDataSourceRequest {
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,
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 GetDataSourceRequest")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetDataSourceRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetDataSourceRequest")
}
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::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::UpdateDataSourceRequest {
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 {
__update_mask,
__data_source,
__request_id,
__allow_missing,
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 UpdateDataSourceRequest")
}
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 {
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
"dataSource" => Ok(__FieldTag::__data_source),
"data_source" => Ok(__FieldTag::__data_source),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"allowMissing" => Ok(__FieldTag::__allow_missing),
"allow_missing" => Ok(__FieldTag::__allow_missing),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateDataSourceRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateDataSourceRequest")
}
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::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::__data_source => {
if !fields.insert(__FieldTag::__data_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source",
));
}
result.data_source =
map.next_value::<std::option::Option<crate::model::DataSource>>()?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__allow_missing => {
if !fields.insert(__FieldTag::__allow_missing) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_missing",
));
}
result.allow_missing = 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::ListBackupsRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
__view,
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 ListBackupsRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
"view" => Ok(__FieldTag::__view),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupsRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__view => {
if !fields.insert(__FieldTag::__view) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for view",
));
}
result.view = map
.next_value::<std::option::Option<crate::model::BackupView>>()?
.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::ListBackupsResponse {
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 {
__backups,
__next_page_token,
__unreachable,
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 ListBackupsResponse")
}
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 {
"backups" => Ok(__FieldTag::__backups),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListBackupsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBackupsResponse")
}
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::__backups => {
if !fields.insert(__FieldTag::__backups) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backups",
));
}
result.backups = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Backup>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::GetBackupRequest {
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,
__view,
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 GetBackupRequest")
}
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),
"view" => Ok(__FieldTag::__view),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetBackupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetBackupRequest")
}
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::__view => {
if !fields.insert(__FieldTag::__view) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for view",
));
}
result.view = map
.next_value::<std::option::Option<crate::model::BackupView>>()?
.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::UpdateBackupRequest {
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 {
__update_mask,
__backup,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateBackupRequest")
}
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 {
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
"backup" => Ok(__FieldTag::__backup),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateBackupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateBackupRequest")
}
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::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::__backup => {
if !fields.insert(__FieldTag::__backup) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup",
));
}
result.backup =
map.next_value::<std::option::Option<crate::model::Backup>>()?;
}
__FieldTag::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteBackupRequest {
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,
__request_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteBackupRequest")
}
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),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteBackupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteBackupRequest")
}
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::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RestoreBackupRequest {
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,
__request_id,
__compute_instance_target_environment,
__disk_target_environment,
__region_disk_target_environment,
__compute_instance_restore_properties,
__disk_restore_properties,
__clear_overrides_field_mask,
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 RestoreBackupRequest")
}
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),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"computeInstanceTargetEnvironment" => {
Ok(__FieldTag::__compute_instance_target_environment)
}
"compute_instance_target_environment" => {
Ok(__FieldTag::__compute_instance_target_environment)
}
"diskTargetEnvironment" => Ok(__FieldTag::__disk_target_environment),
"disk_target_environment" => Ok(__FieldTag::__disk_target_environment),
"regionDiskTargetEnvironment" => {
Ok(__FieldTag::__region_disk_target_environment)
}
"region_disk_target_environment" => {
Ok(__FieldTag::__region_disk_target_environment)
}
"computeInstanceRestoreProperties" => {
Ok(__FieldTag::__compute_instance_restore_properties)
}
"compute_instance_restore_properties" => {
Ok(__FieldTag::__compute_instance_restore_properties)
}
"diskRestoreProperties" => Ok(__FieldTag::__disk_restore_properties),
"disk_restore_properties" => Ok(__FieldTag::__disk_restore_properties),
"clearOverridesFieldMask" => {
Ok(__FieldTag::__clear_overrides_field_mask)
}
"clear_overrides_field_mask" => {
Ok(__FieldTag::__clear_overrides_field_mask)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RestoreBackupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RestoreBackupRequest")
}
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::__request_id => {
if !fields.insert(__FieldTag::__request_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for request_id",
));
}
result.request_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__compute_instance_target_environment => {
if !fields.insert(__FieldTag::__compute_instance_target_environment) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for compute_instance_target_environment",
));
}
if result.target_environment.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `target_environment`, a oneof with full ID .google.cloud.backupdr.v1.RestoreBackupRequest.compute_instance_target_environment, latest field was computeInstanceTargetEnvironment",
));
}
result.target_environment = std::option::Option::Some(
crate::model::restore_backup_request::TargetEnvironment::ComputeInstanceTargetEnvironment(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::ComputeInstanceTargetEnvironment>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__disk_target_environment => {
if !fields.insert(__FieldTag::__disk_target_environment) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_target_environment",
));
}
if result.target_environment.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `target_environment`, a oneof with full ID .google.cloud.backupdr.v1.RestoreBackupRequest.disk_target_environment, latest field was diskTargetEnvironment",
));
}
result.target_environment = std::option::Option::Some(
crate::model::restore_backup_request::TargetEnvironment::DiskTargetEnvironment(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::DiskTargetEnvironment>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__region_disk_target_environment => {
if !fields.insert(__FieldTag::__region_disk_target_environment) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for region_disk_target_environment",
));
}
if result.target_environment.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `target_environment`, a oneof with full ID .google.cloud.backupdr.v1.RestoreBackupRequest.region_disk_target_environment, latest field was regionDiskTargetEnvironment",
));
}
result.target_environment = std::option::Option::Some(
crate::model::restore_backup_request::TargetEnvironment::RegionDiskTargetEnvironment(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::RegionDiskTargetEnvironment>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__compute_instance_restore_properties => {
if !fields.insert(__FieldTag::__compute_instance_restore_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for compute_instance_restore_properties",
));
}
if result.instance_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `instance_properties`, a oneof with full ID .google.cloud.backupdr.v1.RestoreBackupRequest.compute_instance_restore_properties, latest field was computeInstanceRestoreProperties",
));
}
result.instance_properties = std::option::Option::Some(
crate::model::restore_backup_request::InstanceProperties::ComputeInstanceRestoreProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::ComputeInstanceRestoreProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__disk_restore_properties => {
if !fields.insert(__FieldTag::__disk_restore_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_restore_properties",
));
}
if result.instance_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `instance_properties`, a oneof with full ID .google.cloud.backupdr.v1.RestoreBackupRequest.disk_restore_properties, latest field was diskRestoreProperties",
));
}
result.instance_properties = std::option::Option::Some(
crate::model::restore_backup_request::InstanceProperties::DiskRestoreProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::DiskRestoreProperties>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__clear_overrides_field_mask => {
if !fields.insert(__FieldTag::__clear_overrides_field_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for clear_overrides_field_mask",
));
}
result.clear_overrides_field_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__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::RestoreBackupResponse {
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 {
__target_resource,
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 RestoreBackupResponse")
}
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 {
"targetResource" => Ok(__FieldTag::__target_resource),
"target_resource" => Ok(__FieldTag::__target_resource),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RestoreBackupResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RestoreBackupResponse")
}
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::__target_resource => {
if !fields.insert(__FieldTag::__target_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_resource",
));
}
result.target_resource = map
.next_value::<std::option::Option<crate::model::TargetResource>>(
)?;
}
__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::TargetResource {
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 {
__gcp_resource,
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 TargetResource")
}
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 {
"gcpResource" => Ok(__FieldTag::__gcp_resource),
"gcp_resource" => Ok(__FieldTag::__gcp_resource),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TargetResource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TargetResource")
}
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::__gcp_resource => {
if !fields.insert(__FieldTag::__gcp_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_resource",
));
}
if result.target_resource_info.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `target_resource_info`, a oneof with full ID .google.cloud.backupdr.v1.TargetResource.gcp_resource, latest field was gcpResource",
));
}
result.target_resource_info = std::option::Option::Some(
crate::model::target_resource::TargetResourceInfo::GcpResource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::GcpResource>,
>>()?
.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::GcpResource {
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 {
__gcp_resourcename,
__location,
__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 GcpResource")
}
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 {
"gcpResourcename" => Ok(__FieldTag::__gcp_resourcename),
"gcp_resourcename" => Ok(__FieldTag::__gcp_resourcename),
"location" => Ok(__FieldTag::__location),
"type" => Ok(__FieldTag::__type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GcpResource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GcpResource")
}
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::__gcp_resourcename => {
if !fields.insert(__FieldTag::__gcp_resourcename) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_resourcename",
));
}
result.gcp_resourcename = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
result.location = map
.next_value::<std::option::Option<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::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::BackupGcpResource {
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 {
__gcp_resourcename,
__location,
__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 BackupGcpResource")
}
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 {
"gcpResourcename" => Ok(__FieldTag::__gcp_resourcename),
"gcp_resourcename" => Ok(__FieldTag::__gcp_resourcename),
"location" => Ok(__FieldTag::__location),
"type" => Ok(__FieldTag::__type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupGcpResource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupGcpResource")
}
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::__gcp_resourcename => {
if !fields.insert(__FieldTag::__gcp_resourcename) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_resourcename",
));
}
result.gcp_resourcename = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
result.location = map
.next_value::<std::option::Option<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::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::AlloyDBClusterDataSourceProperties {
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,
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 AlloyDBClusterDataSourceProperties")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AlloyDBClusterDataSourceProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AlloyDBClusterDataSourceProperties")
}
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::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::AlloyDbClusterBackupProperties {
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,
__stored_bytes,
__chain_id,
__database_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 AlloyDbClusterBackupProperties")
}
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),
"storedBytes" => Ok(__FieldTag::__stored_bytes),
"stored_bytes" => Ok(__FieldTag::__stored_bytes),
"chainId" => Ok(__FieldTag::__chain_id),
"chain_id" => Ok(__FieldTag::__chain_id),
"databaseVersion" => Ok(__FieldTag::__database_version),
"database_version" => Ok(__FieldTag::__database_version),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AlloyDbClusterBackupProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AlloyDbClusterBackupProperties")
}
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>>()?;
}
__FieldTag::__stored_bytes => {
if !fields.insert(__FieldTag::__stored_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for stored_bytes",
));
}
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.stored_bytes = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__chain_id => {
if !fields.insert(__FieldTag::__chain_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chain_id",
));
}
result.chain_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__database_version => {
if !fields.insert(__FieldTag::__database_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_version",
));
}
result.database_version = 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::AlloyDBClusterBackupPlanAssociationProperties {
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 {
__cluster_uid,
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 AlloyDBClusterBackupPlanAssociationProperties",
)
}
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 {
"clusterUid" => Ok(__FieldTag::__cluster_uid),
"cluster_uid" => Ok(__FieldTag::__cluster_uid),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AlloyDBClusterBackupPlanAssociationProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AlloyDBClusterBackupPlanAssociationProperties")
}
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::__cluster_uid => {
if !fields.insert(__FieldTag::__cluster_uid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uid",
));
}
result.cluster_uid = 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::BackupApplianceBackupProperties {
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 {
__generation_id,
__finalize_time,
__recovery_range_start_time,
__recovery_range_end_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BackupApplianceBackupProperties")
}
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 {
"generationId" => Ok(__FieldTag::__generation_id),
"generation_id" => Ok(__FieldTag::__generation_id),
"finalizeTime" => Ok(__FieldTag::__finalize_time),
"finalize_time" => Ok(__FieldTag::__finalize_time),
"recoveryRangeStartTime" => Ok(__FieldTag::__recovery_range_start_time),
"recovery_range_start_time" => {
Ok(__FieldTag::__recovery_range_start_time)
}
"recoveryRangeEndTime" => Ok(__FieldTag::__recovery_range_end_time),
"recovery_range_end_time" => Ok(__FieldTag::__recovery_range_end_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupApplianceBackupProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupApplianceBackupProperties")
}
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::__generation_id => {
if !fields.insert(__FieldTag::__generation_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for generation_id",
));
}
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.generation_id = map.next_value::<__With>()?.0;
}
__FieldTag::__finalize_time => {
if !fields.insert(__FieldTag::__finalize_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for finalize_time",
));
}
result.finalize_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__recovery_range_start_time => {
if !fields.insert(__FieldTag::__recovery_range_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for recovery_range_start_time",
));
}
result.recovery_range_start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__recovery_range_end_time => {
if !fields.insert(__FieldTag::__recovery_range_end_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for recovery_range_end_time",
));
}
result.recovery_range_end_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CloudSqlInstanceDataSourceProperties {
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,
__database_installed_version,
__instance_create_time,
__instance_tier,
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 CloudSqlInstanceDataSourceProperties")
}
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),
"databaseInstalledVersion" => {
Ok(__FieldTag::__database_installed_version)
}
"database_installed_version" => {
Ok(__FieldTag::__database_installed_version)
}
"instanceCreateTime" => Ok(__FieldTag::__instance_create_time),
"instance_create_time" => Ok(__FieldTag::__instance_create_time),
"instanceTier" => Ok(__FieldTag::__instance_tier),
"instance_tier" => Ok(__FieldTag::__instance_tier),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CloudSqlInstanceDataSourceProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CloudSqlInstanceDataSourceProperties")
}
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::__database_installed_version => {
if !fields.insert(__FieldTag::__database_installed_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_installed_version",
));
}
result.database_installed_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_create_time => {
if !fields.insert(__FieldTag::__instance_create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_create_time",
));
}
result.instance_create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__instance_tier => {
if !fields.insert(__FieldTag::__instance_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_tier",
));
}
result.instance_tier = 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::CloudSqlInstanceBackupProperties {
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 {
__database_installed_version,
__final_backup,
__source_instance,
__instance_create_time,
__instance_tier,
__instance_delete_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CloudSqlInstanceBackupProperties")
}
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 {
"databaseInstalledVersion" => {
Ok(__FieldTag::__database_installed_version)
}
"database_installed_version" => {
Ok(__FieldTag::__database_installed_version)
}
"finalBackup" => Ok(__FieldTag::__final_backup),
"final_backup" => Ok(__FieldTag::__final_backup),
"sourceInstance" => Ok(__FieldTag::__source_instance),
"source_instance" => Ok(__FieldTag::__source_instance),
"instanceCreateTime" => Ok(__FieldTag::__instance_create_time),
"instance_create_time" => Ok(__FieldTag::__instance_create_time),
"instanceTier" => Ok(__FieldTag::__instance_tier),
"instance_tier" => Ok(__FieldTag::__instance_tier),
"instanceDeleteTime" => Ok(__FieldTag::__instance_delete_time),
"instance_delete_time" => Ok(__FieldTag::__instance_delete_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CloudSqlInstanceBackupProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CloudSqlInstanceBackupProperties")
}
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::__database_installed_version => {
if !fields.insert(__FieldTag::__database_installed_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_installed_version",
));
}
result.database_installed_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__final_backup => {
if !fields.insert(__FieldTag::__final_backup) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for final_backup",
));
}
result.final_backup = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__source_instance => {
if !fields.insert(__FieldTag::__source_instance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source_instance",
));
}
result.source_instance = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_create_time => {
if !fields.insert(__FieldTag::__instance_create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_create_time",
));
}
result.instance_create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__instance_tier => {
if !fields.insert(__FieldTag::__instance_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_tier",
));
}
result.instance_tier = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_delete_time => {
if !fields.insert(__FieldTag::__instance_delete_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_delete_time",
));
}
result.instance_delete_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CloudSqlInstanceDataSourceReferenceProperties {
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,
__database_installed_version,
__instance_create_time,
__instance_tier,
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 CloudSqlInstanceDataSourceReferenceProperties",
)
}
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),
"databaseInstalledVersion" => {
Ok(__FieldTag::__database_installed_version)
}
"database_installed_version" => {
Ok(__FieldTag::__database_installed_version)
}
"instanceCreateTime" => Ok(__FieldTag::__instance_create_time),
"instance_create_time" => Ok(__FieldTag::__instance_create_time),
"instanceTier" => Ok(__FieldTag::__instance_tier),
"instance_tier" => Ok(__FieldTag::__instance_tier),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CloudSqlInstanceDataSourceReferenceProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CloudSqlInstanceDataSourceReferenceProperties")
}
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::__database_installed_version => {
if !fields.insert(__FieldTag::__database_installed_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_installed_version",
));
}
result.database_installed_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_create_time => {
if !fields.insert(__FieldTag::__instance_create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_create_time",
));
}
result.instance_create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__instance_tier => {
if !fields.insert(__FieldTag::__instance_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_tier",
));
}
result.instance_tier = 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::CloudSqlInstanceInitializationConfig {
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 {
__edition,
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 CloudSqlInstanceInitializationConfig")
}
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 {
"edition" => Ok(__FieldTag::__edition),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CloudSqlInstanceInitializationConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CloudSqlInstanceInitializationConfig")
}
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::__edition => {
if !fields.insert(__FieldTag::__edition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for edition",
));
}
result.edition = map
.next_value::<std::option::Option<
crate::model::cloud_sql_instance_initialization_config::Edition,
>>()?
.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::CloudSqlInstanceBackupPlanAssociationProperties {
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 {
__instance_create_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str(
"a field name for CloudSqlInstanceBackupPlanAssociationProperties",
)
}
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 {
"instanceCreateTime" => Ok(__FieldTag::__instance_create_time),
"instance_create_time" => Ok(__FieldTag::__instance_create_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CloudSqlInstanceBackupPlanAssociationProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CloudSqlInstanceBackupPlanAssociationProperties")
}
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::__instance_create_time => {
if !fields.insert(__FieldTag::__instance_create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_create_time",
));
}
result.instance_create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DiskTargetEnvironment {
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 {
__project,
__zone,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DiskTargetEnvironment")
}
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 {
"project" => Ok(__FieldTag::__project),
"zone" => Ok(__FieldTag::__zone),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DiskTargetEnvironment;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DiskTargetEnvironment")
}
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::__project => {
if !fields.insert(__FieldTag::__project) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project",
));
}
result.project = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__zone => {
if !fields.insert(__FieldTag::__zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for zone",
));
}
result.zone = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RegionDiskTargetEnvironment {
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 {
__project,
__region,
__replica_zones,
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 RegionDiskTargetEnvironment")
}
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 {
"project" => Ok(__FieldTag::__project),
"region" => Ok(__FieldTag::__region),
"replicaZones" => Ok(__FieldTag::__replica_zones),
"replica_zones" => Ok(__FieldTag::__replica_zones),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RegionDiskTargetEnvironment;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RegionDiskTargetEnvironment")
}
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::__project => {
if !fields.insert(__FieldTag::__project) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project",
));
}
result.project = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__region => {
if !fields.insert(__FieldTag::__region) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for region",
));
}
result.region = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__replica_zones => {
if !fields.insert(__FieldTag::__replica_zones) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for replica_zones",
));
}
result.replica_zones = 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::DiskRestoreProperties {
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,
__size_gb,
__licenses,
__guest_os_feature,
__disk_encryption_key,
__physical_block_size_bytes,
__provisioned_iops,
__provisioned_throughput,
__enable_confidential_compute,
__storage_pool,
__access_mode,
__architecture,
__resource_policy,
__type,
__labels,
__resource_manager_tags,
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 DiskRestoreProperties")
}
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),
"sizeGb" => Ok(__FieldTag::__size_gb),
"size_gb" => Ok(__FieldTag::__size_gb),
"licenses" => Ok(__FieldTag::__licenses),
"guestOsFeature" => Ok(__FieldTag::__guest_os_feature),
"guest_os_feature" => Ok(__FieldTag::__guest_os_feature),
"diskEncryptionKey" => Ok(__FieldTag::__disk_encryption_key),
"disk_encryption_key" => Ok(__FieldTag::__disk_encryption_key),
"physicalBlockSizeBytes" => Ok(__FieldTag::__physical_block_size_bytes),
"physical_block_size_bytes" => {
Ok(__FieldTag::__physical_block_size_bytes)
}
"provisionedIops" => Ok(__FieldTag::__provisioned_iops),
"provisioned_iops" => Ok(__FieldTag::__provisioned_iops),
"provisionedThroughput" => Ok(__FieldTag::__provisioned_throughput),
"provisioned_throughput" => Ok(__FieldTag::__provisioned_throughput),
"enableConfidentialCompute" => {
Ok(__FieldTag::__enable_confidential_compute)
}
"enable_confidential_compute" => {
Ok(__FieldTag::__enable_confidential_compute)
}
"storagePool" => Ok(__FieldTag::__storage_pool),
"storage_pool" => Ok(__FieldTag::__storage_pool),
"accessMode" => Ok(__FieldTag::__access_mode),
"access_mode" => Ok(__FieldTag::__access_mode),
"architecture" => Ok(__FieldTag::__architecture),
"resourcePolicy" => Ok(__FieldTag::__resource_policy),
"resource_policy" => Ok(__FieldTag::__resource_policy),
"type" => Ok(__FieldTag::__type),
"labels" => Ok(__FieldTag::__labels),
"resourceManagerTags" => Ok(__FieldTag::__resource_manager_tags),
"resource_manager_tags" => Ok(__FieldTag::__resource_manager_tags),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DiskRestoreProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DiskRestoreProperties")
}
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>>()?;
}
__FieldTag::__description => {
if !fields.insert(__FieldTag::__description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for description",
));
}
result.description =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__size_gb => {
if !fields.insert(__FieldTag::__size_gb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for size_gb",
));
}
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.size_gb = map.next_value::<__With>()?.0;
}
__FieldTag::__licenses => {
if !fields.insert(__FieldTag::__licenses) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for licenses",
));
}
result.licenses = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__guest_os_feature => {
if !fields.insert(__FieldTag::__guest_os_feature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for guest_os_feature",
));
}
result.guest_os_feature =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::GuestOsFeature>,
>>()?
.unwrap_or_default();
}
__FieldTag::__disk_encryption_key => {
if !fields.insert(__FieldTag::__disk_encryption_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_encryption_key",
));
}
result.disk_encryption_key = map.next_value::<std::option::Option<crate::model::CustomerEncryptionKey>>()?
;
}
__FieldTag::__physical_block_size_bytes => {
if !fields.insert(__FieldTag::__physical_block_size_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for physical_block_size_bytes",
));
}
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.physical_block_size_bytes = map.next_value::<__With>()?.0;
}
__FieldTag::__provisioned_iops => {
if !fields.insert(__FieldTag::__provisioned_iops) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provisioned_iops",
));
}
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.provisioned_iops = map.next_value::<__With>()?.0;
}
__FieldTag::__provisioned_throughput => {
if !fields.insert(__FieldTag::__provisioned_throughput) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provisioned_throughput",
));
}
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.provisioned_throughput = map.next_value::<__With>()?.0;
}
__FieldTag::__enable_confidential_compute => {
if !fields.insert(__FieldTag::__enable_confidential_compute) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_confidential_compute",
));
}
result.enable_confidential_compute =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__storage_pool => {
if !fields.insert(__FieldTag::__storage_pool) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for storage_pool",
));
}
result.storage_pool =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__access_mode => {
if !fields.insert(__FieldTag::__access_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for access_mode",
));
}
result.access_mode = map.next_value::<std::option::Option<
crate::model::disk_restore_properties::AccessMode,
>>()?;
}
__FieldTag::__architecture => {
if !fields.insert(__FieldTag::__architecture) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for architecture",
));
}
result.architecture = map.next_value::<std::option::Option<
crate::model::disk_restore_properties::Architecture,
>>()?;
}
__FieldTag::__resource_policy => {
if !fields.insert(__FieldTag::__resource_policy) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_policy",
));
}
result.resource_policy = map.next_value::<std::option::Option<std::vec::Vec<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>>()?;
}
__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::__resource_manager_tags => {
if !fields.insert(__FieldTag::__resource_manager_tags) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_manager_tags",
));
}
result.resource_manager_tags = 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::DiskBackupProperties {
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,
__licenses,
__guest_os_feature,
__architecture,
__type,
__size_gb,
__region,
__zone,
__replica_zones,
__source_disk,
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 DiskBackupProperties")
}
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),
"licenses" => Ok(__FieldTag::__licenses),
"guestOsFeature" => Ok(__FieldTag::__guest_os_feature),
"guest_os_feature" => Ok(__FieldTag::__guest_os_feature),
"architecture" => Ok(__FieldTag::__architecture),
"type" => Ok(__FieldTag::__type),
"sizeGb" => Ok(__FieldTag::__size_gb),
"size_gb" => Ok(__FieldTag::__size_gb),
"region" => Ok(__FieldTag::__region),
"zone" => Ok(__FieldTag::__zone),
"replicaZones" => Ok(__FieldTag::__replica_zones),
"replica_zones" => Ok(__FieldTag::__replica_zones),
"sourceDisk" => Ok(__FieldTag::__source_disk),
"source_disk" => Ok(__FieldTag::__source_disk),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DiskBackupProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DiskBackupProperties")
}
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>>()?;
}
__FieldTag::__licenses => {
if !fields.insert(__FieldTag::__licenses) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for licenses",
));
}
result.licenses = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__guest_os_feature => {
if !fields.insert(__FieldTag::__guest_os_feature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for guest_os_feature",
));
}
result.guest_os_feature =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::GuestOsFeature>,
>>()?
.unwrap_or_default();
}
__FieldTag::__architecture => {
if !fields.insert(__FieldTag::__architecture) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for architecture",
));
}
result.architecture = map.next_value::<std::option::Option<
crate::model::disk_backup_properties::Architecture,
>>()?;
}
__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>>()?;
}
__FieldTag::__size_gb => {
if !fields.insert(__FieldTag::__size_gb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for size_gb",
));
}
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.size_gb = map.next_value::<__With>()?.0;
}
__FieldTag::__region => {
if !fields.insert(__FieldTag::__region) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for region",
));
}
result.region =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__zone => {
if !fields.insert(__FieldTag::__zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for zone",
));
}
result.zone =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__replica_zones => {
if !fields.insert(__FieldTag::__replica_zones) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for replica_zones",
));
}
result.replica_zones = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__source_disk => {
if !fields.insert(__FieldTag::__source_disk) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source_disk",
));
}
result.source_disk =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DiskDataSourceProperties {
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,
__type,
__size_gb,
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 DiskDataSourceProperties")
}
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),
"type" => Ok(__FieldTag::__type),
"sizeGb" => Ok(__FieldTag::__size_gb),
"size_gb" => Ok(__FieldTag::__size_gb),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DiskDataSourceProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DiskDataSourceProperties")
}
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::__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::__size_gb => {
if !fields.insert(__FieldTag::__size_gb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for size_gb",
));
}
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.size_gb = 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::ComputeInstanceBackupProperties {
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,
__tags,
__machine_type,
__can_ip_forward,
__network_interface,
__disk,
__metadata,
__service_account,
__scheduling,
__guest_accelerator,
__min_cpu_platform,
__key_revocation_action_type,
__source_instance,
__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 ComputeInstanceBackupProperties")
}
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),
"tags" => Ok(__FieldTag::__tags),
"machineType" => Ok(__FieldTag::__machine_type),
"machine_type" => Ok(__FieldTag::__machine_type),
"canIpForward" => Ok(__FieldTag::__can_ip_forward),
"can_ip_forward" => Ok(__FieldTag::__can_ip_forward),
"networkInterface" => Ok(__FieldTag::__network_interface),
"network_interface" => Ok(__FieldTag::__network_interface),
"disk" => Ok(__FieldTag::__disk),
"metadata" => Ok(__FieldTag::__metadata),
"serviceAccount" => Ok(__FieldTag::__service_account),
"service_account" => Ok(__FieldTag::__service_account),
"scheduling" => Ok(__FieldTag::__scheduling),
"guestAccelerator" => Ok(__FieldTag::__guest_accelerator),
"guest_accelerator" => Ok(__FieldTag::__guest_accelerator),
"minCpuPlatform" => Ok(__FieldTag::__min_cpu_platform),
"min_cpu_platform" => Ok(__FieldTag::__min_cpu_platform),
"keyRevocationActionType" => {
Ok(__FieldTag::__key_revocation_action_type)
}
"key_revocation_action_type" => {
Ok(__FieldTag::__key_revocation_action_type)
}
"sourceInstance" => Ok(__FieldTag::__source_instance),
"source_instance" => Ok(__FieldTag::__source_instance),
"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::ComputeInstanceBackupProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ComputeInstanceBackupProperties")
}
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>>()?;
}
__FieldTag::__tags => {
if !fields.insert(__FieldTag::__tags) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tags",
));
}
result.tags =
map.next_value::<std::option::Option<crate::model::Tags>>()?;
}
__FieldTag::__machine_type => {
if !fields.insert(__FieldTag::__machine_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for machine_type",
));
}
result.machine_type =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__can_ip_forward => {
if !fields.insert(__FieldTag::__can_ip_forward) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for can_ip_forward",
));
}
result.can_ip_forward =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__network_interface => {
if !fields.insert(__FieldTag::__network_interface) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_interface",
));
}
result.network_interface =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::NetworkInterface>,
>>()?
.unwrap_or_default();
}
__FieldTag::__disk => {
if !fields.insert(__FieldTag::__disk) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk",
));
}
result.disk = map.next_value::<std::option::Option<std::vec::Vec<crate::model::AttachedDisk>>>()?.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::Metadata>>()?;
}
__FieldTag::__service_account => {
if !fields.insert(__FieldTag::__service_account) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_account",
));
}
result.service_account =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::ServiceAccount>,
>>()?
.unwrap_or_default();
}
__FieldTag::__scheduling => {
if !fields.insert(__FieldTag::__scheduling) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scheduling",
));
}
result.scheduling =
map.next_value::<std::option::Option<crate::model::Scheduling>>()?;
}
__FieldTag::__guest_accelerator => {
if !fields.insert(__FieldTag::__guest_accelerator) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for guest_accelerator",
));
}
result.guest_accelerator =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::AcceleratorConfig>,
>>()?
.unwrap_or_default();
}
__FieldTag::__min_cpu_platform => {
if !fields.insert(__FieldTag::__min_cpu_platform) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_cpu_platform",
));
}
result.min_cpu_platform =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__key_revocation_action_type => {
if !fields.insert(__FieldTag::__key_revocation_action_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key_revocation_action_type",
));
}
result.key_revocation_action_type = map.next_value::<std::option::Option<crate::model::KeyRevocationActionType>>()?
;
}
__FieldTag::__source_instance => {
if !fields.insert(__FieldTag::__source_instance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source_instance",
));
}
result.source_instance =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__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::ComputeInstanceRestoreProperties {
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,
__advanced_machine_features,
__can_ip_forward,
__confidential_instance_config,
__deletion_protection,
__description,
__disks,
__display_device,
__guest_accelerators,
__hostname,
__instance_encryption_key,
__key_revocation_action_type,
__labels,
__machine_type,
__metadata,
__min_cpu_platform,
__network_interfaces,
__network_performance_config,
__params,
__private_ipv6_google_access,
__allocation_affinity,
__resource_policies,
__scheduling,
__service_accounts,
__tags,
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 ComputeInstanceRestoreProperties")
}
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),
"advancedMachineFeatures" => {
Ok(__FieldTag::__advanced_machine_features)
}
"advanced_machine_features" => {
Ok(__FieldTag::__advanced_machine_features)
}
"canIpForward" => Ok(__FieldTag::__can_ip_forward),
"can_ip_forward" => Ok(__FieldTag::__can_ip_forward),
"confidentialInstanceConfig" => {
Ok(__FieldTag::__confidential_instance_config)
}
"confidential_instance_config" => {
Ok(__FieldTag::__confidential_instance_config)
}
"deletionProtection" => Ok(__FieldTag::__deletion_protection),
"deletion_protection" => Ok(__FieldTag::__deletion_protection),
"description" => Ok(__FieldTag::__description),
"disks" => Ok(__FieldTag::__disks),
"displayDevice" => Ok(__FieldTag::__display_device),
"display_device" => Ok(__FieldTag::__display_device),
"guestAccelerators" => Ok(__FieldTag::__guest_accelerators),
"guest_accelerators" => Ok(__FieldTag::__guest_accelerators),
"hostname" => Ok(__FieldTag::__hostname),
"instanceEncryptionKey" => Ok(__FieldTag::__instance_encryption_key),
"instance_encryption_key" => Ok(__FieldTag::__instance_encryption_key),
"keyRevocationActionType" => {
Ok(__FieldTag::__key_revocation_action_type)
}
"key_revocation_action_type" => {
Ok(__FieldTag::__key_revocation_action_type)
}
"labels" => Ok(__FieldTag::__labels),
"machineType" => Ok(__FieldTag::__machine_type),
"machine_type" => Ok(__FieldTag::__machine_type),
"metadata" => Ok(__FieldTag::__metadata),
"minCpuPlatform" => Ok(__FieldTag::__min_cpu_platform),
"min_cpu_platform" => Ok(__FieldTag::__min_cpu_platform),
"networkInterfaces" => Ok(__FieldTag::__network_interfaces),
"network_interfaces" => Ok(__FieldTag::__network_interfaces),
"networkPerformanceConfig" => {
Ok(__FieldTag::__network_performance_config)
}
"network_performance_config" => {
Ok(__FieldTag::__network_performance_config)
}
"params" => Ok(__FieldTag::__params),
"privateIpv6GoogleAccess" => {
Ok(__FieldTag::__private_ipv6_google_access)
}
"private_ipv6_google_access" => {
Ok(__FieldTag::__private_ipv6_google_access)
}
"reservationAffinity" => Ok(__FieldTag::__allocation_affinity),
"allocation_affinity" => Ok(__FieldTag::__allocation_affinity),
"resourcePolicies" => Ok(__FieldTag::__resource_policies),
"resource_policies" => Ok(__FieldTag::__resource_policies),
"scheduling" => Ok(__FieldTag::__scheduling),
"serviceAccounts" => Ok(__FieldTag::__service_accounts),
"service_accounts" => Ok(__FieldTag::__service_accounts),
"tags" => Ok(__FieldTag::__tags),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ComputeInstanceRestoreProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ComputeInstanceRestoreProperties")
}
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>>()?;
}
__FieldTag::__advanced_machine_features => {
if !fields.insert(__FieldTag::__advanced_machine_features) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for advanced_machine_features",
));
}
result.advanced_machine_features = map.next_value::<std::option::Option<crate::model::AdvancedMachineFeatures>>()?
;
}
__FieldTag::__can_ip_forward => {
if !fields.insert(__FieldTag::__can_ip_forward) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for can_ip_forward",
));
}
result.can_ip_forward =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__confidential_instance_config => {
if !fields.insert(__FieldTag::__confidential_instance_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for confidential_instance_config",
));
}
result.confidential_instance_config = map.next_value::<std::option::Option<crate::model::ConfidentialInstanceConfig>>()?
;
}
__FieldTag::__deletion_protection => {
if !fields.insert(__FieldTag::__deletion_protection) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for deletion_protection",
));
}
result.deletion_protection =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__description => {
if !fields.insert(__FieldTag::__description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for description",
));
}
result.description =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__disks => {
if !fields.insert(__FieldTag::__disks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disks",
));
}
result.disks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::AttachedDisk>>>()?.unwrap_or_default();
}
__FieldTag::__display_device => {
if !fields.insert(__FieldTag::__display_device) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_device",
));
}
result.display_device = map
.next_value::<std::option::Option<crate::model::DisplayDevice>>()?;
}
__FieldTag::__guest_accelerators => {
if !fields.insert(__FieldTag::__guest_accelerators) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for guest_accelerators",
));
}
result.guest_accelerators =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::AcceleratorConfig>,
>>()?
.unwrap_or_default();
}
__FieldTag::__hostname => {
if !fields.insert(__FieldTag::__hostname) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hostname",
));
}
result.hostname =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__instance_encryption_key => {
if !fields.insert(__FieldTag::__instance_encryption_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_encryption_key",
));
}
result.instance_encryption_key = map.next_value::<std::option::Option<crate::model::CustomerEncryptionKey>>()?
;
}
__FieldTag::__key_revocation_action_type => {
if !fields.insert(__FieldTag::__key_revocation_action_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key_revocation_action_type",
));
}
result.key_revocation_action_type = map.next_value::<std::option::Option<crate::model::KeyRevocationActionType>>()?
;
}
__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::__machine_type => {
if !fields.insert(__FieldTag::__machine_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for machine_type",
));
}
result.machine_type =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__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::Metadata>>()?;
}
__FieldTag::__min_cpu_platform => {
if !fields.insert(__FieldTag::__min_cpu_platform) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_cpu_platform",
));
}
result.min_cpu_platform =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__network_interfaces => {
if !fields.insert(__FieldTag::__network_interfaces) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_interfaces",
));
}
result.network_interfaces =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::NetworkInterface>,
>>()?
.unwrap_or_default();
}
__FieldTag::__network_performance_config => {
if !fields.insert(__FieldTag::__network_performance_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_performance_config",
));
}
result.network_performance_config = map.next_value::<std::option::Option<crate::model::NetworkPerformanceConfig>>()?
;
}
__FieldTag::__params => {
if !fields.insert(__FieldTag::__params) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for params",
));
}
result.params = map
.next_value::<std::option::Option<crate::model::InstanceParams>>(
)?;
}
__FieldTag::__private_ipv6_google_access => {
if !fields.insert(__FieldTag::__private_ipv6_google_access) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for private_ipv6_google_access",
));
}
result.private_ipv6_google_access = map.next_value::<std::option::Option<crate::model::compute_instance_restore_properties::InstancePrivateIpv6GoogleAccess>>()?
;
}
__FieldTag::__allocation_affinity => {
if !fields.insert(__FieldTag::__allocation_affinity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allocation_affinity",
));
}
result.allocation_affinity = map.next_value::<std::option::Option<crate::model::AllocationAffinity>>()?
;
}
__FieldTag::__resource_policies => {
if !fields.insert(__FieldTag::__resource_policies) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_policies",
));
}
result.resource_policies = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__scheduling => {
if !fields.insert(__FieldTag::__scheduling) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scheduling",
));
}
result.scheduling =
map.next_value::<std::option::Option<crate::model::Scheduling>>()?;
}
__FieldTag::__service_accounts => {
if !fields.insert(__FieldTag::__service_accounts) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_accounts",
));
}
result.service_accounts =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::ServiceAccount>,
>>()?
.unwrap_or_default();
}
__FieldTag::__tags => {
if !fields.insert(__FieldTag::__tags) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tags",
));
}
result.tags =
map.next_value::<std::option::Option<crate::model::Tags>>()?;
}
__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::ComputeInstanceTargetEnvironment {
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 {
__project,
__zone,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ComputeInstanceTargetEnvironment")
}
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 {
"project" => Ok(__FieldTag::__project),
"zone" => Ok(__FieldTag::__zone),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ComputeInstanceTargetEnvironment;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ComputeInstanceTargetEnvironment")
}
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::__project => {
if !fields.insert(__FieldTag::__project) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project",
));
}
result.project = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__zone => {
if !fields.insert(__FieldTag::__zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for zone",
));
}
result.zone = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ComputeInstanceDataSourceProperties {
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,
__machine_type,
__total_disk_count,
__total_disk_size_gb,
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 ComputeInstanceDataSourceProperties")
}
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),
"machineType" => Ok(__FieldTag::__machine_type),
"machine_type" => Ok(__FieldTag::__machine_type),
"totalDiskCount" => Ok(__FieldTag::__total_disk_count),
"total_disk_count" => Ok(__FieldTag::__total_disk_count),
"totalDiskSizeGb" => Ok(__FieldTag::__total_disk_size_gb),
"total_disk_size_gb" => Ok(__FieldTag::__total_disk_size_gb),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ComputeInstanceDataSourceProperties;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ComputeInstanceDataSourceProperties")
}
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::__machine_type => {
if !fields.insert(__FieldTag::__machine_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for machine_type",
));
}
result.machine_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__total_disk_count => {
if !fields.insert(__FieldTag::__total_disk_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_disk_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.total_disk_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__total_disk_size_gb => {
if !fields.insert(__FieldTag::__total_disk_size_gb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_disk_size_gb",
));
}
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.total_disk_size_gb =
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::AdvancedMachineFeatures {
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 {
__enable_nested_virtualization,
__threads_per_core,
__visible_core_count,
__enable_uefi_networking,
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 AdvancedMachineFeatures")
}
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 {
"enableNestedVirtualization" => {
Ok(__FieldTag::__enable_nested_virtualization)
}
"enable_nested_virtualization" => {
Ok(__FieldTag::__enable_nested_virtualization)
}
"threadsPerCore" => Ok(__FieldTag::__threads_per_core),
"threads_per_core" => Ok(__FieldTag::__threads_per_core),
"visibleCoreCount" => Ok(__FieldTag::__visible_core_count),
"visible_core_count" => Ok(__FieldTag::__visible_core_count),
"enableUefiNetworking" => Ok(__FieldTag::__enable_uefi_networking),
"enable_uefi_networking" => Ok(__FieldTag::__enable_uefi_networking),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AdvancedMachineFeatures;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AdvancedMachineFeatures")
}
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::__enable_nested_virtualization => {
if !fields.insert(__FieldTag::__enable_nested_virtualization) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_nested_virtualization",
));
}
result.enable_nested_virtualization =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__threads_per_core => {
if !fields.insert(__FieldTag::__threads_per_core) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for threads_per_core",
));
}
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.threads_per_core = map.next_value::<__With>()?.0;
}
__FieldTag::__visible_core_count => {
if !fields.insert(__FieldTag::__visible_core_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for visible_core_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.visible_core_count = map.next_value::<__With>()?.0;
}
__FieldTag::__enable_uefi_networking => {
if !fields.insert(__FieldTag::__enable_uefi_networking) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_uefi_networking",
));
}
result.enable_uefi_networking =
map.next_value::<std::option::Option<bool>>()?;
}
__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::ConfidentialInstanceConfig {
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 {
__enable_confidential_compute,
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 ConfidentialInstanceConfig")
}
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 {
"enableConfidentialCompute" => {
Ok(__FieldTag::__enable_confidential_compute)
}
"enable_confidential_compute" => {
Ok(__FieldTag::__enable_confidential_compute)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ConfidentialInstanceConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ConfidentialInstanceConfig")
}
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::__enable_confidential_compute => {
if !fields.insert(__FieldTag::__enable_confidential_compute) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_confidential_compute",
));
}
result.enable_confidential_compute =
map.next_value::<std::option::Option<bool>>()?;
}
__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::DisplayDevice {
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 {
__enable_display,
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 DisplayDevice")
}
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 {
"enableDisplay" => Ok(__FieldTag::__enable_display),
"enable_display" => Ok(__FieldTag::__enable_display),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DisplayDevice;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DisplayDevice")
}
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::__enable_display => {
if !fields.insert(__FieldTag::__enable_display) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_display",
));
}
result.enable_display =
map.next_value::<std::option::Option<bool>>()?;
}
__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::AcceleratorConfig {
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 {
__accelerator_type,
__accelerator_count,
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 AcceleratorConfig")
}
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 {
"acceleratorType" => Ok(__FieldTag::__accelerator_type),
"accelerator_type" => Ok(__FieldTag::__accelerator_type),
"acceleratorCount" => Ok(__FieldTag::__accelerator_count),
"accelerator_count" => Ok(__FieldTag::__accelerator_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AcceleratorConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AcceleratorConfig")
}
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::__accelerator_type => {
if !fields.insert(__FieldTag::__accelerator_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for accelerator_type",
));
}
result.accelerator_type =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__accelerator_count => {
if !fields.insert(__FieldTag::__accelerator_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for accelerator_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.accelerator_count = 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::CustomerEncryptionKey {
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 {
__raw_key,
__rsa_encrypted_key,
__kms_key_name,
__kms_key_service_account,
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 CustomerEncryptionKey")
}
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 {
"rawKey" => Ok(__FieldTag::__raw_key),
"raw_key" => Ok(__FieldTag::__raw_key),
"rsaEncryptedKey" => Ok(__FieldTag::__rsa_encrypted_key),
"rsa_encrypted_key" => Ok(__FieldTag::__rsa_encrypted_key),
"kmsKeyName" => Ok(__FieldTag::__kms_key_name),
"kms_key_name" => Ok(__FieldTag::__kms_key_name),
"kmsKeyServiceAccount" => Ok(__FieldTag::__kms_key_service_account),
"kms_key_service_account" => Ok(__FieldTag::__kms_key_service_account),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CustomerEncryptionKey;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CustomerEncryptionKey")
}
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::__raw_key => {
if !fields.insert(__FieldTag::__raw_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for raw_key",
));
}
if result.key.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `key`, a oneof with full ID .google.cloud.backupdr.v1.CustomerEncryptionKey.raw_key, latest field was rawKey",
));
}
result.key = std::option::Option::Some(
crate::model::customer_encryption_key::Key::RawKey(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__rsa_encrypted_key => {
if !fields.insert(__FieldTag::__rsa_encrypted_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rsa_encrypted_key",
));
}
if result.key.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `key`, a oneof with full ID .google.cloud.backupdr.v1.CustomerEncryptionKey.rsa_encrypted_key, latest field was rsaEncryptedKey",
));
}
result.key = std::option::Option::Some(
crate::model::customer_encryption_key::Key::RsaEncryptedKey(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__kms_key_name => {
if !fields.insert(__FieldTag::__kms_key_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_name",
));
}
if result.key.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `key`, a oneof with full ID .google.cloud.backupdr.v1.CustomerEncryptionKey.kms_key_name, latest field was kmsKeyName",
));
}
result.key = std::option::Option::Some(
crate::model::customer_encryption_key::Key::KmsKeyName(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__kms_key_service_account => {
if !fields.insert(__FieldTag::__kms_key_service_account) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_service_account",
));
}
result.kms_key_service_account =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Entry {
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,
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 Entry")
}
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),
"value" => Ok(__FieldTag::__value),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Entry;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Entry")
}
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>>()?;
}
__FieldTag::__value => {
if !fields.insert(__FieldTag::__value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value",
));
}
result.value =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Metadata {
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 {
__items,
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 Metadata")
}
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 {
"items" => Ok(__FieldTag::__items),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Metadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Metadata")
}
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::__items => {
if !fields.insert(__FieldTag::__items) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for items",
));
}
result.items = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Entry>>>()?.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::NetworkInterface {
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 {
__network,
__subnetwork,
__ip_address,
__ipv6_address,
__internal_ipv6_prefix_length,
__name,
__access_configs,
__ipv6_access_configs,
__alias_ip_ranges,
__stack_type,
__ipv6_access_type,
__queue_count,
__nic_type,
__network_attachment,
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 NetworkInterface")
}
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 {
"network" => Ok(__FieldTag::__network),
"subnetwork" => Ok(__FieldTag::__subnetwork),
"networkIP" => Ok(__FieldTag::__ip_address),
"ip_address" => Ok(__FieldTag::__ip_address),
"ipv6Address" => Ok(__FieldTag::__ipv6_address),
"ipv6_address" => Ok(__FieldTag::__ipv6_address),
"internalIpv6PrefixLength" => {
Ok(__FieldTag::__internal_ipv6_prefix_length)
}
"internal_ipv6_prefix_length" => {
Ok(__FieldTag::__internal_ipv6_prefix_length)
}
"name" => Ok(__FieldTag::__name),
"accessConfigs" => Ok(__FieldTag::__access_configs),
"access_configs" => Ok(__FieldTag::__access_configs),
"ipv6AccessConfigs" => Ok(__FieldTag::__ipv6_access_configs),
"ipv6_access_configs" => Ok(__FieldTag::__ipv6_access_configs),
"aliasIpRanges" => Ok(__FieldTag::__alias_ip_ranges),
"alias_ip_ranges" => Ok(__FieldTag::__alias_ip_ranges),
"stackType" => Ok(__FieldTag::__stack_type),
"stack_type" => Ok(__FieldTag::__stack_type),
"ipv6AccessType" => Ok(__FieldTag::__ipv6_access_type),
"ipv6_access_type" => Ok(__FieldTag::__ipv6_access_type),
"queueCount" => Ok(__FieldTag::__queue_count),
"queue_count" => Ok(__FieldTag::__queue_count),
"nicType" => Ok(__FieldTag::__nic_type),
"nic_type" => Ok(__FieldTag::__nic_type),
"networkAttachment" => Ok(__FieldTag::__network_attachment),
"network_attachment" => Ok(__FieldTag::__network_attachment),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NetworkInterface;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NetworkInterface")
}
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::__network => {
if !fields.insert(__FieldTag::__network) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network",
));
}
result.network =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__subnetwork => {
if !fields.insert(__FieldTag::__subnetwork) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subnetwork",
));
}
result.subnetwork =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__ip_address => {
if !fields.insert(__FieldTag::__ip_address) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ip_address",
));
}
result.ip_address =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__ipv6_address => {
if !fields.insert(__FieldTag::__ipv6_address) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ipv6_address",
));
}
result.ipv6_address =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__internal_ipv6_prefix_length => {
if !fields.insert(__FieldTag::__internal_ipv6_prefix_length) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for internal_ipv6_prefix_length",
));
}
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.internal_ipv6_prefix_length = map.next_value::<__With>()?.0;
}
__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>>()?;
}
__FieldTag::__access_configs => {
if !fields.insert(__FieldTag::__access_configs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for access_configs",
));
}
result.access_configs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::AccessConfig>>>()?.unwrap_or_default();
}
__FieldTag::__ipv6_access_configs => {
if !fields.insert(__FieldTag::__ipv6_access_configs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ipv6_access_configs",
));
}
result.ipv6_access_configs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::AccessConfig>>>()?.unwrap_or_default();
}
__FieldTag::__alias_ip_ranges => {
if !fields.insert(__FieldTag::__alias_ip_ranges) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alias_ip_ranges",
));
}
result.alias_ip_ranges = map.next_value::<std::option::Option<std::vec::Vec<crate::model::AliasIpRange>>>()?.unwrap_or_default();
}
__FieldTag::__stack_type => {
if !fields.insert(__FieldTag::__stack_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for stack_type",
));
}
result.stack_type = map.next_value::<std::option::Option<crate::model::network_interface::StackType>>()?
;
}
__FieldTag::__ipv6_access_type => {
if !fields.insert(__FieldTag::__ipv6_access_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ipv6_access_type",
));
}
result.ipv6_access_type = map.next_value::<std::option::Option<
crate::model::network_interface::Ipv6AccessType,
>>()?;
}
__FieldTag::__queue_count => {
if !fields.insert(__FieldTag::__queue_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for queue_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.queue_count = map.next_value::<__With>()?.0;
}
__FieldTag::__nic_type => {
if !fields.insert(__FieldTag::__nic_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for nic_type",
));
}
result.nic_type = map.next_value::<std::option::Option<crate::model::network_interface::NicType>>()?
;
}
__FieldTag::__network_attachment => {
if !fields.insert(__FieldTag::__network_attachment) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_attachment",
));
}
result.network_attachment =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::NetworkPerformanceConfig {
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 {
__total_egress_bandwidth_tier,
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 NetworkPerformanceConfig")
}
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 {
"totalEgressBandwidthTier" => {
Ok(__FieldTag::__total_egress_bandwidth_tier)
}
"total_egress_bandwidth_tier" => {
Ok(__FieldTag::__total_egress_bandwidth_tier)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NetworkPerformanceConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NetworkPerformanceConfig")
}
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::__total_egress_bandwidth_tier => {
if !fields.insert(__FieldTag::__total_egress_bandwidth_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_egress_bandwidth_tier",
));
}
result.total_egress_bandwidth_tier = map
.next_value::<std::option::Option<
crate::model::network_performance_config::Tier,
>>()?;
}
__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::AccessConfig {
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,
__external_ip,
__external_ipv6,
__external_ipv6_prefix_length,
__set_public_ptr,
__public_ptr_domain_name,
__network_tier,
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 AccessConfig")
}
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),
"name" => Ok(__FieldTag::__name),
"natIP" => Ok(__FieldTag::__external_ip),
"external_ip" => Ok(__FieldTag::__external_ip),
"externalIpv6" => Ok(__FieldTag::__external_ipv6),
"external_ipv6" => Ok(__FieldTag::__external_ipv6),
"externalIpv6PrefixLength" => {
Ok(__FieldTag::__external_ipv6_prefix_length)
}
"external_ipv6_prefix_length" => {
Ok(__FieldTag::__external_ipv6_prefix_length)
}
"setPublicPtr" => Ok(__FieldTag::__set_public_ptr),
"set_public_ptr" => Ok(__FieldTag::__set_public_ptr),
"publicPtrDomainName" => Ok(__FieldTag::__public_ptr_domain_name),
"public_ptr_domain_name" => Ok(__FieldTag::__public_ptr_domain_name),
"networkTier" => Ok(__FieldTag::__network_tier),
"network_tier" => Ok(__FieldTag::__network_tier),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AccessConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AccessConfig")
}
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<crate::model::access_config::AccessType>>()?
;
}
__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>>()?;
}
__FieldTag::__external_ip => {
if !fields.insert(__FieldTag::__external_ip) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for external_ip",
));
}
result.external_ip =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__external_ipv6 => {
if !fields.insert(__FieldTag::__external_ipv6) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for external_ipv6",
));
}
result.external_ipv6 =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__external_ipv6_prefix_length => {
if !fields.insert(__FieldTag::__external_ipv6_prefix_length) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for external_ipv6_prefix_length",
));
}
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.external_ipv6_prefix_length = map.next_value::<__With>()?.0;
}
__FieldTag::__set_public_ptr => {
if !fields.insert(__FieldTag::__set_public_ptr) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for set_public_ptr",
));
}
result.set_public_ptr =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__public_ptr_domain_name => {
if !fields.insert(__FieldTag::__public_ptr_domain_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for public_ptr_domain_name",
));
}
result.public_ptr_domain_name =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__network_tier => {
if !fields.insert(__FieldTag::__network_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_tier",
));
}
result.network_tier = map.next_value::<std::option::Option<crate::model::access_config::NetworkTier>>()?
;
}
__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::AliasIpRange {
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 {
__ip_cidr_range,
__subnetwork_range_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 AliasIpRange")
}
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 {
"ipCidrRange" => Ok(__FieldTag::__ip_cidr_range),
"ip_cidr_range" => Ok(__FieldTag::__ip_cidr_range),
"subnetworkRangeName" => Ok(__FieldTag::__subnetwork_range_name),
"subnetwork_range_name" => Ok(__FieldTag::__subnetwork_range_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AliasIpRange;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AliasIpRange")
}
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::__ip_cidr_range => {
if !fields.insert(__FieldTag::__ip_cidr_range) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ip_cidr_range",
));
}
result.ip_cidr_range =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__subnetwork_range_name => {
if !fields.insert(__FieldTag::__subnetwork_range_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subnetwork_range_name",
));
}
result.subnetwork_range_name =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::InstanceParams {
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 {
__resource_manager_tags,
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 InstanceParams")
}
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 {
"resourceManagerTags" => Ok(__FieldTag::__resource_manager_tags),
"resource_manager_tags" => Ok(__FieldTag::__resource_manager_tags),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InstanceParams;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstanceParams")
}
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::__resource_manager_tags => {
if !fields.insert(__FieldTag::__resource_manager_tags) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_manager_tags",
));
}
result.resource_manager_tags = 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::AllocationAffinity {
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 {
__consume_allocation_type,
__key,
__values,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AllocationAffinity")
}
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 {
"consumeReservationType" => Ok(__FieldTag::__consume_allocation_type),
"consume_allocation_type" => Ok(__FieldTag::__consume_allocation_type),
"key" => Ok(__FieldTag::__key),
"values" => Ok(__FieldTag::__values),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AllocationAffinity;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AllocationAffinity")
}
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::__consume_allocation_type => {
if !fields.insert(__FieldTag::__consume_allocation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for consume_allocation_type",
));
}
result.consume_allocation_type = map.next_value::<std::option::Option<crate::model::allocation_affinity::Type>>()?
;
}
__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>>()?;
}
__FieldTag::__values => {
if !fields.insert(__FieldTag::__values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for values",
));
}
result.values = 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::Scheduling {
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 {
__on_host_maintenance,
__automatic_restart,
__preemptible,
__node_affinities,
__min_node_cpus,
__provisioning_model,
__instance_termination_action,
__local_ssd_recovery_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 Scheduling")
}
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 {
"onHostMaintenance" => Ok(__FieldTag::__on_host_maintenance),
"on_host_maintenance" => Ok(__FieldTag::__on_host_maintenance),
"automaticRestart" => Ok(__FieldTag::__automatic_restart),
"automatic_restart" => Ok(__FieldTag::__automatic_restart),
"preemptible" => Ok(__FieldTag::__preemptible),
"nodeAffinities" => Ok(__FieldTag::__node_affinities),
"node_affinities" => Ok(__FieldTag::__node_affinities),
"minNodeCpus" => Ok(__FieldTag::__min_node_cpus),
"min_node_cpus" => Ok(__FieldTag::__min_node_cpus),
"provisioningModel" => Ok(__FieldTag::__provisioning_model),
"provisioning_model" => Ok(__FieldTag::__provisioning_model),
"instanceTerminationAction" => {
Ok(__FieldTag::__instance_termination_action)
}
"instance_termination_action" => {
Ok(__FieldTag::__instance_termination_action)
}
"localSsdRecoveryTimeout" => {
Ok(__FieldTag::__local_ssd_recovery_timeout)
}
"local_ssd_recovery_timeout" => {
Ok(__FieldTag::__local_ssd_recovery_timeout)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Scheduling;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Scheduling")
}
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::__on_host_maintenance => {
if !fields.insert(__FieldTag::__on_host_maintenance) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for on_host_maintenance",
));
}
result.on_host_maintenance =
map.next_value::<std::option::Option<
crate::model::scheduling::OnHostMaintenance,
>>()?;
}
__FieldTag::__automatic_restart => {
if !fields.insert(__FieldTag::__automatic_restart) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for automatic_restart",
));
}
result.automatic_restart =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__preemptible => {
if !fields.insert(__FieldTag::__preemptible) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for preemptible",
));
}
result.preemptible = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__node_affinities => {
if !fields.insert(__FieldTag::__node_affinities) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_affinities",
));
}
result.node_affinities = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::scheduling::NodeAffinity>,
>>()?
.unwrap_or_default();
}
__FieldTag::__min_node_cpus => {
if !fields.insert(__FieldTag::__min_node_cpus) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_node_cpus",
));
}
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.min_node_cpus = map.next_value::<__With>()?.0;
}
__FieldTag::__provisioning_model => {
if !fields.insert(__FieldTag::__provisioning_model) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provisioning_model",
));
}
result.provisioning_model =
map.next_value::<std::option::Option<
crate::model::scheduling::ProvisioningModel,
>>()?;
}
__FieldTag::__instance_termination_action => {
if !fields.insert(__FieldTag::__instance_termination_action) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_termination_action",
));
}
result.instance_termination_action = map
.next_value::<std::option::Option<
crate::model::scheduling::InstanceTerminationAction,
>>()?;
}
__FieldTag::__local_ssd_recovery_timeout => {
if !fields.insert(__FieldTag::__local_ssd_recovery_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for local_ssd_recovery_timeout",
));
}
result.local_ssd_recovery_timeout = map.next_value::<std::option::Option<crate::model::SchedulingDuration>>()?
;
}
__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::scheduling::NodeAffinity {
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,
__operator,
__values,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for NodeAffinity")
}
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),
"operator" => Ok(__FieldTag::__operator),
"values" => Ok(__FieldTag::__values),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::scheduling::NodeAffinity;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NodeAffinity")
}
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>>()?;
}
__FieldTag::__operator => {
if !fields.insert(__FieldTag::__operator) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operator",
));
}
result.operator = map.next_value::<std::option::Option<
crate::model::scheduling::node_affinity::Operator,
>>()?;
}
__FieldTag::__values => {
if !fields.insert(__FieldTag::__values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for values",
));
}
result.values = 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::SchedulingDuration {
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 {
__seconds,
__nanos,
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 SchedulingDuration")
}
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 {
"seconds" => Ok(__FieldTag::__seconds),
"nanos" => Ok(__FieldTag::__nanos),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SchedulingDuration;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SchedulingDuration")
}
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::__seconds => {
if !fields.insert(__FieldTag::__seconds) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for seconds",
));
}
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.seconds = map.next_value::<__With>()?.0;
}
__FieldTag::__nanos => {
if !fields.insert(__FieldTag::__nanos) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for nanos",
));
}
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.nanos = 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::ServiceAccount {
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 {
__email,
__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 ServiceAccount")
}
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 {
"email" => Ok(__FieldTag::__email),
"scopes" => Ok(__FieldTag::__scopes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ServiceAccount;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ServiceAccount")
}
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::__email => {
if !fields.insert(__FieldTag::__email) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for email",
));
}
result.email =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__scopes => {
if !fields.insert(__FieldTag::__scopes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scopes",
));
}
result.scopes = 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::Tags {
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 {
__items,
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 Tags")
}
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 {
"items" => Ok(__FieldTag::__items),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Tags;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Tags")
}
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::__items => {
if !fields.insert(__FieldTag::__items) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for items",
));
}
result.items = 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::AttachedDisk {
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 {
__initialize_params,
__device_name,
__kind,
__disk_type_deprecated,
__mode,
__source,
__index,
__boot,
__auto_delete,
__license,
__disk_interface,
__guest_os_feature,
__disk_encryption_key,
__disk_size_gb,
__saved_state,
__disk_type,
__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 AttachedDisk")
}
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 {
"initializeParams" => Ok(__FieldTag::__initialize_params),
"initialize_params" => Ok(__FieldTag::__initialize_params),
"deviceName" => Ok(__FieldTag::__device_name),
"device_name" => Ok(__FieldTag::__device_name),
"kind" => Ok(__FieldTag::__kind),
"diskTypeDeprecated" => Ok(__FieldTag::__disk_type_deprecated),
"disk_type_deprecated" => Ok(__FieldTag::__disk_type_deprecated),
"mode" => Ok(__FieldTag::__mode),
"source" => Ok(__FieldTag::__source),
"index" => Ok(__FieldTag::__index),
"boot" => Ok(__FieldTag::__boot),
"autoDelete" => Ok(__FieldTag::__auto_delete),
"auto_delete" => Ok(__FieldTag::__auto_delete),
"license" => Ok(__FieldTag::__license),
"diskInterface" => Ok(__FieldTag::__disk_interface),
"disk_interface" => Ok(__FieldTag::__disk_interface),
"guestOsFeature" => Ok(__FieldTag::__guest_os_feature),
"guest_os_feature" => Ok(__FieldTag::__guest_os_feature),
"diskEncryptionKey" => Ok(__FieldTag::__disk_encryption_key),
"disk_encryption_key" => Ok(__FieldTag::__disk_encryption_key),
"diskSizeGb" => Ok(__FieldTag::__disk_size_gb),
"disk_size_gb" => Ok(__FieldTag::__disk_size_gb),
"savedState" => Ok(__FieldTag::__saved_state),
"saved_state" => Ok(__FieldTag::__saved_state),
"diskType" => Ok(__FieldTag::__disk_type),
"disk_type" => Ok(__FieldTag::__disk_type),
"type" => Ok(__FieldTag::__type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AttachedDisk;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AttachedDisk")
}
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::__initialize_params => {
if !fields.insert(__FieldTag::__initialize_params) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for initialize_params",
));
}
result.initialize_params = map.next_value::<std::option::Option<
crate::model::attached_disk::InitializeParams,
>>()?;
}
__FieldTag::__device_name => {
if !fields.insert(__FieldTag::__device_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for device_name",
));
}
result.device_name =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__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>>()?;
}
__FieldTag::__disk_type_deprecated => {
if !fields.insert(__FieldTag::__disk_type_deprecated) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_type_deprecated",
));
}
result.disk_type_deprecated = map.next_value::<std::option::Option<crate::model::attached_disk::DiskType>>()?
;
}
__FieldTag::__mode => {
if !fields.insert(__FieldTag::__mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mode",
));
}
result.mode = map.next_value::<std::option::Option<crate::model::attached_disk::DiskMode>>()?
;
}
__FieldTag::__source => {
if !fields.insert(__FieldTag::__source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source",
));
}
result.source =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__index => {
if !fields.insert(__FieldTag::__index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for index",
));
}
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.index = map.next_value::<__With>()?.0;
}
__FieldTag::__boot => {
if !fields.insert(__FieldTag::__boot) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boot",
));
}
result.boot = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__auto_delete => {
if !fields.insert(__FieldTag::__auto_delete) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for auto_delete",
));
}
result.auto_delete = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__license => {
if !fields.insert(__FieldTag::__license) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for license",
));
}
result.license = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__disk_interface => {
if !fields.insert(__FieldTag::__disk_interface) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_interface",
));
}
result.disk_interface = map.next_value::<std::option::Option<crate::model::attached_disk::DiskInterface>>()?
;
}
__FieldTag::__guest_os_feature => {
if !fields.insert(__FieldTag::__guest_os_feature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for guest_os_feature",
));
}
result.guest_os_feature =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::GuestOsFeature>,
>>()?
.unwrap_or_default();
}
__FieldTag::__disk_encryption_key => {
if !fields.insert(__FieldTag::__disk_encryption_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_encryption_key",
));
}
result.disk_encryption_key = map.next_value::<std::option::Option<crate::model::CustomerEncryptionKey>>()?
;
}
__FieldTag::__disk_size_gb => {
if !fields.insert(__FieldTag::__disk_size_gb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_size_gb",
));
}
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.disk_size_gb = map.next_value::<__With>()?.0;
}
__FieldTag::__saved_state => {
if !fields.insert(__FieldTag::__saved_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for saved_state",
));
}
result.saved_state =
map.next_value::<std::option::Option<
crate::model::attached_disk::DiskSavedState,
>>()?;
}
__FieldTag::__disk_type => {
if !fields.insert(__FieldTag::__disk_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_type",
));
}
result.disk_type =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__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::attached_disk::DiskType>>()?
;
}
__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::attached_disk::InitializeParams {
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 {
__disk_name,
__replica_zones,
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 InitializeParams")
}
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 {
"diskName" => Ok(__FieldTag::__disk_name),
"disk_name" => Ok(__FieldTag::__disk_name),
"replicaZones" => Ok(__FieldTag::__replica_zones),
"replica_zones" => Ok(__FieldTag::__replica_zones),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::attached_disk::InitializeParams;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InitializeParams")
}
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::__disk_name => {
if !fields.insert(__FieldTag::__disk_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_name",
));
}
result.disk_name =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__replica_zones => {
if !fields.insert(__FieldTag::__replica_zones) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for replica_zones",
));
}
result.replica_zones = 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::GuestOsFeature {
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,
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 GuestOsFeature")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GuestOsFeature;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GuestOsFeature")
}
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<
crate::model::guest_os_feature::FeatureType,
>>()?;
}
__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::DataSourceReference {
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,
__data_source,
__create_time,
__data_source_backup_config_state,
__data_source_backup_count,
__data_source_backup_config_info,
__data_source_gcp_resource_info,
__total_stored_bytes,
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 DataSourceReference")
}
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),
"dataSource" => Ok(__FieldTag::__data_source),
"data_source" => Ok(__FieldTag::__data_source),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"dataSourceBackupConfigState" => {
Ok(__FieldTag::__data_source_backup_config_state)
}
"data_source_backup_config_state" => {
Ok(__FieldTag::__data_source_backup_config_state)
}
"dataSourceBackupCount" => Ok(__FieldTag::__data_source_backup_count),
"data_source_backup_count" => {
Ok(__FieldTag::__data_source_backup_count)
}
"dataSourceBackupConfigInfo" => {
Ok(__FieldTag::__data_source_backup_config_info)
}
"data_source_backup_config_info" => {
Ok(__FieldTag::__data_source_backup_config_info)
}
"dataSourceGcpResourceInfo" => {
Ok(__FieldTag::__data_source_gcp_resource_info)
}
"data_source_gcp_resource_info" => {
Ok(__FieldTag::__data_source_gcp_resource_info)
}
"totalStoredBytes" => Ok(__FieldTag::__total_stored_bytes),
"total_stored_bytes" => Ok(__FieldTag::__total_stored_bytes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataSourceReference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataSourceReference")
}
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::__data_source => {
if !fields.insert(__FieldTag::__data_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source",
));
}
result.data_source = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__data_source_backup_config_state => {
if !fields.insert(__FieldTag::__data_source_backup_config_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_backup_config_state",
));
}
result.data_source_backup_config_state = map
.next_value::<std::option::Option<crate::model::BackupConfigState>>(
)?
.unwrap_or_default();
}
__FieldTag::__data_source_backup_count => {
if !fields.insert(__FieldTag::__data_source_backup_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_backup_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.data_source_backup_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__data_source_backup_config_info => {
if !fields.insert(__FieldTag::__data_source_backup_config_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_backup_config_info",
));
}
result.data_source_backup_config_info = map.next_value::<std::option::Option<crate::model::DataSourceBackupConfigInfo>>()?
;
}
__FieldTag::__data_source_gcp_resource_info => {
if !fields.insert(__FieldTag::__data_source_gcp_resource_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_gcp_resource_info",
));
}
result.data_source_gcp_resource_info = map.next_value::<std::option::Option<crate::model::DataSourceGcpResourceInfo>>()?
;
}
__FieldTag::__total_stored_bytes => {
if !fields.insert(__FieldTag::__total_stored_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_stored_bytes",
));
}
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.total_stored_bytes = 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::DataSourceBackupConfigInfo {
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 {
__last_backup_state,
__last_successful_backup_consistency_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DataSourceBackupConfigInfo")
}
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 {
"lastBackupState" => Ok(__FieldTag::__last_backup_state),
"last_backup_state" => Ok(__FieldTag::__last_backup_state),
"lastSuccessfulBackupConsistencyTime" => {
Ok(__FieldTag::__last_successful_backup_consistency_time)
}
"last_successful_backup_consistency_time" => {
Ok(__FieldTag::__last_successful_backup_consistency_time)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataSourceBackupConfigInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataSourceBackupConfigInfo")
}
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::__last_backup_state => {
if !fields.insert(__FieldTag::__last_backup_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_backup_state",
));
}
result.last_backup_state = map
.next_value::<std::option::Option<
crate::model::backup_config_info::LastBackupState,
>>()?
.unwrap_or_default();
}
__FieldTag::__last_successful_backup_consistency_time => {
if !fields.insert(__FieldTag::__last_successful_backup_consistency_time)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_successful_backup_consistency_time",
));
}
result.last_successful_backup_consistency_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DataSourceGcpResourceInfo {
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 {
__gcp_resourcename,
__type,
__location,
__cloud_sql_instance_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 DataSourceGcpResourceInfo")
}
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 {
"gcpResourcename" => Ok(__FieldTag::__gcp_resourcename),
"gcp_resourcename" => Ok(__FieldTag::__gcp_resourcename),
"type" => Ok(__FieldTag::__type),
"location" => Ok(__FieldTag::__location),
"cloudSqlInstanceProperties" => {
Ok(__FieldTag::__cloud_sql_instance_properties)
}
"cloud_sql_instance_properties" => {
Ok(__FieldTag::__cloud_sql_instance_properties)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataSourceGcpResourceInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataSourceGcpResourceInfo")
}
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::__gcp_resourcename => {
if !fields.insert(__FieldTag::__gcp_resourcename) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcp_resourcename",
));
}
result.gcp_resourcename = 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::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
result.location = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cloud_sql_instance_properties => {
if !fields.insert(__FieldTag::__cloud_sql_instance_properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_sql_instance_properties",
));
}
if result.resource_properties.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `resource_properties`, a oneof with full ID .google.cloud.backupdr.v1.DataSourceGcpResourceInfo.cloud_sql_instance_properties, latest field was cloudSqlInstanceProperties",
));
}
result.resource_properties = std::option::Option::Some(
crate::model::data_source_gcp_resource_info::ResourceProperties::CloudSqlInstanceProperties(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::CloudSqlInstanceDataSourceReferenceProperties>>>()?.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::GetDataSourceReferenceRequest {
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,
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 GetDataSourceReferenceRequest")
}
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),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetDataSourceReferenceRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetDataSourceReferenceRequest")
}
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::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::ListDataSourceReferencesRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
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 ListDataSourceReferencesRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDataSourceReferencesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDataSourceReferencesRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = 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::ListDataSourceReferencesResponse {
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 {
__data_source_references,
__next_page_token,
__unreachable,
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 ListDataSourceReferencesResponse")
}
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 {
"dataSourceReferences" => Ok(__FieldTag::__data_source_references),
"data_source_references" => Ok(__FieldTag::__data_source_references),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"unreachable" => Ok(__FieldTag::__unreachable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDataSourceReferencesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDataSourceReferencesResponse")
}
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::__data_source_references => {
if !fields.insert(__FieldTag::__data_source_references) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_references",
));
}
result.data_source_references = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::DataSourceReference>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__unreachable => {
if !fields.insert(__FieldTag::__unreachable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unreachable",
));
}
result.unreachable = 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::FetchDataSourceReferencesForResourceTypeRequest {
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 {
__parent,
__resource_type,
__page_size,
__page_token,
__filter,
__order_by,
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 FetchDataSourceReferencesForResourceTypeRequest",
)
}
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 {
"parent" => Ok(__FieldTag::__parent),
"resourceType" => Ok(__FieldTag::__resource_type),
"resource_type" => Ok(__FieldTag::__resource_type),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchDataSourceReferencesForResourceTypeRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchDataSourceReferencesForResourceTypeRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = 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::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = 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::FetchDataSourceReferencesForResourceTypeResponse {
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 {
__data_source_references,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str(
"a field name for FetchDataSourceReferencesForResourceTypeResponse",
)
}
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 {
"dataSourceReferences" => Ok(__FieldTag::__data_source_references),
"data_source_references" => Ok(__FieldTag::__data_source_references),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchDataSourceReferencesForResourceTypeResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchDataSourceReferencesForResourceTypeResponse")
}
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::__data_source_references => {
if !fields.insert(__FieldTag::__data_source_references) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_source_references",
));
}
result.data_source_references = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::DataSourceReference>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListResourceBackupConfigsRequest {
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 {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
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 ListResourceBackupConfigsRequest")
}
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 {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListResourceBackupConfigsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListResourceBackupConfigsRequest")
}
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::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = 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::ListResourceBackupConfigsResponse {
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 {
__resource_backup_configs,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListResourceBackupConfigsResponse")
}
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 {
"resourceBackupConfigs" => Ok(__FieldTag::__resource_backup_configs),
"resource_backup_configs" => Ok(__FieldTag::__resource_backup_configs),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListResourceBackupConfigsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListResourceBackupConfigsResponse")
}
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::__resource_backup_configs => {
if !fields.insert(__FieldTag::__resource_backup_configs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_backup_configs",
));
}
result.resource_backup_configs = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::ResourceBackupConfig>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ResourceBackupConfig {
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,
__uid,
__target_resource,
__target_resource_display_name,
__target_resource_type,
__target_resource_labels,
__backup_configs_details,
__backup_configured,
__vaulted,
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 ResourceBackupConfig")
}
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),
"uid" => Ok(__FieldTag::__uid),
"targetResource" => Ok(__FieldTag::__target_resource),
"target_resource" => Ok(__FieldTag::__target_resource),
"targetResourceDisplayName" => {
Ok(__FieldTag::__target_resource_display_name)
}
"target_resource_display_name" => {
Ok(__FieldTag::__target_resource_display_name)
}
"targetResourceType" => Ok(__FieldTag::__target_resource_type),
"target_resource_type" => Ok(__FieldTag::__target_resource_type),
"targetResourceLabels" => Ok(__FieldTag::__target_resource_labels),
"target_resource_labels" => Ok(__FieldTag::__target_resource_labels),
"backupConfigsDetails" => Ok(__FieldTag::__backup_configs_details),
"backup_configs_details" => Ok(__FieldTag::__backup_configs_details),
"backupConfigured" => Ok(__FieldTag::__backup_configured),
"backup_configured" => Ok(__FieldTag::__backup_configured),
"vaulted" => Ok(__FieldTag::__vaulted),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ResourceBackupConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ResourceBackupConfig")
}
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::__uid => {
if !fields.insert(__FieldTag::__uid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uid",
));
}
result.uid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__target_resource => {
if !fields.insert(__FieldTag::__target_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_resource",
));
}
result.target_resource = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__target_resource_display_name => {
if !fields.insert(__FieldTag::__target_resource_display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_resource_display_name",
));
}
result.target_resource_display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__target_resource_type => {
if !fields.insert(__FieldTag::__target_resource_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_resource_type",
));
}
result.target_resource_type = map
.next_value::<std::option::Option<
crate::model::resource_backup_config::ResourceType,
>>()?
.unwrap_or_default();
}
__FieldTag::__target_resource_labels => {
if !fields.insert(__FieldTag::__target_resource_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_resource_labels",
));
}
result.target_resource_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__backup_configs_details => {
if !fields.insert(__FieldTag::__backup_configs_details) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_configs_details",
));
}
result.backup_configs_details = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::BackupConfigDetails>,
>>()?
.unwrap_or_default();
}
__FieldTag::__backup_configured => {
if !fields.insert(__FieldTag::__backup_configured) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_configured",
));
}
result.backup_configured = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__vaulted => {
if !fields.insert(__FieldTag::__vaulted) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for vaulted",
));
}
result.vaulted = 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::BackupConfigDetails {
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 {
__backup_config_source,
__backup_config_source_display_name,
__type,
__state,
__pitr_settings,
__latest_successful_backup_time,
__applicable_resource,
__backup_vault,
__backup_locations,
__backup_dr_plan_config,
__backup_dr_template_config,
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 BackupConfigDetails")
}
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 {
"backupConfigSource" => Ok(__FieldTag::__backup_config_source),
"backup_config_source" => Ok(__FieldTag::__backup_config_source),
"backupConfigSourceDisplayName" => {
Ok(__FieldTag::__backup_config_source_display_name)
}
"backup_config_source_display_name" => {
Ok(__FieldTag::__backup_config_source_display_name)
}
"type" => Ok(__FieldTag::__type),
"state" => Ok(__FieldTag::__state),
"pitrSettings" => Ok(__FieldTag::__pitr_settings),
"pitr_settings" => Ok(__FieldTag::__pitr_settings),
"latestSuccessfulBackupTime" => {
Ok(__FieldTag::__latest_successful_backup_time)
}
"latest_successful_backup_time" => {
Ok(__FieldTag::__latest_successful_backup_time)
}
"applicableResource" => Ok(__FieldTag::__applicable_resource),
"applicable_resource" => Ok(__FieldTag::__applicable_resource),
"backupVault" => Ok(__FieldTag::__backup_vault),
"backup_vault" => Ok(__FieldTag::__backup_vault),
"backupLocations" => Ok(__FieldTag::__backup_locations),
"backup_locations" => Ok(__FieldTag::__backup_locations),
"backupDrPlanConfig" => Ok(__FieldTag::__backup_dr_plan_config),
"backup_dr_plan_config" => Ok(__FieldTag::__backup_dr_plan_config),
"backupDrTemplateConfig" => Ok(__FieldTag::__backup_dr_template_config),
"backup_dr_template_config" => {
Ok(__FieldTag::__backup_dr_template_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupConfigDetails;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupConfigDetails")
}
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::__backup_config_source => {
if !fields.insert(__FieldTag::__backup_config_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_config_source",
));
}
result.backup_config_source = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_config_source_display_name => {
if !fields.insert(__FieldTag::__backup_config_source_display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_config_source_display_name",
));
}
result.backup_config_source_display_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::backup_config_details::Type>>()?.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::backup_config_details::State>>()?.unwrap_or_default();
}
__FieldTag::__pitr_settings => {
if !fields.insert(__FieldTag::__pitr_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pitr_settings",
));
}
result.pitr_settings = map
.next_value::<std::option::Option<crate::model::PitrSettings>>()?;
}
__FieldTag::__latest_successful_backup_time => {
if !fields.insert(__FieldTag::__latest_successful_backup_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for latest_successful_backup_time",
));
}
result.latest_successful_backup_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__applicable_resource => {
if !fields.insert(__FieldTag::__applicable_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for applicable_resource",
));
}
result.applicable_resource = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_vault => {
if !fields.insert(__FieldTag::__backup_vault) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_vault",
));
}
result.backup_vault = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__backup_locations => {
if !fields.insert(__FieldTag::__backup_locations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_locations",
));
}
result.backup_locations =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::BackupLocation>,
>>()?
.unwrap_or_default();
}
__FieldTag::__backup_dr_plan_config => {
if !fields.insert(__FieldTag::__backup_dr_plan_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_dr_plan_config",
));
}
if result.plan_specific_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `plan_specific_config`, a oneof with full ID .google.cloud.backupdr.v1.BackupConfigDetails.backup_dr_plan_config, latest field was backupDrPlanConfig",
));
}
result.plan_specific_config = std::option::Option::Some(
crate::model::backup_config_details::PlanSpecificConfig::BackupDrPlanConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::BackupDrPlanConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__backup_dr_template_config => {
if !fields.insert(__FieldTag::__backup_dr_template_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_dr_template_config",
));
}
if result.plan_specific_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `plan_specific_config`, a oneof with full ID .google.cloud.backupdr.v1.BackupConfigDetails.backup_dr_template_config, latest field was backupDrTemplateConfig",
));
}
result.plan_specific_config = std::option::Option::Some(
crate::model::backup_config_details::PlanSpecificConfig::BackupDrTemplateConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::BackupDrTemplateConfig>>>()?.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::PitrSettings {
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 {
__retention_days,
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 PitrSettings")
}
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 {
"retentionDays" => Ok(__FieldTag::__retention_days),
"retention_days" => Ok(__FieldTag::__retention_days),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PitrSettings;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PitrSettings")
}
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::__retention_days => {
if !fields.insert(__FieldTag::__retention_days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for retention_days",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.retention_days =
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::BackupDrTemplateConfig {
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 {
__first_party_management_uri,
__third_party_management_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 BackupDrTemplateConfig")
}
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 {
"firstPartyManagementUri" => {
Ok(__FieldTag::__first_party_management_uri)
}
"first_party_management_uri" => {
Ok(__FieldTag::__first_party_management_uri)
}
"thirdPartyManagementUri" => {
Ok(__FieldTag::__third_party_management_uri)
}
"third_party_management_uri" => {
Ok(__FieldTag::__third_party_management_uri)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupDrTemplateConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupDrTemplateConfig")
}
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::__first_party_management_uri => {
if !fields.insert(__FieldTag::__first_party_management_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for first_party_management_uri",
));
}
result.first_party_management_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__third_party_management_uri => {
if !fields.insert(__FieldTag::__third_party_management_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for third_party_management_uri",
));
}
result.third_party_management_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::BackupDrPlanConfig {
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 {
__backup_dr_plan_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 BackupDrPlanConfig")
}
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 {
"backupDrPlanRules" => Ok(__FieldTag::__backup_dr_plan_rules),
"backup_dr_plan_rules" => Ok(__FieldTag::__backup_dr_plan_rules),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupDrPlanConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupDrPlanConfig")
}
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::__backup_dr_plan_rules => {
if !fields.insert(__FieldTag::__backup_dr_plan_rules) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for backup_dr_plan_rules",
));
}
result.backup_dr_plan_rules =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::BackupDrPlanRule>,
>>()?
.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::BackupDrPlanRule {
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 {
__rule_id,
__last_successful_backup_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BackupDrPlanRule")
}
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 {
"ruleId" => Ok(__FieldTag::__rule_id),
"rule_id" => Ok(__FieldTag::__rule_id),
"lastSuccessfulBackupTime" => {
Ok(__FieldTag::__last_successful_backup_time)
}
"last_successful_backup_time" => {
Ok(__FieldTag::__last_successful_backup_time)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupDrPlanRule;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupDrPlanRule")
}
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::__rule_id => {
if !fields.insert(__FieldTag::__rule_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rule_id",
));
}
result.rule_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__last_successful_backup_time => {
if !fields.insert(__FieldTag::__last_successful_backup_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_successful_backup_time",
));
}
result.last_successful_backup_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BackupLocation {
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,
__location_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BackupLocation")
}
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),
"locationId" => Ok(__FieldTag::__location_id),
"location_id" => Ok(__FieldTag::__location_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BackupLocation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BackupLocation")
}
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<crate::model::backup_location::Type>>()?.unwrap_or_default();
}
__FieldTag::__location_id => {
if !fields.insert(__FieldTag::__location_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location_id",
));
}
result.location_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}