#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AutoscalingPolicy {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__id,
__name,
__basic_algorithm,
__worker_config,
__secondary_worker_config,
__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 AutoscalingPolicy")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"id" => Ok(__FieldTag::__id),
"name" => Ok(__FieldTag::__name),
"basicAlgorithm" => Ok(__FieldTag::__basic_algorithm),
"basic_algorithm" => Ok(__FieldTag::__basic_algorithm),
"workerConfig" => Ok(__FieldTag::__worker_config),
"worker_config" => Ok(__FieldTag::__worker_config),
"secondaryWorkerConfig" => Ok(__FieldTag::__secondary_worker_config),
"secondary_worker_config" => Ok(__FieldTag::__secondary_worker_config),
"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::AutoscalingPolicy;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AutoscalingPolicy")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__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::__basic_algorithm => {
if !fields.insert(__FieldTag::__basic_algorithm) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for basic_algorithm",
));
}
if result.algorithm.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `algorithm`, a oneof with full ID .google.cloud.dataproc.v1.AutoscalingPolicy.basic_algorithm, latest field was basicAlgorithm",
));
}
result.algorithm = std::option::Option::Some(
crate::model::autoscaling_policy::Algorithm::BasicAlgorithm(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::BasicAutoscalingAlgorithm>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__worker_config => {
if !fields.insert(__FieldTag::__worker_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for worker_config",
));
}
result.worker_config = map.next_value::<std::option::Option<
crate::model::InstanceGroupAutoscalingPolicyConfig,
>>()?;
}
__FieldTag::__secondary_worker_config => {
if !fields.insert(__FieldTag::__secondary_worker_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for secondary_worker_config",
));
}
result.secondary_worker_config = map.next_value::<std::option::Option<
crate::model::InstanceGroupAutoscalingPolicyConfig,
>>()?;
}
__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::BasicAutoscalingAlgorithm {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__yarn_config,
__cooldown_period,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BasicAutoscalingAlgorithm")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"yarnConfig" => Ok(__FieldTag::__yarn_config),
"yarn_config" => Ok(__FieldTag::__yarn_config),
"cooldownPeriod" => Ok(__FieldTag::__cooldown_period),
"cooldown_period" => Ok(__FieldTag::__cooldown_period),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BasicAutoscalingAlgorithm;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BasicAutoscalingAlgorithm")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__yarn_config => {
if !fields.insert(__FieldTag::__yarn_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for yarn_config",
));
}
if result.config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `config`, a oneof with full ID .google.cloud.dataproc.v1.BasicAutoscalingAlgorithm.yarn_config, latest field was yarnConfig",
));
}
result.config = std::option::Option::Some(
crate::model::basic_autoscaling_algorithm::Config::YarnConfig(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::BasicYarnAutoscalingConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__cooldown_period => {
if !fields.insert(__FieldTag::__cooldown_period) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cooldown_period",
));
}
result.cooldown_period =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BasicYarnAutoscalingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__graceful_decommission_timeout,
__scale_up_factor,
__scale_down_factor,
__scale_up_min_worker_fraction,
__scale_down_min_worker_fraction,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BasicYarnAutoscalingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"gracefulDecommissionTimeout" => {
Ok(__FieldTag::__graceful_decommission_timeout)
}
"graceful_decommission_timeout" => {
Ok(__FieldTag::__graceful_decommission_timeout)
}
"scaleUpFactor" => Ok(__FieldTag::__scale_up_factor),
"scale_up_factor" => Ok(__FieldTag::__scale_up_factor),
"scaleDownFactor" => Ok(__FieldTag::__scale_down_factor),
"scale_down_factor" => Ok(__FieldTag::__scale_down_factor),
"scaleUpMinWorkerFraction" => {
Ok(__FieldTag::__scale_up_min_worker_fraction)
}
"scale_up_min_worker_fraction" => {
Ok(__FieldTag::__scale_up_min_worker_fraction)
}
"scaleDownMinWorkerFraction" => {
Ok(__FieldTag::__scale_down_min_worker_fraction)
}
"scale_down_min_worker_fraction" => {
Ok(__FieldTag::__scale_down_min_worker_fraction)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BasicYarnAutoscalingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BasicYarnAutoscalingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__graceful_decommission_timeout => {
if !fields.insert(__FieldTag::__graceful_decommission_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for graceful_decommission_timeout",
));
}
result.graceful_decommission_timeout =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__scale_up_factor => {
if !fields.insert(__FieldTag::__scale_up_factor) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scale_up_factor",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.scale_up_factor =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__scale_down_factor => {
if !fields.insert(__FieldTag::__scale_down_factor) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scale_down_factor",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.scale_down_factor =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__scale_up_min_worker_fraction => {
if !fields.insert(__FieldTag::__scale_up_min_worker_fraction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scale_up_min_worker_fraction",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.scale_up_min_worker_fraction =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__scale_down_min_worker_fraction => {
if !fields.insert(__FieldTag::__scale_down_min_worker_fraction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scale_down_min_worker_fraction",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.scale_down_min_worker_fraction =
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::InstanceGroupAutoscalingPolicyConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__min_instances,
__max_instances,
__weight,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InstanceGroupAutoscalingPolicyConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"minInstances" => Ok(__FieldTag::__min_instances),
"min_instances" => Ok(__FieldTag::__min_instances),
"maxInstances" => Ok(__FieldTag::__max_instances),
"max_instances" => Ok(__FieldTag::__max_instances),
"weight" => Ok(__FieldTag::__weight),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InstanceGroupAutoscalingPolicyConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstanceGroupAutoscalingPolicyConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__min_instances => {
if !fields.insert(__FieldTag::__min_instances) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_instances",
));
}
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_instances =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__max_instances => {
if !fields.insert(__FieldTag::__max_instances) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_instances",
));
}
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.max_instances =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__weight => {
if !fields.insert(__FieldTag::__weight) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for weight",
));
}
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.weight = 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::CreateAutoscalingPolicyRequest {
fn deserialize<D>(deserializer: D) -> 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,
__policy,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateAutoscalingPolicyRequest")
}
fn visit_str<E>(self, 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),
"policy" => Ok(__FieldTag::__policy),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateAutoscalingPolicyRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateAutoscalingPolicyRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__policy => {
if !fields.insert(__FieldTag::__policy) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for policy",
));
}
result.policy = map
.next_value::<std::option::Option<crate::model::AutoscalingPolicy>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetAutoscalingPolicyRequest {
fn deserialize<D>(deserializer: D) -> 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 GetAutoscalingPolicyRequest")
}
fn visit_str<E>(self, 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::GetAutoscalingPolicyRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetAutoscalingPolicyRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::UpdateAutoscalingPolicyRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__policy,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateAutoscalingPolicyRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"policy" => Ok(__FieldTag::__policy),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateAutoscalingPolicyRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateAutoscalingPolicyRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__policy => {
if !fields.insert(__FieldTag::__policy) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for policy",
));
}
result.policy = map
.next_value::<std::option::Option<crate::model::AutoscalingPolicy>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteAutoscalingPolicyRequest {
fn deserialize<D>(deserializer: D) -> 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 DeleteAutoscalingPolicyRequest")
}
fn visit_str<E>(self, 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::DeleteAutoscalingPolicyRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteAutoscalingPolicyRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListAutoscalingPoliciesRequest {
fn deserialize<D>(deserializer: D) -> 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 ListAutoscalingPoliciesRequest")
}
fn visit_str<E>(self, 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::ListAutoscalingPoliciesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListAutoscalingPoliciesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListAutoscalingPoliciesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__policies,
__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 ListAutoscalingPoliciesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"policies" => Ok(__FieldTag::__policies),
"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::ListAutoscalingPoliciesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListAutoscalingPoliciesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__policies => {
if !fields.insert(__FieldTag::__policies) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for policies",
));
}
result.policies =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::AutoscalingPolicy>,
>>()?
.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::CreateBatchRequest {
fn deserialize<D>(deserializer: D) -> 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,
__batch,
__batch_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 CreateBatchRequest")
}
fn visit_str<E>(self, 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),
"batch" => Ok(__FieldTag::__batch),
"batchId" => Ok(__FieldTag::__batch_id),
"batch_id" => Ok(__FieldTag::__batch_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::CreateBatchRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateBatchRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__batch => {
if !fields.insert(__FieldTag::__batch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batch",
));
}
result.batch =
map.next_value::<std::option::Option<crate::model::Batch>>()?;
}
__FieldTag::__batch_id => {
if !fields.insert(__FieldTag::__batch_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batch_id",
));
}
result.batch_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::GetBatchRequest {
fn deserialize<D>(deserializer: D) -> 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 GetBatchRequest")
}
fn visit_str<E>(self, 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::GetBatchRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetBatchRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListBatchesRequest {
fn deserialize<D>(deserializer: D) -> 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 ListBatchesRequest")
}
fn visit_str<E>(self, 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::ListBatchesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBatchesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListBatchesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__batches,
__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 ListBatchesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"batches" => Ok(__FieldTag::__batches),
"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::ListBatchesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListBatchesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__batches => {
if !fields.insert(__FieldTag::__batches) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batches",
));
}
result.batches = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Batch>>>()?.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::DeleteBatchRequest {
fn deserialize<D>(deserializer: D) -> 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 DeleteBatchRequest")
}
fn visit_str<E>(self, 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::DeleteBatchRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteBatchRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::Batch {
fn deserialize<D>(deserializer: D) -> 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,
__uuid,
__create_time,
__pyspark_batch,
__spark_batch,
__spark_r_batch,
__spark_sql_batch,
__runtime_info,
__state,
__state_message,
__state_time,
__creator,
__labels,
__runtime_config,
__environment_config,
__operation,
__state_history,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Batch")
}
fn visit_str<E>(self, 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),
"uuid" => Ok(__FieldTag::__uuid),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"pysparkBatch" => Ok(__FieldTag::__pyspark_batch),
"pyspark_batch" => Ok(__FieldTag::__pyspark_batch),
"sparkBatch" => Ok(__FieldTag::__spark_batch),
"spark_batch" => Ok(__FieldTag::__spark_batch),
"sparkRBatch" => Ok(__FieldTag::__spark_r_batch),
"spark_r_batch" => Ok(__FieldTag::__spark_r_batch),
"sparkSqlBatch" => Ok(__FieldTag::__spark_sql_batch),
"spark_sql_batch" => Ok(__FieldTag::__spark_sql_batch),
"runtimeInfo" => Ok(__FieldTag::__runtime_info),
"runtime_info" => Ok(__FieldTag::__runtime_info),
"state" => Ok(__FieldTag::__state),
"stateMessage" => Ok(__FieldTag::__state_message),
"state_message" => Ok(__FieldTag::__state_message),
"stateTime" => Ok(__FieldTag::__state_time),
"state_time" => Ok(__FieldTag::__state_time),
"creator" => Ok(__FieldTag::__creator),
"labels" => Ok(__FieldTag::__labels),
"runtimeConfig" => Ok(__FieldTag::__runtime_config),
"runtime_config" => Ok(__FieldTag::__runtime_config),
"environmentConfig" => Ok(__FieldTag::__environment_config),
"environment_config" => Ok(__FieldTag::__environment_config),
"operation" => Ok(__FieldTag::__operation),
"stateHistory" => Ok(__FieldTag::__state_history),
"state_history" => Ok(__FieldTag::__state_history),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Batch;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Batch")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__uuid => {
if !fields.insert(__FieldTag::__uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uuid",
));
}
result.uuid = 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::__pyspark_batch => {
if !fields.insert(__FieldTag::__pyspark_batch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pyspark_batch",
));
}
if result.batch_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `batch_config`, a oneof with full ID .google.cloud.dataproc.v1.Batch.pyspark_batch, latest field was pysparkBatch",
));
}
result.batch_config = std::option::Option::Some(
crate::model::batch::BatchConfig::PysparkBatch(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::PySparkBatch>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_batch => {
if !fields.insert(__FieldTag::__spark_batch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_batch",
));
}
if result.batch_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `batch_config`, a oneof with full ID .google.cloud.dataproc.v1.Batch.spark_batch, latest field was sparkBatch",
));
}
result.batch_config = std::option::Option::Some(
crate::model::batch::BatchConfig::SparkBatch(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkBatch>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_r_batch => {
if !fields.insert(__FieldTag::__spark_r_batch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_r_batch",
));
}
if result.batch_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `batch_config`, a oneof with full ID .google.cloud.dataproc.v1.Batch.spark_r_batch, latest field was sparkRBatch",
));
}
result.batch_config = std::option::Option::Some(
crate::model::batch::BatchConfig::SparkRBatch(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkRBatch>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_sql_batch => {
if !fields.insert(__FieldTag::__spark_sql_batch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_sql_batch",
));
}
if result.batch_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `batch_config`, a oneof with full ID .google.cloud.dataproc.v1.Batch.spark_sql_batch, latest field was sparkSqlBatch",
));
}
result.batch_config = std::option::Option::Some(
crate::model::batch::BatchConfig::SparkSqlBatch(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkSqlBatch>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__runtime_info => {
if !fields.insert(__FieldTag::__runtime_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for runtime_info",
));
}
result.runtime_info =
map.next_value::<std::option::Option<crate::model::RuntimeInfo>>()?;
}
__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::batch::State>>()?
.unwrap_or_default();
}
__FieldTag::__state_message => {
if !fields.insert(__FieldTag::__state_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_message",
));
}
result.state_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_time => {
if !fields.insert(__FieldTag::__state_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_time",
));
}
result.state_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__creator => {
if !fields.insert(__FieldTag::__creator) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for creator",
));
}
result.creator = 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::__runtime_config => {
if !fields.insert(__FieldTag::__runtime_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for runtime_config",
));
}
result.runtime_config = map
.next_value::<std::option::Option<crate::model::RuntimeConfig>>()?;
}
__FieldTag::__environment_config => {
if !fields.insert(__FieldTag::__environment_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for environment_config",
));
}
result.environment_config = map
.next_value::<std::option::Option<crate::model::EnvironmentConfig>>(
)?;
}
__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::__state_history => {
if !fields.insert(__FieldTag::__state_history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_history",
));
}
result.state_history = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::batch::StateHistory>,
>>()?
.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::batch::StateHistory {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__state,
__state_message,
__state_start_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 StateHistory")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"state" => Ok(__FieldTag::__state),
"stateMessage" => Ok(__FieldTag::__state_message),
"state_message" => Ok(__FieldTag::__state_message),
"stateStartTime" => Ok(__FieldTag::__state_start_time),
"state_start_time" => Ok(__FieldTag::__state_start_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::batch::StateHistory;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StateHistory")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::batch::State>>()?
.unwrap_or_default();
}
__FieldTag::__state_message => {
if !fields.insert(__FieldTag::__state_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_message",
));
}
result.state_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_start_time => {
if !fields.insert(__FieldTag::__state_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_start_time",
));
}
result.state_start_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::PySparkBatch {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_python_file_uri,
__args,
__python_file_uris,
__jar_file_uris,
__file_uris,
__archive_uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PySparkBatch")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainPythonFileUri" => Ok(__FieldTag::__main_python_file_uri),
"main_python_file_uri" => Ok(__FieldTag::__main_python_file_uri),
"args" => Ok(__FieldTag::__args),
"pythonFileUris" => Ok(__FieldTag::__python_file_uris),
"python_file_uris" => Ok(__FieldTag::__python_file_uris),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"fileUris" => Ok(__FieldTag::__file_uris),
"file_uris" => Ok(__FieldTag::__file_uris),
"archiveUris" => Ok(__FieldTag::__archive_uris),
"archive_uris" => Ok(__FieldTag::__archive_uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PySparkBatch;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PySparkBatch")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_python_file_uri => {
if !fields.insert(__FieldTag::__main_python_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_python_file_uri",
));
}
result.main_python_file_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__python_file_uris => {
if !fields.insert(__FieldTag::__python_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for python_file_uris",
));
}
result.python_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__file_uris => {
if !fields.insert(__FieldTag::__file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_uris",
));
}
result.file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__archive_uris => {
if !fields.insert(__FieldTag::__archive_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for archive_uris",
));
}
result.archive_uris = 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::SparkBatch {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_jar_file_uri,
__main_class,
__args,
__jar_file_uris,
__file_uris,
__archive_uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SparkBatch")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainJarFileUri" => Ok(__FieldTag::__main_jar_file_uri),
"main_jar_file_uri" => Ok(__FieldTag::__main_jar_file_uri),
"mainClass" => Ok(__FieldTag::__main_class),
"main_class" => Ok(__FieldTag::__main_class),
"args" => Ok(__FieldTag::__args),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"fileUris" => Ok(__FieldTag::__file_uris),
"file_uris" => Ok(__FieldTag::__file_uris),
"archiveUris" => Ok(__FieldTag::__archive_uris),
"archive_uris" => Ok(__FieldTag::__archive_uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkBatch;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkBatch")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_jar_file_uri => {
if !fields.insert(__FieldTag::__main_jar_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_jar_file_uri",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.SparkBatch.main_jar_file_uri, latest field was mainJarFileUri",
));
}
result.driver = std::option::Option::Some(
crate::model::spark_batch::Driver::MainJarFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__main_class => {
if !fields.insert(__FieldTag::__main_class) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_class",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.SparkBatch.main_class, latest field was mainClass",
));
}
result.driver = std::option::Option::Some(
crate::model::spark_batch::Driver::MainClass(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__file_uris => {
if !fields.insert(__FieldTag::__file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_uris",
));
}
result.file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__archive_uris => {
if !fields.insert(__FieldTag::__archive_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for archive_uris",
));
}
result.archive_uris = 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::SparkRBatch {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_r_file_uri,
__args,
__file_uris,
__archive_uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SparkRBatch")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainRFileUri" => Ok(__FieldTag::__main_r_file_uri),
"main_r_file_uri" => Ok(__FieldTag::__main_r_file_uri),
"args" => Ok(__FieldTag::__args),
"fileUris" => Ok(__FieldTag::__file_uris),
"file_uris" => Ok(__FieldTag::__file_uris),
"archiveUris" => Ok(__FieldTag::__archive_uris),
"archive_uris" => Ok(__FieldTag::__archive_uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkRBatch;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkRBatch")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_r_file_uri => {
if !fields.insert(__FieldTag::__main_r_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_r_file_uri",
));
}
result.main_r_file_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__file_uris => {
if !fields.insert(__FieldTag::__file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_uris",
));
}
result.file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__archive_uris => {
if !fields.insert(__FieldTag::__archive_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for archive_uris",
));
}
result.archive_uris = 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::SparkSqlBatch {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_file_uri,
__query_variables,
__jar_file_uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SparkSqlBatch")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryFileUri" => Ok(__FieldTag::__query_file_uri),
"query_file_uri" => Ok(__FieldTag::__query_file_uri),
"queryVariables" => Ok(__FieldTag::__query_variables),
"query_variables" => Ok(__FieldTag::__query_variables),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkSqlBatch;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkSqlBatch")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_file_uri => {
if !fields.insert(__FieldTag::__query_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_file_uri",
));
}
result.query_file_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query_variables => {
if !fields.insert(__FieldTag::__query_variables) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_variables",
));
}
result.query_variables = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = 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::Cluster {
fn deserialize<D>(deserializer: D) -> 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_id,
__cluster_name,
__config,
__virtual_cluster_config,
__labels,
__status,
__status_history,
__cluster_uuid,
__metrics,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Cluster")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"config" => Ok(__FieldTag::__config),
"virtualClusterConfig" => Ok(__FieldTag::__virtual_cluster_config),
"virtual_cluster_config" => Ok(__FieldTag::__virtual_cluster_config),
"labels" => Ok(__FieldTag::__labels),
"status" => Ok(__FieldTag::__status),
"statusHistory" => Ok(__FieldTag::__status_history),
"status_history" => Ok(__FieldTag::__status_history),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"metrics" => Ok(__FieldTag::__metrics),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Cluster;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Cluster")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__config => {
if !fields.insert(__FieldTag::__config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for config",
));
}
result.config = map
.next_value::<std::option::Option<crate::model::ClusterConfig>>()?;
}
__FieldTag::__virtual_cluster_config => {
if !fields.insert(__FieldTag::__virtual_cluster_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for virtual_cluster_config",
));
}
result.virtual_cluster_config = map.next_value::<std::option::Option<crate::model::VirtualClusterConfig>>()?
;
}
__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::__status => {
if !fields.insert(__FieldTag::__status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status",
));
}
result.status = map
.next_value::<std::option::Option<crate::model::ClusterStatus>>()?;
}
__FieldTag::__status_history => {
if !fields.insert(__FieldTag::__status_history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status_history",
));
}
result.status_history = map.next_value::<std::option::Option<std::vec::Vec<crate::model::ClusterStatus>>>()?.unwrap_or_default();
}
__FieldTag::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__metrics => {
if !fields.insert(__FieldTag::__metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metrics",
));
}
result.metrics = map
.next_value::<std::option::Option<crate::model::ClusterMetrics>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ClusterConfig {
fn deserialize<D>(deserializer: D) -> 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_tier,
__config_bucket,
__temp_bucket,
__gce_cluster_config,
__master_config,
__worker_config,
__secondary_worker_config,
__software_config,
__initialization_actions,
__encryption_config,
__autoscaling_config,
__security_config,
__lifecycle_config,
__endpoint_config,
__metastore_config,
__dataproc_metric_config,
__auxiliary_node_groups,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ClusterConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"clusterTier" => Ok(__FieldTag::__cluster_tier),
"cluster_tier" => Ok(__FieldTag::__cluster_tier),
"configBucket" => Ok(__FieldTag::__config_bucket),
"config_bucket" => Ok(__FieldTag::__config_bucket),
"tempBucket" => Ok(__FieldTag::__temp_bucket),
"temp_bucket" => Ok(__FieldTag::__temp_bucket),
"gceClusterConfig" => Ok(__FieldTag::__gce_cluster_config),
"gce_cluster_config" => Ok(__FieldTag::__gce_cluster_config),
"masterConfig" => Ok(__FieldTag::__master_config),
"master_config" => Ok(__FieldTag::__master_config),
"workerConfig" => Ok(__FieldTag::__worker_config),
"worker_config" => Ok(__FieldTag::__worker_config),
"secondaryWorkerConfig" => Ok(__FieldTag::__secondary_worker_config),
"secondary_worker_config" => Ok(__FieldTag::__secondary_worker_config),
"softwareConfig" => Ok(__FieldTag::__software_config),
"software_config" => Ok(__FieldTag::__software_config),
"initializationActions" => Ok(__FieldTag::__initialization_actions),
"initialization_actions" => Ok(__FieldTag::__initialization_actions),
"encryptionConfig" => Ok(__FieldTag::__encryption_config),
"encryption_config" => Ok(__FieldTag::__encryption_config),
"autoscalingConfig" => Ok(__FieldTag::__autoscaling_config),
"autoscaling_config" => Ok(__FieldTag::__autoscaling_config),
"securityConfig" => Ok(__FieldTag::__security_config),
"security_config" => Ok(__FieldTag::__security_config),
"lifecycleConfig" => Ok(__FieldTag::__lifecycle_config),
"lifecycle_config" => Ok(__FieldTag::__lifecycle_config),
"endpointConfig" => Ok(__FieldTag::__endpoint_config),
"endpoint_config" => Ok(__FieldTag::__endpoint_config),
"metastoreConfig" => Ok(__FieldTag::__metastore_config),
"metastore_config" => Ok(__FieldTag::__metastore_config),
"dataprocMetricConfig" => Ok(__FieldTag::__dataproc_metric_config),
"dataproc_metric_config" => Ok(__FieldTag::__dataproc_metric_config),
"auxiliaryNodeGroups" => Ok(__FieldTag::__auxiliary_node_groups),
"auxiliary_node_groups" => Ok(__FieldTag::__auxiliary_node_groups),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClusterConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClusterConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_tier => {
if !fields.insert(__FieldTag::__cluster_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_tier",
));
}
result.cluster_tier = map.next_value::<std::option::Option<crate::model::cluster_config::ClusterTier>>()?.unwrap_or_default();
}
__FieldTag::__config_bucket => {
if !fields.insert(__FieldTag::__config_bucket) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for config_bucket",
));
}
result.config_bucket = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__temp_bucket => {
if !fields.insert(__FieldTag::__temp_bucket) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for temp_bucket",
));
}
result.temp_bucket = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__gce_cluster_config => {
if !fields.insert(__FieldTag::__gce_cluster_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gce_cluster_config",
));
}
result.gce_cluster_config = map
.next_value::<std::option::Option<crate::model::GceClusterConfig>>(
)?;
}
__FieldTag::__master_config => {
if !fields.insert(__FieldTag::__master_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for master_config",
));
}
result.master_config = map.next_value::<std::option::Option<crate::model::InstanceGroupConfig>>()?
;
}
__FieldTag::__worker_config => {
if !fields.insert(__FieldTag::__worker_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for worker_config",
));
}
result.worker_config = map.next_value::<std::option::Option<crate::model::InstanceGroupConfig>>()?
;
}
__FieldTag::__secondary_worker_config => {
if !fields.insert(__FieldTag::__secondary_worker_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for secondary_worker_config",
));
}
result.secondary_worker_config = map.next_value::<std::option::Option<crate::model::InstanceGroupConfig>>()?
;
}
__FieldTag::__software_config => {
if !fields.insert(__FieldTag::__software_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for software_config",
));
}
result.software_config = map
.next_value::<std::option::Option<crate::model::SoftwareConfig>>(
)?;
}
__FieldTag::__initialization_actions => {
if !fields.insert(__FieldTag::__initialization_actions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for initialization_actions",
));
}
result.initialization_actions = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::NodeInitializationAction>,
>>()?
.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::EncryptionConfig>>(
)?;
}
__FieldTag::__autoscaling_config => {
if !fields.insert(__FieldTag::__autoscaling_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for autoscaling_config",
));
}
result.autoscaling_config = map
.next_value::<std::option::Option<crate::model::AutoscalingConfig>>(
)?;
}
__FieldTag::__security_config => {
if !fields.insert(__FieldTag::__security_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for security_config",
));
}
result.security_config = map
.next_value::<std::option::Option<crate::model::SecurityConfig>>(
)?;
}
__FieldTag::__lifecycle_config => {
if !fields.insert(__FieldTag::__lifecycle_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for lifecycle_config",
));
}
result.lifecycle_config = map
.next_value::<std::option::Option<crate::model::LifecycleConfig>>(
)?;
}
__FieldTag::__endpoint_config => {
if !fields.insert(__FieldTag::__endpoint_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for endpoint_config",
));
}
result.endpoint_config = map
.next_value::<std::option::Option<crate::model::EndpointConfig>>(
)?;
}
__FieldTag::__metastore_config => {
if !fields.insert(__FieldTag::__metastore_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metastore_config",
));
}
result.metastore_config = map
.next_value::<std::option::Option<crate::model::MetastoreConfig>>(
)?;
}
__FieldTag::__dataproc_metric_config => {
if !fields.insert(__FieldTag::__dataproc_metric_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dataproc_metric_config",
));
}
result.dataproc_metric_config = map.next_value::<std::option::Option<crate::model::DataprocMetricConfig>>()?
;
}
__FieldTag::__auxiliary_node_groups => {
if !fields.insert(__FieldTag::__auxiliary_node_groups) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for auxiliary_node_groups",
));
}
result.auxiliary_node_groups = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::AuxiliaryNodeGroup>,
>>()?
.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::VirtualClusterConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__staging_bucket,
__kubernetes_cluster_config,
__auxiliary_services_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 VirtualClusterConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"stagingBucket" => Ok(__FieldTag::__staging_bucket),
"staging_bucket" => Ok(__FieldTag::__staging_bucket),
"kubernetesClusterConfig" => {
Ok(__FieldTag::__kubernetes_cluster_config)
}
"kubernetes_cluster_config" => {
Ok(__FieldTag::__kubernetes_cluster_config)
}
"auxiliaryServicesConfig" => {
Ok(__FieldTag::__auxiliary_services_config)
}
"auxiliary_services_config" => {
Ok(__FieldTag::__auxiliary_services_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::VirtualClusterConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct VirtualClusterConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__staging_bucket => {
if !fields.insert(__FieldTag::__staging_bucket) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for staging_bucket",
));
}
result.staging_bucket = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__kubernetes_cluster_config => {
if !fields.insert(__FieldTag::__kubernetes_cluster_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kubernetes_cluster_config",
));
}
if result.infrastructure_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `infrastructure_config`, a oneof with full ID .google.cloud.dataproc.v1.VirtualClusterConfig.kubernetes_cluster_config, latest field was kubernetesClusterConfig",
));
}
result.infrastructure_config = std::option::Option::Some(
crate::model::virtual_cluster_config::InfrastructureConfig::KubernetesClusterConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::KubernetesClusterConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__auxiliary_services_config => {
if !fields.insert(__FieldTag::__auxiliary_services_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for auxiliary_services_config",
));
}
result.auxiliary_services_config = map.next_value::<std::option::Option<crate::model::AuxiliaryServicesConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AuxiliaryServicesConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__metastore_config,
__spark_history_server_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 AuxiliaryServicesConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"metastoreConfig" => Ok(__FieldTag::__metastore_config),
"metastore_config" => Ok(__FieldTag::__metastore_config),
"sparkHistoryServerConfig" => {
Ok(__FieldTag::__spark_history_server_config)
}
"spark_history_server_config" => {
Ok(__FieldTag::__spark_history_server_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AuxiliaryServicesConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AuxiliaryServicesConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__metastore_config => {
if !fields.insert(__FieldTag::__metastore_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metastore_config",
));
}
result.metastore_config = map
.next_value::<std::option::Option<crate::model::MetastoreConfig>>(
)?;
}
__FieldTag::__spark_history_server_config => {
if !fields.insert(__FieldTag::__spark_history_server_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_history_server_config",
));
}
result.spark_history_server_config = map.next_value::<std::option::Option<crate::model::SparkHistoryServerConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::EndpointConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__http_ports,
__enable_http_port_access,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EndpointConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"httpPorts" => Ok(__FieldTag::__http_ports),
"http_ports" => Ok(__FieldTag::__http_ports),
"enableHttpPortAccess" => Ok(__FieldTag::__enable_http_port_access),
"enable_http_port_access" => Ok(__FieldTag::__enable_http_port_access),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::EndpointConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EndpointConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__http_ports => {
if !fields.insert(__FieldTag::__http_ports) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for http_ports",
));
}
result.http_ports = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__enable_http_port_access => {
if !fields.insert(__FieldTag::__enable_http_port_access) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_http_port_access",
));
}
result.enable_http_port_access = 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::AutoscalingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__policy_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 AutoscalingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"policyUri" => Ok(__FieldTag::__policy_uri),
"policy_uri" => Ok(__FieldTag::__policy_uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AutoscalingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AutoscalingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__policy_uri => {
if !fields.insert(__FieldTag::__policy_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for policy_uri",
));
}
result.policy_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::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 {
__gce_pd_kms_key_name,
__kms_key,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'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 {
"gcePdKmsKeyName" => Ok(__FieldTag::__gce_pd_kms_key_name),
"gce_pd_kms_key_name" => Ok(__FieldTag::__gce_pd_kms_key_name),
"kmsKey" => Ok(__FieldTag::__kms_key),
"kms_key" => Ok(__FieldTag::__kms_key),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::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::__gce_pd_kms_key_name => {
if !fields.insert(__FieldTag::__gce_pd_kms_key_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gce_pd_kms_key_name",
));
}
result.gce_pd_kms_key_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__kms_key => {
if !fields.insert(__FieldTag::__kms_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key",
));
}
result.kms_key = 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::GceClusterConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__zone_uri,
__network_uri,
__subnetwork_uri,
__internal_ip_only,
__private_ipv6_google_access,
__service_account,
__service_account_scopes,
__tags,
__metadata,
__reservation_affinity,
__node_group_affinity,
__shielded_instance_config,
__confidential_instance_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 GceClusterConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"zoneUri" => Ok(__FieldTag::__zone_uri),
"zone_uri" => Ok(__FieldTag::__zone_uri),
"networkUri" => Ok(__FieldTag::__network_uri),
"network_uri" => Ok(__FieldTag::__network_uri),
"subnetworkUri" => Ok(__FieldTag::__subnetwork_uri),
"subnetwork_uri" => Ok(__FieldTag::__subnetwork_uri),
"internalIpOnly" => Ok(__FieldTag::__internal_ip_only),
"internal_ip_only" => Ok(__FieldTag::__internal_ip_only),
"privateIpv6GoogleAccess" => {
Ok(__FieldTag::__private_ipv6_google_access)
}
"private_ipv6_google_access" => {
Ok(__FieldTag::__private_ipv6_google_access)
}
"serviceAccount" => Ok(__FieldTag::__service_account),
"service_account" => Ok(__FieldTag::__service_account),
"serviceAccountScopes" => Ok(__FieldTag::__service_account_scopes),
"service_account_scopes" => Ok(__FieldTag::__service_account_scopes),
"tags" => Ok(__FieldTag::__tags),
"metadata" => Ok(__FieldTag::__metadata),
"reservationAffinity" => Ok(__FieldTag::__reservation_affinity),
"reservation_affinity" => Ok(__FieldTag::__reservation_affinity),
"nodeGroupAffinity" => Ok(__FieldTag::__node_group_affinity),
"node_group_affinity" => Ok(__FieldTag::__node_group_affinity),
"shieldedInstanceConfig" => Ok(__FieldTag::__shielded_instance_config),
"shielded_instance_config" => {
Ok(__FieldTag::__shielded_instance_config)
}
"confidentialInstanceConfig" => {
Ok(__FieldTag::__confidential_instance_config)
}
"confidential_instance_config" => {
Ok(__FieldTag::__confidential_instance_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GceClusterConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GceClusterConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__zone_uri => {
if !fields.insert(__FieldTag::__zone_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for zone_uri",
));
}
result.zone_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__network_uri => {
if !fields.insert(__FieldTag::__network_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_uri",
));
}
result.network_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__subnetwork_uri => {
if !fields.insert(__FieldTag::__subnetwork_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subnetwork_uri",
));
}
result.subnetwork_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__internal_ip_only => {
if !fields.insert(__FieldTag::__internal_ip_only) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for internal_ip_only",
));
}
result.internal_ip_only =
map.next_value::<std::option::Option<bool>>()?;
}
__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::gce_cluster_config::PrivateIpv6GoogleAccess,
>>()?
.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::__service_account_scopes => {
if !fields.insert(__FieldTag::__service_account_scopes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_account_scopes",
));
}
result.service_account_scopes = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.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<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__metadata => {
if !fields.insert(__FieldTag::__metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metadata",
));
}
result.metadata = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__reservation_affinity => {
if !fields.insert(__FieldTag::__reservation_affinity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reservation_affinity",
));
}
result.reservation_affinity = map.next_value::<std::option::Option<crate::model::ReservationAffinity>>()?
;
}
__FieldTag::__node_group_affinity => {
if !fields.insert(__FieldTag::__node_group_affinity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group_affinity",
));
}
result.node_group_affinity = map
.next_value::<std::option::Option<crate::model::NodeGroupAffinity>>(
)?;
}
__FieldTag::__shielded_instance_config => {
if !fields.insert(__FieldTag::__shielded_instance_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for shielded_instance_config",
));
}
result.shielded_instance_config = map.next_value::<std::option::Option<crate::model::ShieldedInstanceConfig>>()?
;
}
__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::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::NodeGroupAffinity {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__node_group_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 NodeGroupAffinity")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"nodeGroupUri" => Ok(__FieldTag::__node_group_uri),
"node_group_uri" => Ok(__FieldTag::__node_group_uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NodeGroupAffinity;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NodeGroupAffinity")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__node_group_uri => {
if !fields.insert(__FieldTag::__node_group_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group_uri",
));
}
result.node_group_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::ShieldedInstanceConfig {
fn deserialize<D>(deserializer: D) -> 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_secure_boot,
__enable_vtpm,
__enable_integrity_monitoring,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ShieldedInstanceConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"enableSecureBoot" => Ok(__FieldTag::__enable_secure_boot),
"enable_secure_boot" => Ok(__FieldTag::__enable_secure_boot),
"enableVtpm" => Ok(__FieldTag::__enable_vtpm),
"enable_vtpm" => Ok(__FieldTag::__enable_vtpm),
"enableIntegrityMonitoring" => {
Ok(__FieldTag::__enable_integrity_monitoring)
}
"enable_integrity_monitoring" => {
Ok(__FieldTag::__enable_integrity_monitoring)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ShieldedInstanceConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ShieldedInstanceConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_secure_boot => {
if !fields.insert(__FieldTag::__enable_secure_boot) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_secure_boot",
));
}
result.enable_secure_boot =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__enable_vtpm => {
if !fields.insert(__FieldTag::__enable_vtpm) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_vtpm",
));
}
result.enable_vtpm = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__enable_integrity_monitoring => {
if !fields.insert(__FieldTag::__enable_integrity_monitoring) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_integrity_monitoring",
));
}
result.enable_integrity_monitoring =
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>>()?
.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::InstanceGroupConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__num_instances,
__instance_names,
__instance_references,
__image_uri,
__machine_type_uri,
__disk_config,
__is_preemptible,
__preemptibility,
__managed_group_config,
__accelerators,
__min_cpu_platform,
__min_num_instances,
__instance_flexibility_policy,
__startup_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 InstanceGroupConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"numInstances" => Ok(__FieldTag::__num_instances),
"num_instances" => Ok(__FieldTag::__num_instances),
"instanceNames" => Ok(__FieldTag::__instance_names),
"instance_names" => Ok(__FieldTag::__instance_names),
"instanceReferences" => Ok(__FieldTag::__instance_references),
"instance_references" => Ok(__FieldTag::__instance_references),
"imageUri" => Ok(__FieldTag::__image_uri),
"image_uri" => Ok(__FieldTag::__image_uri),
"machineTypeUri" => Ok(__FieldTag::__machine_type_uri),
"machine_type_uri" => Ok(__FieldTag::__machine_type_uri),
"diskConfig" => Ok(__FieldTag::__disk_config),
"disk_config" => Ok(__FieldTag::__disk_config),
"isPreemptible" => Ok(__FieldTag::__is_preemptible),
"is_preemptible" => Ok(__FieldTag::__is_preemptible),
"preemptibility" => Ok(__FieldTag::__preemptibility),
"managedGroupConfig" => Ok(__FieldTag::__managed_group_config),
"managed_group_config" => Ok(__FieldTag::__managed_group_config),
"accelerators" => Ok(__FieldTag::__accelerators),
"minCpuPlatform" => Ok(__FieldTag::__min_cpu_platform),
"min_cpu_platform" => Ok(__FieldTag::__min_cpu_platform),
"minNumInstances" => Ok(__FieldTag::__min_num_instances),
"min_num_instances" => Ok(__FieldTag::__min_num_instances),
"instanceFlexibilityPolicy" => {
Ok(__FieldTag::__instance_flexibility_policy)
}
"instance_flexibility_policy" => {
Ok(__FieldTag::__instance_flexibility_policy)
}
"startupConfig" => Ok(__FieldTag::__startup_config),
"startup_config" => Ok(__FieldTag::__startup_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InstanceGroupConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstanceGroupConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__num_instances => {
if !fields.insert(__FieldTag::__num_instances) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_instances",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.num_instances =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__instance_names => {
if !fields.insert(__FieldTag::__instance_names) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_names",
));
}
result.instance_names = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__instance_references => {
if !fields.insert(__FieldTag::__instance_references) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_references",
));
}
result.instance_references =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::InstanceReference>,
>>()?
.unwrap_or_default();
}
__FieldTag::__image_uri => {
if !fields.insert(__FieldTag::__image_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image_uri",
));
}
result.image_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__machine_type_uri => {
if !fields.insert(__FieldTag::__machine_type_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for machine_type_uri",
));
}
result.machine_type_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__disk_config => {
if !fields.insert(__FieldTag::__disk_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disk_config",
));
}
result.disk_config =
map.next_value::<std::option::Option<crate::model::DiskConfig>>()?;
}
__FieldTag::__is_preemptible => {
if !fields.insert(__FieldTag::__is_preemptible) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for is_preemptible",
));
}
result.is_preemptible = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__preemptibility => {
if !fields.insert(__FieldTag::__preemptibility) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for preemptibility",
));
}
result.preemptibility = map
.next_value::<std::option::Option<
crate::model::instance_group_config::Preemptibility,
>>()?
.unwrap_or_default();
}
__FieldTag::__managed_group_config => {
if !fields.insert(__FieldTag::__managed_group_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for managed_group_config",
));
}
result.managed_group_config = map.next_value::<std::option::Option<crate::model::ManagedGroupConfig>>()?
;
}
__FieldTag::__accelerators => {
if !fields.insert(__FieldTag::__accelerators) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for accelerators",
));
}
result.accelerators =
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>>()?
.unwrap_or_default();
}
__FieldTag::__min_num_instances => {
if !fields.insert(__FieldTag::__min_num_instances) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_num_instances",
));
}
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_num_instances =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__instance_flexibility_policy => {
if !fields.insert(__FieldTag::__instance_flexibility_policy) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_flexibility_policy",
));
}
result.instance_flexibility_policy = map.next_value::<std::option::Option<crate::model::InstanceFlexibilityPolicy>>()?
;
}
__FieldTag::__startup_config => {
if !fields.insert(__FieldTag::__startup_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for startup_config",
));
}
result.startup_config = map
.next_value::<std::option::Option<crate::model::StartupConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::StartupConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__required_registration_fraction,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StartupConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"requiredRegistrationFraction" => {
Ok(__FieldTag::__required_registration_fraction)
}
"required_registration_fraction" => {
Ok(__FieldTag::__required_registration_fraction)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::StartupConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StartupConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__required_registration_fraction => {
if !fields.insert(__FieldTag::__required_registration_fraction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for required_registration_fraction",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.required_registration_fraction = 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::InstanceReference {
fn deserialize<D>(deserializer: D) -> 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_name,
__instance_id,
__public_key,
__public_ecies_key,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InstanceReference")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"instanceName" => Ok(__FieldTag::__instance_name),
"instance_name" => Ok(__FieldTag::__instance_name),
"instanceId" => Ok(__FieldTag::__instance_id),
"instance_id" => Ok(__FieldTag::__instance_id),
"publicKey" => Ok(__FieldTag::__public_key),
"public_key" => Ok(__FieldTag::__public_key),
"publicEciesKey" => Ok(__FieldTag::__public_ecies_key),
"public_ecies_key" => Ok(__FieldTag::__public_ecies_key),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InstanceReference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstanceReference")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_name => {
if !fields.insert(__FieldTag::__instance_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_name",
));
}
result.instance_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_id => {
if !fields.insert(__FieldTag::__instance_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_id",
));
}
result.instance_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__public_key => {
if !fields.insert(__FieldTag::__public_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for public_key",
));
}
result.public_key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__public_ecies_key => {
if !fields.insert(__FieldTag::__public_ecies_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for public_ecies_key",
));
}
result.public_ecies_key = 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::ManagedGroupConfig {
fn deserialize<D>(deserializer: D) -> 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_template_name,
__instance_group_manager_name,
__instance_group_manager_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 ManagedGroupConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"instanceTemplateName" => Ok(__FieldTag::__instance_template_name),
"instance_template_name" => Ok(__FieldTag::__instance_template_name),
"instanceGroupManagerName" => {
Ok(__FieldTag::__instance_group_manager_name)
}
"instance_group_manager_name" => {
Ok(__FieldTag::__instance_group_manager_name)
}
"instanceGroupManagerUri" => {
Ok(__FieldTag::__instance_group_manager_uri)
}
"instance_group_manager_uri" => {
Ok(__FieldTag::__instance_group_manager_uri)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ManagedGroupConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ManagedGroupConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_template_name => {
if !fields.insert(__FieldTag::__instance_template_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_template_name",
));
}
result.instance_template_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_group_manager_name => {
if !fields.insert(__FieldTag::__instance_group_manager_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_group_manager_name",
));
}
result.instance_group_manager_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_group_manager_uri => {
if !fields.insert(__FieldTag::__instance_group_manager_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_group_manager_uri",
));
}
result.instance_group_manager_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::InstanceFlexibilityPolicy {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__provisioning_model_mix,
__instance_selection_list,
__instance_selection_results,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InstanceFlexibilityPolicy")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"provisioningModelMix" => Ok(__FieldTag::__provisioning_model_mix),
"provisioning_model_mix" => Ok(__FieldTag::__provisioning_model_mix),
"instanceSelectionList" => Ok(__FieldTag::__instance_selection_list),
"instance_selection_list" => Ok(__FieldTag::__instance_selection_list),
"instanceSelectionResults" => {
Ok(__FieldTag::__instance_selection_results)
}
"instance_selection_results" => {
Ok(__FieldTag::__instance_selection_results)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InstanceFlexibilityPolicy;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstanceFlexibilityPolicy")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__provisioning_model_mix => {
if !fields.insert(__FieldTag::__provisioning_model_mix) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provisioning_model_mix",
));
}
result.provisioning_model_mix = map.next_value::<std::option::Option<
crate::model::instance_flexibility_policy::ProvisioningModelMix,
>>()?;
}
__FieldTag::__instance_selection_list => {
if !fields.insert(__FieldTag::__instance_selection_list) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_selection_list",
));
}
result.instance_selection_list = map.next_value::<std::option::Option<std::vec::Vec<crate::model::instance_flexibility_policy::InstanceSelection>>>()?.unwrap_or_default();
}
__FieldTag::__instance_selection_results => {
if !fields.insert(__FieldTag::__instance_selection_results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_selection_results",
));
}
result.instance_selection_results = map.next_value::<std::option::Option<std::vec::Vec<crate::model::instance_flexibility_policy::InstanceSelectionResult>>>()?.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::instance_flexibility_policy::ProvisioningModelMix {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__standard_capacity_base,
__standard_capacity_percent_above_base,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ProvisioningModelMix")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"standardCapacityBase" => Ok(__FieldTag::__standard_capacity_base),
"standard_capacity_base" => Ok(__FieldTag::__standard_capacity_base),
"standardCapacityPercentAboveBase" => {
Ok(__FieldTag::__standard_capacity_percent_above_base)
}
"standard_capacity_percent_above_base" => {
Ok(__FieldTag::__standard_capacity_percent_above_base)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::instance_flexibility_policy::ProvisioningModelMix;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ProvisioningModelMix")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__standard_capacity_base => {
if !fields.insert(__FieldTag::__standard_capacity_base) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for standard_capacity_base",
));
}
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.standard_capacity_base = map.next_value::<__With>()?.0;
}
__FieldTag::__standard_capacity_percent_above_base => {
if !fields.insert(__FieldTag::__standard_capacity_percent_above_base) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for standard_capacity_percent_above_base",
));
}
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.standard_capacity_percent_above_base =
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::instance_flexibility_policy::InstanceSelection {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__machine_types,
__rank,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InstanceSelection")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"machineTypes" => Ok(__FieldTag::__machine_types),
"machine_types" => Ok(__FieldTag::__machine_types),
"rank" => Ok(__FieldTag::__rank),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::instance_flexibility_policy::InstanceSelection;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstanceSelection")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__machine_types => {
if !fields.insert(__FieldTag::__machine_types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for machine_types",
));
}
result.machine_types = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__rank => {
if !fields.insert(__FieldTag::__rank) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rank",
));
}
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.rank = 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::instance_flexibility_policy::InstanceSelectionResult
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__machine_type,
__vm_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 InstanceSelectionResult")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"machineType" => Ok(__FieldTag::__machine_type),
"machine_type" => Ok(__FieldTag::__machine_type),
"vmCount" => Ok(__FieldTag::__vm_count),
"vm_count" => Ok(__FieldTag::__vm_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::instance_flexibility_policy::InstanceSelectionResult;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstanceSelectionResult")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::__vm_count => {
if !fields.insert(__FieldTag::__vm_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for vm_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.vm_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::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_uri,
__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 {
"acceleratorTypeUri" => Ok(__FieldTag::__accelerator_type_uri),
"accelerator_type_uri" => Ok(__FieldTag::__accelerator_type_uri),
"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_uri => {
if !fields.insert(__FieldTag::__accelerator_type_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for accelerator_type_uri",
));
}
result.accelerator_type_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__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.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::DiskConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__boot_disk_type,
__boot_disk_size_gb,
__num_local_ssds,
__local_ssd_interface,
__boot_disk_provisioned_iops,
__boot_disk_provisioned_throughput,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DiskConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"bootDiskType" => Ok(__FieldTag::__boot_disk_type),
"boot_disk_type" => Ok(__FieldTag::__boot_disk_type),
"bootDiskSizeGb" => Ok(__FieldTag::__boot_disk_size_gb),
"boot_disk_size_gb" => Ok(__FieldTag::__boot_disk_size_gb),
"numLocalSsds" => Ok(__FieldTag::__num_local_ssds),
"num_local_ssds" => Ok(__FieldTag::__num_local_ssds),
"localSsdInterface" => Ok(__FieldTag::__local_ssd_interface),
"local_ssd_interface" => Ok(__FieldTag::__local_ssd_interface),
"bootDiskProvisionedIops" => {
Ok(__FieldTag::__boot_disk_provisioned_iops)
}
"boot_disk_provisioned_iops" => {
Ok(__FieldTag::__boot_disk_provisioned_iops)
}
"bootDiskProvisionedThroughput" => {
Ok(__FieldTag::__boot_disk_provisioned_throughput)
}
"boot_disk_provisioned_throughput" => {
Ok(__FieldTag::__boot_disk_provisioned_throughput)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DiskConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DiskConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__boot_disk_type => {
if !fields.insert(__FieldTag::__boot_disk_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boot_disk_type",
));
}
result.boot_disk_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boot_disk_size_gb => {
if !fields.insert(__FieldTag::__boot_disk_size_gb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boot_disk_size_gb",
));
}
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.boot_disk_size_gb =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__num_local_ssds => {
if !fields.insert(__FieldTag::__num_local_ssds) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_local_ssds",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.num_local_ssds =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__local_ssd_interface => {
if !fields.insert(__FieldTag::__local_ssd_interface) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for local_ssd_interface",
));
}
result.local_ssd_interface = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boot_disk_provisioned_iops => {
if !fields.insert(__FieldTag::__boot_disk_provisioned_iops) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boot_disk_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.boot_disk_provisioned_iops = map.next_value::<__With>()?.0;
}
__FieldTag::__boot_disk_provisioned_throughput => {
if !fields.insert(__FieldTag::__boot_disk_provisioned_throughput) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boot_disk_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.boot_disk_provisioned_throughput = 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::AuxiliaryNodeGroup {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__node_group,
__node_group_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 AuxiliaryNodeGroup")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"nodeGroup" => Ok(__FieldTag::__node_group),
"node_group" => Ok(__FieldTag::__node_group),
"nodeGroupId" => Ok(__FieldTag::__node_group_id),
"node_group_id" => Ok(__FieldTag::__node_group_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AuxiliaryNodeGroup;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AuxiliaryNodeGroup")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__node_group => {
if !fields.insert(__FieldTag::__node_group) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group",
));
}
result.node_group =
map.next_value::<std::option::Option<crate::model::NodeGroup>>()?;
}
__FieldTag::__node_group_id => {
if !fields.insert(__FieldTag::__node_group_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group_id",
));
}
result.node_group_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::NodeGroup {
fn deserialize<D>(deserializer: D) -> 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,
__roles,
__node_group_config,
__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 NodeGroup")
}
fn visit_str<E>(self, 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),
"roles" => Ok(__FieldTag::__roles),
"nodeGroupConfig" => Ok(__FieldTag::__node_group_config),
"node_group_config" => Ok(__FieldTag::__node_group_config),
"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::NodeGroup;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NodeGroup")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__roles => {
if !fields.insert(__FieldTag::__roles) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for roles",
));
}
result.roles =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::node_group::Role>,
>>()?
.unwrap_or_default();
}
__FieldTag::__node_group_config => {
if !fields.insert(__FieldTag::__node_group_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group_config",
));
}
result.node_group_config = map.next_value::<std::option::Option<crate::model::InstanceGroupConfig>>()?
;
}
__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::NodeInitializationAction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__executable_file,
__execution_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 NodeInitializationAction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"executableFile" => Ok(__FieldTag::__executable_file),
"executable_file" => Ok(__FieldTag::__executable_file),
"executionTimeout" => Ok(__FieldTag::__execution_timeout),
"execution_timeout" => Ok(__FieldTag::__execution_timeout),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NodeInitializationAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NodeInitializationAction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__executable_file => {
if !fields.insert(__FieldTag::__executable_file) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for executable_file",
));
}
result.executable_file = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__execution_timeout => {
if !fields.insert(__FieldTag::__execution_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for execution_timeout",
));
}
result.execution_timeout =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ClusterStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__state,
__detail,
__state_start_time,
__substate,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ClusterStatus")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"state" => Ok(__FieldTag::__state),
"detail" => Ok(__FieldTag::__detail),
"stateStartTime" => Ok(__FieldTag::__state_start_time),
"state_start_time" => Ok(__FieldTag::__state_start_time),
"substate" => Ok(__FieldTag::__substate),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClusterStatus;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClusterStatus")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::cluster_status::State>>()?.unwrap_or_default();
}
__FieldTag::__detail => {
if !fields.insert(__FieldTag::__detail) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for detail",
));
}
result.detail = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_start_time => {
if !fields.insert(__FieldTag::__state_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_start_time",
));
}
result.state_start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__substate => {
if !fields.insert(__FieldTag::__substate) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for substate",
));
}
result.substate = map.next_value::<std::option::Option<crate::model::cluster_status::Substate>>()?.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::SecurityConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__kerberos_config,
__identity_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 SecurityConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"kerberosConfig" => Ok(__FieldTag::__kerberos_config),
"kerberos_config" => Ok(__FieldTag::__kerberos_config),
"identityConfig" => Ok(__FieldTag::__identity_config),
"identity_config" => Ok(__FieldTag::__identity_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SecurityConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SecurityConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__kerberos_config => {
if !fields.insert(__FieldTag::__kerberos_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kerberos_config",
));
}
result.kerberos_config = map
.next_value::<std::option::Option<crate::model::KerberosConfig>>(
)?;
}
__FieldTag::__identity_config => {
if !fields.insert(__FieldTag::__identity_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_config",
));
}
result.identity_config = map
.next_value::<std::option::Option<crate::model::IdentityConfig>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::KerberosConfig {
fn deserialize<D>(deserializer: D) -> 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_kerberos,
__root_principal_password_uri,
__kms_key_uri,
__keystore_uri,
__truststore_uri,
__keystore_password_uri,
__key_password_uri,
__truststore_password_uri,
__cross_realm_trust_realm,
__cross_realm_trust_kdc,
__cross_realm_trust_admin_server,
__cross_realm_trust_shared_password_uri,
__kdc_db_key_uri,
__tgt_lifetime_hours,
__realm,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for KerberosConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"enableKerberos" => Ok(__FieldTag::__enable_kerberos),
"enable_kerberos" => Ok(__FieldTag::__enable_kerberos),
"rootPrincipalPasswordUri" => {
Ok(__FieldTag::__root_principal_password_uri)
}
"root_principal_password_uri" => {
Ok(__FieldTag::__root_principal_password_uri)
}
"kmsKeyUri" => Ok(__FieldTag::__kms_key_uri),
"kms_key_uri" => Ok(__FieldTag::__kms_key_uri),
"keystoreUri" => Ok(__FieldTag::__keystore_uri),
"keystore_uri" => Ok(__FieldTag::__keystore_uri),
"truststoreUri" => Ok(__FieldTag::__truststore_uri),
"truststore_uri" => Ok(__FieldTag::__truststore_uri),
"keystorePasswordUri" => Ok(__FieldTag::__keystore_password_uri),
"keystore_password_uri" => Ok(__FieldTag::__keystore_password_uri),
"keyPasswordUri" => Ok(__FieldTag::__key_password_uri),
"key_password_uri" => Ok(__FieldTag::__key_password_uri),
"truststorePasswordUri" => Ok(__FieldTag::__truststore_password_uri),
"truststore_password_uri" => Ok(__FieldTag::__truststore_password_uri),
"crossRealmTrustRealm" => Ok(__FieldTag::__cross_realm_trust_realm),
"cross_realm_trust_realm" => Ok(__FieldTag::__cross_realm_trust_realm),
"crossRealmTrustKdc" => Ok(__FieldTag::__cross_realm_trust_kdc),
"cross_realm_trust_kdc" => Ok(__FieldTag::__cross_realm_trust_kdc),
"crossRealmTrustAdminServer" => {
Ok(__FieldTag::__cross_realm_trust_admin_server)
}
"cross_realm_trust_admin_server" => {
Ok(__FieldTag::__cross_realm_trust_admin_server)
}
"crossRealmTrustSharedPasswordUri" => {
Ok(__FieldTag::__cross_realm_trust_shared_password_uri)
}
"cross_realm_trust_shared_password_uri" => {
Ok(__FieldTag::__cross_realm_trust_shared_password_uri)
}
"kdcDbKeyUri" => Ok(__FieldTag::__kdc_db_key_uri),
"kdc_db_key_uri" => Ok(__FieldTag::__kdc_db_key_uri),
"tgtLifetimeHours" => Ok(__FieldTag::__tgt_lifetime_hours),
"tgt_lifetime_hours" => Ok(__FieldTag::__tgt_lifetime_hours),
"realm" => Ok(__FieldTag::__realm),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::KerberosConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct KerberosConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_kerberos => {
if !fields.insert(__FieldTag::__enable_kerberos) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_kerberos",
));
}
result.enable_kerberos = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__root_principal_password_uri => {
if !fields.insert(__FieldTag::__root_principal_password_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for root_principal_password_uri",
));
}
result.root_principal_password_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__kms_key_uri => {
if !fields.insert(__FieldTag::__kms_key_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_uri",
));
}
result.kms_key_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__keystore_uri => {
if !fields.insert(__FieldTag::__keystore_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for keystore_uri",
));
}
result.keystore_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__truststore_uri => {
if !fields.insert(__FieldTag::__truststore_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for truststore_uri",
));
}
result.truststore_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__keystore_password_uri => {
if !fields.insert(__FieldTag::__keystore_password_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for keystore_password_uri",
));
}
result.keystore_password_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__key_password_uri => {
if !fields.insert(__FieldTag::__key_password_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key_password_uri",
));
}
result.key_password_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__truststore_password_uri => {
if !fields.insert(__FieldTag::__truststore_password_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for truststore_password_uri",
));
}
result.truststore_password_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cross_realm_trust_realm => {
if !fields.insert(__FieldTag::__cross_realm_trust_realm) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cross_realm_trust_realm",
));
}
result.cross_realm_trust_realm = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cross_realm_trust_kdc => {
if !fields.insert(__FieldTag::__cross_realm_trust_kdc) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cross_realm_trust_kdc",
));
}
result.cross_realm_trust_kdc = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cross_realm_trust_admin_server => {
if !fields.insert(__FieldTag::__cross_realm_trust_admin_server) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cross_realm_trust_admin_server",
));
}
result.cross_realm_trust_admin_server = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cross_realm_trust_shared_password_uri => {
if !fields.insert(__FieldTag::__cross_realm_trust_shared_password_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cross_realm_trust_shared_password_uri",
));
}
result.cross_realm_trust_shared_password_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__kdc_db_key_uri => {
if !fields.insert(__FieldTag::__kdc_db_key_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kdc_db_key_uri",
));
}
result.kdc_db_key_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__tgt_lifetime_hours => {
if !fields.insert(__FieldTag::__tgt_lifetime_hours) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tgt_lifetime_hours",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.tgt_lifetime_hours =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__realm => {
if !fields.insert(__FieldTag::__realm) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for realm",
));
}
result.realm = 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::IdentityConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_service_account_mapping,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for IdentityConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userServiceAccountMapping" => {
Ok(__FieldTag::__user_service_account_mapping)
}
"user_service_account_mapping" => {
Ok(__FieldTag::__user_service_account_mapping)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::IdentityConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct IdentityConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_service_account_mapping => {
if !fields.insert(__FieldTag::__user_service_account_mapping) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_service_account_mapping",
));
}
result.user_service_account_mapping = 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::SoftwareConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__image_version,
__properties,
__optional_components,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SoftwareConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"imageVersion" => Ok(__FieldTag::__image_version),
"image_version" => Ok(__FieldTag::__image_version),
"properties" => Ok(__FieldTag::__properties),
"optionalComponents" => Ok(__FieldTag::__optional_components),
"optional_components" => Ok(__FieldTag::__optional_components),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SoftwareConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SoftwareConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__image_version => {
if !fields.insert(__FieldTag::__image_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image_version",
));
}
result.image_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__optional_components => {
if !fields.insert(__FieldTag::__optional_components) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for optional_components",
));
}
result.optional_components = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Component>>>()?.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::LifecycleConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__idle_delete_ttl,
__auto_delete_time,
__auto_delete_ttl,
__idle_start_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 LifecycleConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"idleDeleteTtl" => Ok(__FieldTag::__idle_delete_ttl),
"idle_delete_ttl" => Ok(__FieldTag::__idle_delete_ttl),
"autoDeleteTime" => Ok(__FieldTag::__auto_delete_time),
"auto_delete_time" => Ok(__FieldTag::__auto_delete_time),
"autoDeleteTtl" => Ok(__FieldTag::__auto_delete_ttl),
"auto_delete_ttl" => Ok(__FieldTag::__auto_delete_ttl),
"idleStartTime" => Ok(__FieldTag::__idle_start_time),
"idle_start_time" => Ok(__FieldTag::__idle_start_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LifecycleConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LifecycleConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__idle_delete_ttl => {
if !fields.insert(__FieldTag::__idle_delete_ttl) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for idle_delete_ttl",
));
}
result.idle_delete_ttl =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__auto_delete_time => {
if !fields.insert(__FieldTag::__auto_delete_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for auto_delete_time",
));
}
if result.ttl.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `ttl`, a oneof with full ID .google.cloud.dataproc.v1.LifecycleConfig.auto_delete_time, latest field was autoDeleteTime",
));
}
result.ttl = std::option::Option::Some(
crate::model::lifecycle_config::Ttl::AutoDeleteTime(
map.next_value::<std::option::Option<std::boxed::Box<wkt::Timestamp>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__auto_delete_ttl => {
if !fields.insert(__FieldTag::__auto_delete_ttl) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for auto_delete_ttl",
));
}
if result.ttl.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `ttl`, a oneof with full ID .google.cloud.dataproc.v1.LifecycleConfig.auto_delete_ttl, latest field was autoDeleteTtl",
));
}
result.ttl = std::option::Option::Some(
crate::model::lifecycle_config::Ttl::AutoDeleteTtl(
map.next_value::<std::option::Option<std::boxed::Box<wkt::Duration>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__idle_start_time => {
if !fields.insert(__FieldTag::__idle_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for idle_start_time",
));
}
result.idle_start_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::MetastoreConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__dataproc_metastore_service,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for MetastoreConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataprocMetastoreService" => {
Ok(__FieldTag::__dataproc_metastore_service)
}
"dataproc_metastore_service" => {
Ok(__FieldTag::__dataproc_metastore_service)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MetastoreConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MetastoreConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__dataproc_metastore_service => {
if !fields.insert(__FieldTag::__dataproc_metastore_service) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dataproc_metastore_service",
));
}
result.dataproc_metastore_service = 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::ClusterMetrics {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__hdfs_metrics,
__yarn_metrics,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ClusterMetrics")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"hdfsMetrics" => Ok(__FieldTag::__hdfs_metrics),
"hdfs_metrics" => Ok(__FieldTag::__hdfs_metrics),
"yarnMetrics" => Ok(__FieldTag::__yarn_metrics),
"yarn_metrics" => Ok(__FieldTag::__yarn_metrics),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClusterMetrics;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClusterMetrics")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__hdfs_metrics => {
if !fields.insert(__FieldTag::__hdfs_metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hdfs_metrics",
));
}
struct __With(
std::option::Option<
std::collections::HashMap<std::string::String, i64>,
>,
);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<
std::collections::HashMap<
serde_with::Same,
wkt::internal::I64,
>,
>,
>::deserialize(deserializer)
.map(__With)
}
}
result.hdfs_metrics = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__yarn_metrics => {
if !fields.insert(__FieldTag::__yarn_metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for yarn_metrics",
));
}
struct __With(
std::option::Option<
std::collections::HashMap<std::string::String, i64>,
>,
);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<
std::collections::HashMap<
serde_with::Same,
wkt::internal::I64,
>,
>,
>::deserialize(deserializer)
.map(__With)
}
}
result.yarn_metrics = 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::DataprocMetricConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__metrics,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DataprocMetricConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"metrics" => Ok(__FieldTag::__metrics),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataprocMetricConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataprocMetricConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__metrics => {
if !fields.insert(__FieldTag::__metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metrics",
));
}
result.metrics = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::dataproc_metric_config::Metric>,
>>()?
.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::dataproc_metric_config::Metric {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__metric_source,
__metric_overrides,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Metric")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"metricSource" => Ok(__FieldTag::__metric_source),
"metric_source" => Ok(__FieldTag::__metric_source),
"metricOverrides" => Ok(__FieldTag::__metric_overrides),
"metric_overrides" => Ok(__FieldTag::__metric_overrides),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::dataproc_metric_config::Metric;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Metric")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__metric_source => {
if !fields.insert(__FieldTag::__metric_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metric_source",
));
}
result.metric_source = map
.next_value::<std::option::Option<
crate::model::dataproc_metric_config::MetricSource,
>>()?
.unwrap_or_default();
}
__FieldTag::__metric_overrides => {
if !fields.insert(__FieldTag::__metric_overrides) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metric_overrides",
));
}
result.metric_overrides = 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::CreateClusterRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__cluster,
__request_id,
__action_on_failed_primary_workers,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateClusterRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"cluster" => Ok(__FieldTag::__cluster),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"actionOnFailedPrimaryWorkers" => {
Ok(__FieldTag::__action_on_failed_primary_workers)
}
"action_on_failed_primary_workers" => {
Ok(__FieldTag::__action_on_failed_primary_workers)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateClusterRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateClusterRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__cluster => {
if !fields.insert(__FieldTag::__cluster) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster",
));
}
result.cluster =
map.next_value::<std::option::Option<crate::model::Cluster>>()?;
}
__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::__action_on_failed_primary_workers => {
if !fields.insert(__FieldTag::__action_on_failed_primary_workers) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for action_on_failed_primary_workers",
));
}
result.action_on_failed_primary_workers = map
.next_value::<std::option::Option<crate::model::FailureAction>>()?
.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::UpdateClusterRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__cluster_name,
__cluster,
__graceful_decommission_timeout,
__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 UpdateClusterRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"cluster" => Ok(__FieldTag::__cluster),
"gracefulDecommissionTimeout" => {
Ok(__FieldTag::__graceful_decommission_timeout)
}
"graceful_decommission_timeout" => {
Ok(__FieldTag::__graceful_decommission_timeout)
}
"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::UpdateClusterRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateClusterRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster => {
if !fields.insert(__FieldTag::__cluster) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster",
));
}
result.cluster =
map.next_value::<std::option::Option<crate::model::Cluster>>()?;
}
__FieldTag::__graceful_decommission_timeout => {
if !fields.insert(__FieldTag::__graceful_decommission_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for graceful_decommission_timeout",
));
}
result.graceful_decommission_timeout =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__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::StopClusterRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__cluster_name,
__cluster_uuid,
__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 StopClusterRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"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::StopClusterRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StopClusterRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = 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::StartClusterRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__cluster_name,
__cluster_uuid,
__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 StartClusterRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"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::StartClusterRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StartClusterRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = 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::DeleteClusterRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__cluster_name,
__cluster_uuid,
__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 DeleteClusterRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"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::DeleteClusterRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteClusterRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = 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::GetClusterRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__cluster_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 GetClusterRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetClusterRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetClusterRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_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::ListClustersRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__filter,
__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 ListClustersRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"filter" => Ok(__FieldTag::__filter),
"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::ListClustersRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListClustersRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__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::__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::ListClustersResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__clusters,
__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 ListClustersResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"clusters" => Ok(__FieldTag::__clusters),
"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::ListClustersResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListClustersResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__clusters => {
if !fields.insert(__FieldTag::__clusters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for clusters",
));
}
result.clusters = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Cluster>>>()?.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::DiagnoseClusterRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__cluster_name,
__tarball_gcs_dir,
__tarball_access,
__diagnosis_interval,
__jobs,
__yarn_application_ids,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DiagnoseClusterRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"tarballGcsDir" => Ok(__FieldTag::__tarball_gcs_dir),
"tarball_gcs_dir" => Ok(__FieldTag::__tarball_gcs_dir),
"tarballAccess" => Ok(__FieldTag::__tarball_access),
"tarball_access" => Ok(__FieldTag::__tarball_access),
"diagnosisInterval" => Ok(__FieldTag::__diagnosis_interval),
"diagnosis_interval" => Ok(__FieldTag::__diagnosis_interval),
"jobs" => Ok(__FieldTag::__jobs),
"yarnApplicationIds" => Ok(__FieldTag::__yarn_application_ids),
"yarn_application_ids" => Ok(__FieldTag::__yarn_application_ids),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DiagnoseClusterRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DiagnoseClusterRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__tarball_gcs_dir => {
if !fields.insert(__FieldTag::__tarball_gcs_dir) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tarball_gcs_dir",
));
}
result.tarball_gcs_dir = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__tarball_access => {
if !fields.insert(__FieldTag::__tarball_access) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tarball_access",
));
}
result.tarball_access = map
.next_value::<std::option::Option<
crate::model::diagnose_cluster_request::TarballAccess,
>>()?
.unwrap_or_default();
}
__FieldTag::__diagnosis_interval => {
if !fields.insert(__FieldTag::__diagnosis_interval) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for diagnosis_interval",
));
}
result.diagnosis_interval = map.next_value::<std::option::Option<google_cloud_type::model::Interval>>()?
;
}
__FieldTag::__jobs => {
if !fields.insert(__FieldTag::__jobs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jobs",
));
}
result.jobs = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__yarn_application_ids => {
if !fields.insert(__FieldTag::__yarn_application_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for yarn_application_ids",
));
}
result.yarn_application_ids = 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::DiagnoseClusterResults {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__output_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 DiagnoseClusterResults")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"outputUri" => Ok(__FieldTag::__output_uri),
"output_uri" => Ok(__FieldTag::__output_uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DiagnoseClusterResults;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DiagnoseClusterResults")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__output_uri => {
if !fields.insert(__FieldTag::__output_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for output_uri",
));
}
result.output_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::ReservationAffinity {
fn deserialize<D>(deserializer: D) -> 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_reservation_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 ReservationAffinity")
}
fn visit_str<E>(self, 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_reservation_type),
"consume_reservation_type" => {
Ok(__FieldTag::__consume_reservation_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::ReservationAffinity;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ReservationAffinity")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_reservation_type => {
if !fields.insert(__FieldTag::__consume_reservation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for consume_reservation_type",
));
}
result.consume_reservation_type = map.next_value::<std::option::Option<crate::model::reservation_affinity::Type>>()?.unwrap_or_default();
}
__FieldTag::__key => {
if !fields.insert(__FieldTag::__key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key",
));
}
result.key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__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::LoggingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__driver_log_levels,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for LoggingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"driverLogLevels" => Ok(__FieldTag::__driver_log_levels),
"driver_log_levels" => Ok(__FieldTag::__driver_log_levels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::LoggingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LoggingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__driver_log_levels => {
if !fields.insert(__FieldTag::__driver_log_levels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for driver_log_levels",
));
}
result.driver_log_levels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::logging_config::Level,
>,
>>()?
.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::HadoopJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_jar_file_uri,
__main_class,
__args,
__jar_file_uris,
__file_uris,
__archive_uris,
__properties,
__logging_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 HadoopJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainJarFileUri" => Ok(__FieldTag::__main_jar_file_uri),
"main_jar_file_uri" => Ok(__FieldTag::__main_jar_file_uri),
"mainClass" => Ok(__FieldTag::__main_class),
"main_class" => Ok(__FieldTag::__main_class),
"args" => Ok(__FieldTag::__args),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"fileUris" => Ok(__FieldTag::__file_uris),
"file_uris" => Ok(__FieldTag::__file_uris),
"archiveUris" => Ok(__FieldTag::__archive_uris),
"archive_uris" => Ok(__FieldTag::__archive_uris),
"properties" => Ok(__FieldTag::__properties),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::HadoopJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct HadoopJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_jar_file_uri => {
if !fields.insert(__FieldTag::__main_jar_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_jar_file_uri",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.HadoopJob.main_jar_file_uri, latest field was mainJarFileUri",
));
}
result.driver = std::option::Option::Some(
crate::model::hadoop_job::Driver::MainJarFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__main_class => {
if !fields.insert(__FieldTag::__main_class) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_class",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.HadoopJob.main_class, latest field was mainClass",
));
}
result.driver = std::option::Option::Some(
crate::model::hadoop_job::Driver::MainClass(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__file_uris => {
if !fields.insert(__FieldTag::__file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_uris",
));
}
result.file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__archive_uris => {
if !fields.insert(__FieldTag::__archive_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for archive_uris",
));
}
result.archive_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SparkJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_jar_file_uri,
__main_class,
__args,
__jar_file_uris,
__file_uris,
__archive_uris,
__properties,
__logging_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 SparkJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainJarFileUri" => Ok(__FieldTag::__main_jar_file_uri),
"main_jar_file_uri" => Ok(__FieldTag::__main_jar_file_uri),
"mainClass" => Ok(__FieldTag::__main_class),
"main_class" => Ok(__FieldTag::__main_class),
"args" => Ok(__FieldTag::__args),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"fileUris" => Ok(__FieldTag::__file_uris),
"file_uris" => Ok(__FieldTag::__file_uris),
"archiveUris" => Ok(__FieldTag::__archive_uris),
"archive_uris" => Ok(__FieldTag::__archive_uris),
"properties" => Ok(__FieldTag::__properties),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_jar_file_uri => {
if !fields.insert(__FieldTag::__main_jar_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_jar_file_uri",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.SparkJob.main_jar_file_uri, latest field was mainJarFileUri",
));
}
result.driver = std::option::Option::Some(
crate::model::spark_job::Driver::MainJarFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__main_class => {
if !fields.insert(__FieldTag::__main_class) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_class",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.SparkJob.main_class, latest field was mainClass",
));
}
result.driver = std::option::Option::Some(
crate::model::spark_job::Driver::MainClass(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__file_uris => {
if !fields.insert(__FieldTag::__file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_uris",
));
}
result.file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__archive_uris => {
if !fields.insert(__FieldTag::__archive_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for archive_uris",
));
}
result.archive_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PySparkJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_python_file_uri,
__args,
__python_file_uris,
__jar_file_uris,
__file_uris,
__archive_uris,
__properties,
__logging_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 PySparkJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainPythonFileUri" => Ok(__FieldTag::__main_python_file_uri),
"main_python_file_uri" => Ok(__FieldTag::__main_python_file_uri),
"args" => Ok(__FieldTag::__args),
"pythonFileUris" => Ok(__FieldTag::__python_file_uris),
"python_file_uris" => Ok(__FieldTag::__python_file_uris),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"fileUris" => Ok(__FieldTag::__file_uris),
"file_uris" => Ok(__FieldTag::__file_uris),
"archiveUris" => Ok(__FieldTag::__archive_uris),
"archive_uris" => Ok(__FieldTag::__archive_uris),
"properties" => Ok(__FieldTag::__properties),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PySparkJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PySparkJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_python_file_uri => {
if !fields.insert(__FieldTag::__main_python_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_python_file_uri",
));
}
result.main_python_file_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__python_file_uris => {
if !fields.insert(__FieldTag::__python_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for python_file_uris",
));
}
result.python_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__file_uris => {
if !fields.insert(__FieldTag::__file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_uris",
));
}
result.file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__archive_uris => {
if !fields.insert(__FieldTag::__archive_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for archive_uris",
));
}
result.archive_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::QueryList {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__queries,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryList")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queries" => Ok(__FieldTag::__queries),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::QueryList;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryList")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__queries => {
if !fields.insert(__FieldTag::__queries) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for queries",
));
}
result.queries = 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::HiveJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_file_uri,
__query_list,
__continue_on_failure,
__script_variables,
__properties,
__jar_file_uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for HiveJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryFileUri" => Ok(__FieldTag::__query_file_uri),
"query_file_uri" => Ok(__FieldTag::__query_file_uri),
"queryList" => Ok(__FieldTag::__query_list),
"query_list" => Ok(__FieldTag::__query_list),
"continueOnFailure" => Ok(__FieldTag::__continue_on_failure),
"continue_on_failure" => Ok(__FieldTag::__continue_on_failure),
"scriptVariables" => Ok(__FieldTag::__script_variables),
"script_variables" => Ok(__FieldTag::__script_variables),
"properties" => Ok(__FieldTag::__properties),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::HiveJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct HiveJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_file_uri => {
if !fields.insert(__FieldTag::__query_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_file_uri",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.HiveJob.query_file_uri, latest field was queryFileUri",
));
}
result.queries = std::option::Option::Some(
crate::model::hive_job::Queries::QueryFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__query_list => {
if !fields.insert(__FieldTag::__query_list) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_list",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.HiveJob.query_list, latest field was queryList",
));
}
result.queries = std::option::Option::Some(
crate::model::hive_job::Queries::QueryList(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::QueryList>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__continue_on_failure => {
if !fields.insert(__FieldTag::__continue_on_failure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for continue_on_failure",
));
}
result.continue_on_failure = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__script_variables => {
if !fields.insert(__FieldTag::__script_variables) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for script_variables",
));
}
result.script_variables = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = 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::SparkSqlJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_file_uri,
__query_list,
__script_variables,
__properties,
__jar_file_uris,
__logging_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 SparkSqlJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryFileUri" => Ok(__FieldTag::__query_file_uri),
"query_file_uri" => Ok(__FieldTag::__query_file_uri),
"queryList" => Ok(__FieldTag::__query_list),
"query_list" => Ok(__FieldTag::__query_list),
"scriptVariables" => Ok(__FieldTag::__script_variables),
"script_variables" => Ok(__FieldTag::__script_variables),
"properties" => Ok(__FieldTag::__properties),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkSqlJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkSqlJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_file_uri => {
if !fields.insert(__FieldTag::__query_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_file_uri",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.SparkSqlJob.query_file_uri, latest field was queryFileUri",
));
}
result.queries = std::option::Option::Some(
crate::model::spark_sql_job::Queries::QueryFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__query_list => {
if !fields.insert(__FieldTag::__query_list) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_list",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.SparkSqlJob.query_list, latest field was queryList",
));
}
result.queries = std::option::Option::Some(
crate::model::spark_sql_job::Queries::QueryList(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::QueryList>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__script_variables => {
if !fields.insert(__FieldTag::__script_variables) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for script_variables",
));
}
result.script_variables = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PigJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_file_uri,
__query_list,
__continue_on_failure,
__script_variables,
__properties,
__jar_file_uris,
__logging_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 PigJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryFileUri" => Ok(__FieldTag::__query_file_uri),
"query_file_uri" => Ok(__FieldTag::__query_file_uri),
"queryList" => Ok(__FieldTag::__query_list),
"query_list" => Ok(__FieldTag::__query_list),
"continueOnFailure" => Ok(__FieldTag::__continue_on_failure),
"continue_on_failure" => Ok(__FieldTag::__continue_on_failure),
"scriptVariables" => Ok(__FieldTag::__script_variables),
"script_variables" => Ok(__FieldTag::__script_variables),
"properties" => Ok(__FieldTag::__properties),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PigJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PigJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_file_uri => {
if !fields.insert(__FieldTag::__query_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_file_uri",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.PigJob.query_file_uri, latest field was queryFileUri",
));
}
result.queries = std::option::Option::Some(
crate::model::pig_job::Queries::QueryFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__query_list => {
if !fields.insert(__FieldTag::__query_list) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_list",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.PigJob.query_list, latest field was queryList",
));
}
result.queries = std::option::Option::Some(
crate::model::pig_job::Queries::QueryList(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::QueryList>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__continue_on_failure => {
if !fields.insert(__FieldTag::__continue_on_failure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for continue_on_failure",
));
}
result.continue_on_failure = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__script_variables => {
if !fields.insert(__FieldTag::__script_variables) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for script_variables",
));
}
result.script_variables = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SparkRJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_r_file_uri,
__args,
__file_uris,
__archive_uris,
__properties,
__logging_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 SparkRJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainRFileUri" => Ok(__FieldTag::__main_r_file_uri),
"main_r_file_uri" => Ok(__FieldTag::__main_r_file_uri),
"args" => Ok(__FieldTag::__args),
"fileUris" => Ok(__FieldTag::__file_uris),
"file_uris" => Ok(__FieldTag::__file_uris),
"archiveUris" => Ok(__FieldTag::__archive_uris),
"archive_uris" => Ok(__FieldTag::__archive_uris),
"properties" => Ok(__FieldTag::__properties),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkRJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkRJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_r_file_uri => {
if !fields.insert(__FieldTag::__main_r_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_r_file_uri",
));
}
result.main_r_file_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__file_uris => {
if !fields.insert(__FieldTag::__file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_uris",
));
}
result.file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__archive_uris => {
if !fields.insert(__FieldTag::__archive_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for archive_uris",
));
}
result.archive_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PrestoJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_file_uri,
__query_list,
__continue_on_failure,
__output_format,
__client_tags,
__properties,
__logging_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 PrestoJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryFileUri" => Ok(__FieldTag::__query_file_uri),
"query_file_uri" => Ok(__FieldTag::__query_file_uri),
"queryList" => Ok(__FieldTag::__query_list),
"query_list" => Ok(__FieldTag::__query_list),
"continueOnFailure" => Ok(__FieldTag::__continue_on_failure),
"continue_on_failure" => Ok(__FieldTag::__continue_on_failure),
"outputFormat" => Ok(__FieldTag::__output_format),
"output_format" => Ok(__FieldTag::__output_format),
"clientTags" => Ok(__FieldTag::__client_tags),
"client_tags" => Ok(__FieldTag::__client_tags),
"properties" => Ok(__FieldTag::__properties),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PrestoJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PrestoJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_file_uri => {
if !fields.insert(__FieldTag::__query_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_file_uri",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.PrestoJob.query_file_uri, latest field was queryFileUri",
));
}
result.queries = std::option::Option::Some(
crate::model::presto_job::Queries::QueryFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__query_list => {
if !fields.insert(__FieldTag::__query_list) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_list",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.PrestoJob.query_list, latest field was queryList",
));
}
result.queries = std::option::Option::Some(
crate::model::presto_job::Queries::QueryList(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::QueryList>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__continue_on_failure => {
if !fields.insert(__FieldTag::__continue_on_failure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for continue_on_failure",
));
}
result.continue_on_failure = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__output_format => {
if !fields.insert(__FieldTag::__output_format) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for output_format",
));
}
result.output_format = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__client_tags => {
if !fields.insert(__FieldTag::__client_tags) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for client_tags",
));
}
result.client_tags = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TrinoJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_file_uri,
__query_list,
__continue_on_failure,
__output_format,
__client_tags,
__properties,
__logging_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 TrinoJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryFileUri" => Ok(__FieldTag::__query_file_uri),
"query_file_uri" => Ok(__FieldTag::__query_file_uri),
"queryList" => Ok(__FieldTag::__query_list),
"query_list" => Ok(__FieldTag::__query_list),
"continueOnFailure" => Ok(__FieldTag::__continue_on_failure),
"continue_on_failure" => Ok(__FieldTag::__continue_on_failure),
"outputFormat" => Ok(__FieldTag::__output_format),
"output_format" => Ok(__FieldTag::__output_format),
"clientTags" => Ok(__FieldTag::__client_tags),
"client_tags" => Ok(__FieldTag::__client_tags),
"properties" => Ok(__FieldTag::__properties),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TrinoJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TrinoJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_file_uri => {
if !fields.insert(__FieldTag::__query_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_file_uri",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.TrinoJob.query_file_uri, latest field was queryFileUri",
));
}
result.queries = std::option::Option::Some(
crate::model::trino_job::Queries::QueryFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__query_list => {
if !fields.insert(__FieldTag::__query_list) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_list",
));
}
if result.queries.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `queries`, a oneof with full ID .google.cloud.dataproc.v1.TrinoJob.query_list, latest field was queryList",
));
}
result.queries = std::option::Option::Some(
crate::model::trino_job::Queries::QueryList(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::QueryList>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__continue_on_failure => {
if !fields.insert(__FieldTag::__continue_on_failure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for continue_on_failure",
));
}
result.continue_on_failure = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__output_format => {
if !fields.insert(__FieldTag::__output_format) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for output_format",
));
}
result.output_format = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__client_tags => {
if !fields.insert(__FieldTag::__client_tags) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for client_tags",
));
}
result.client_tags = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FlinkJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__main_jar_file_uri,
__main_class,
__args,
__jar_file_uris,
__savepoint_uri,
__properties,
__logging_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 FlinkJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mainJarFileUri" => Ok(__FieldTag::__main_jar_file_uri),
"main_jar_file_uri" => Ok(__FieldTag::__main_jar_file_uri),
"mainClass" => Ok(__FieldTag::__main_class),
"main_class" => Ok(__FieldTag::__main_class),
"args" => Ok(__FieldTag::__args),
"jarFileUris" => Ok(__FieldTag::__jar_file_uris),
"jar_file_uris" => Ok(__FieldTag::__jar_file_uris),
"savepointUri" => Ok(__FieldTag::__savepoint_uri),
"savepoint_uri" => Ok(__FieldTag::__savepoint_uri),
"properties" => Ok(__FieldTag::__properties),
"loggingConfig" => Ok(__FieldTag::__logging_config),
"logging_config" => Ok(__FieldTag::__logging_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FlinkJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FlinkJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__main_jar_file_uri => {
if !fields.insert(__FieldTag::__main_jar_file_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_jar_file_uri",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.FlinkJob.main_jar_file_uri, latest field was mainJarFileUri",
));
}
result.driver = std::option::Option::Some(
crate::model::flink_job::Driver::MainJarFileUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__main_class => {
if !fields.insert(__FieldTag::__main_class) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for main_class",
));
}
if result.driver.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `driver`, a oneof with full ID .google.cloud.dataproc.v1.FlinkJob.main_class, latest field was mainClass",
));
}
result.driver = std::option::Option::Some(
crate::model::flink_job::Driver::MainClass(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__args => {
if !fields.insert(__FieldTag::__args) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for args",
));
}
result.args = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__jar_file_uris => {
if !fields.insert(__FieldTag::__jar_file_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jar_file_uris",
));
}
result.jar_file_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__savepoint_uri => {
if !fields.insert(__FieldTag::__savepoint_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for savepoint_uri",
));
}
result.savepoint_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__logging_config => {
if !fields.insert(__FieldTag::__logging_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for logging_config",
));
}
result.logging_config = map
.next_value::<std::option::Option<crate::model::LoggingConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::JobPlacement {
fn deserialize<D>(deserializer: D) -> 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_name,
__cluster_uuid,
__cluster_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 JobPlacement")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"clusterLabels" => Ok(__FieldTag::__cluster_labels),
"cluster_labels" => Ok(__FieldTag::__cluster_labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JobPlacement;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JobPlacement")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_labels => {
if !fields.insert(__FieldTag::__cluster_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_labels",
));
}
result.cluster_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::JobStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__state,
__details,
__state_start_time,
__substate,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for JobStatus")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"state" => Ok(__FieldTag::__state),
"details" => Ok(__FieldTag::__details),
"stateStartTime" => Ok(__FieldTag::__state_start_time),
"state_start_time" => Ok(__FieldTag::__state_start_time),
"substate" => Ok(__FieldTag::__substate),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JobStatus;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JobStatus")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::job_status::State>>(
)?
.unwrap_or_default();
}
__FieldTag::__details => {
if !fields.insert(__FieldTag::__details) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for details",
));
}
result.details = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_start_time => {
if !fields.insert(__FieldTag::__state_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_start_time",
));
}
result.state_start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__substate => {
if !fields.insert(__FieldTag::__substate) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for substate",
));
}
result.substate = map.next_value::<std::option::Option<crate::model::job_status::Substate>>()?.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::JobReference {
fn deserialize<D>(deserializer: D) -> 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_id,
__job_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 JobReference")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"jobId" => Ok(__FieldTag::__job_id),
"job_id" => Ok(__FieldTag::__job_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JobReference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JobReference")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__job_id => {
if !fields.insert(__FieldTag::__job_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_id",
));
}
result.job_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::YarnApplication {
fn deserialize<D>(deserializer: D) -> 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,
__progress,
__tracking_url,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for YarnApplication")
}
fn visit_str<E>(self, 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),
"progress" => Ok(__FieldTag::__progress),
"trackingUrl" => Ok(__FieldTag::__tracking_url),
"tracking_url" => Ok(__FieldTag::__tracking_url),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::YarnApplication;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct YarnApplication")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::yarn_application::State>>()?.unwrap_or_default();
}
__FieldTag::__progress => {
if !fields.insert(__FieldTag::__progress) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for progress",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.progress = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__tracking_url => {
if !fields.insert(__FieldTag::__tracking_url) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tracking_url",
));
}
result.tracking_url = 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::Job {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__reference,
__placement,
__hadoop_job,
__spark_job,
__pyspark_job,
__hive_job,
__pig_job,
__spark_r_job,
__spark_sql_job,
__presto_job,
__trino_job,
__flink_job,
__status,
__status_history,
__yarn_applications,
__driver_output_resource_uri,
__driver_control_files_uri,
__labels,
__scheduling,
__job_uuid,
__done,
__driver_scheduling_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 Job")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"reference" => Ok(__FieldTag::__reference),
"placement" => Ok(__FieldTag::__placement),
"hadoopJob" => Ok(__FieldTag::__hadoop_job),
"hadoop_job" => Ok(__FieldTag::__hadoop_job),
"sparkJob" => Ok(__FieldTag::__spark_job),
"spark_job" => Ok(__FieldTag::__spark_job),
"pysparkJob" => Ok(__FieldTag::__pyspark_job),
"pyspark_job" => Ok(__FieldTag::__pyspark_job),
"hiveJob" => Ok(__FieldTag::__hive_job),
"hive_job" => Ok(__FieldTag::__hive_job),
"pigJob" => Ok(__FieldTag::__pig_job),
"pig_job" => Ok(__FieldTag::__pig_job),
"sparkRJob" => Ok(__FieldTag::__spark_r_job),
"spark_r_job" => Ok(__FieldTag::__spark_r_job),
"sparkSqlJob" => Ok(__FieldTag::__spark_sql_job),
"spark_sql_job" => Ok(__FieldTag::__spark_sql_job),
"prestoJob" => Ok(__FieldTag::__presto_job),
"presto_job" => Ok(__FieldTag::__presto_job),
"trinoJob" => Ok(__FieldTag::__trino_job),
"trino_job" => Ok(__FieldTag::__trino_job),
"flinkJob" => Ok(__FieldTag::__flink_job),
"flink_job" => Ok(__FieldTag::__flink_job),
"status" => Ok(__FieldTag::__status),
"statusHistory" => Ok(__FieldTag::__status_history),
"status_history" => Ok(__FieldTag::__status_history),
"yarnApplications" => Ok(__FieldTag::__yarn_applications),
"yarn_applications" => Ok(__FieldTag::__yarn_applications),
"driverOutputResourceUri" => {
Ok(__FieldTag::__driver_output_resource_uri)
}
"driver_output_resource_uri" => {
Ok(__FieldTag::__driver_output_resource_uri)
}
"driverControlFilesUri" => Ok(__FieldTag::__driver_control_files_uri),
"driver_control_files_uri" => {
Ok(__FieldTag::__driver_control_files_uri)
}
"labels" => Ok(__FieldTag::__labels),
"scheduling" => Ok(__FieldTag::__scheduling),
"jobUuid" => Ok(__FieldTag::__job_uuid),
"job_uuid" => Ok(__FieldTag::__job_uuid),
"done" => Ok(__FieldTag::__done),
"driverSchedulingConfig" => Ok(__FieldTag::__driver_scheduling_config),
"driver_scheduling_config" => {
Ok(__FieldTag::__driver_scheduling_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Job;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Job")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__reference => {
if !fields.insert(__FieldTag::__reference) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reference",
));
}
result.reference = map
.next_value::<std::option::Option<crate::model::JobReference>>()?;
}
__FieldTag::__placement => {
if !fields.insert(__FieldTag::__placement) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for placement",
));
}
result.placement = map
.next_value::<std::option::Option<crate::model::JobPlacement>>()?;
}
__FieldTag::__hadoop_job => {
if !fields.insert(__FieldTag::__hadoop_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hadoop_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.hadoop_job, latest field was hadoopJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::HadoopJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::HadoopJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__spark_job => {
if !fields.insert(__FieldTag::__spark_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.spark_job, latest field was sparkJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::SparkJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__pyspark_job => {
if !fields.insert(__FieldTag::__pyspark_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pyspark_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.pyspark_job, latest field was pysparkJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::PysparkJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::PySparkJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__hive_job => {
if !fields.insert(__FieldTag::__hive_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hive_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.hive_job, latest field was hiveJob",
));
}
result.type_job =
std::option::Option::Some(
crate::model::job::TypeJob::HiveJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::HiveJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__pig_job => {
if !fields.insert(__FieldTag::__pig_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pig_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.pig_job, latest field was pigJob",
));
}
result.type_job =
std::option::Option::Some(
crate::model::job::TypeJob::PigJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::PigJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_r_job => {
if !fields.insert(__FieldTag::__spark_r_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_r_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.spark_r_job, latest field was sparkRJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::SparkRJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkRJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__spark_sql_job => {
if !fields.insert(__FieldTag::__spark_sql_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_sql_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.spark_sql_job, latest field was sparkSqlJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::SparkSqlJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkSqlJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__presto_job => {
if !fields.insert(__FieldTag::__presto_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for presto_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.presto_job, latest field was prestoJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::PrestoJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::PrestoJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__trino_job => {
if !fields.insert(__FieldTag::__trino_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for trino_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.trino_job, latest field was trinoJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::TrinoJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::TrinoJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__flink_job => {
if !fields.insert(__FieldTag::__flink_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for flink_job",
));
}
if result.type_job.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_job`, a oneof with full ID .google.cloud.dataproc.v1.Job.flink_job, latest field was flinkJob",
));
}
result.type_job =
std::option::Option::Some(crate::model::job::TypeJob::FlinkJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::FlinkJob>,
>>()?
.unwrap_or_default(),
));
}
__FieldTag::__status => {
if !fields.insert(__FieldTag::__status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status",
));
}
result.status =
map.next_value::<std::option::Option<crate::model::JobStatus>>()?;
}
__FieldTag::__status_history => {
if !fields.insert(__FieldTag::__status_history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status_history",
));
}
result.status_history = map.next_value::<std::option::Option<std::vec::Vec<crate::model::JobStatus>>>()?.unwrap_or_default();
}
__FieldTag::__yarn_applications => {
if !fields.insert(__FieldTag::__yarn_applications) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for yarn_applications",
));
}
result.yarn_applications =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::YarnApplication>,
>>()?
.unwrap_or_default();
}
__FieldTag::__driver_output_resource_uri => {
if !fields.insert(__FieldTag::__driver_output_resource_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for driver_output_resource_uri",
));
}
result.driver_output_resource_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__driver_control_files_uri => {
if !fields.insert(__FieldTag::__driver_control_files_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for driver_control_files_uri",
));
}
result.driver_control_files_uri = 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::__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::JobScheduling>>()?;
}
__FieldTag::__job_uuid => {
if !fields.insert(__FieldTag::__job_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_uuid",
));
}
result.job_uuid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__done => {
if !fields.insert(__FieldTag::__done) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for done",
));
}
result.done = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__driver_scheduling_config => {
if !fields.insert(__FieldTag::__driver_scheduling_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for driver_scheduling_config",
));
}
result.driver_scheduling_config = map.next_value::<std::option::Option<crate::model::DriverSchedulingConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DriverSchedulingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__memory_mb,
__vcores,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DriverSchedulingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"memoryMb" => Ok(__FieldTag::__memory_mb),
"memory_mb" => Ok(__FieldTag::__memory_mb),
"vcores" => Ok(__FieldTag::__vcores),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DriverSchedulingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DriverSchedulingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__memory_mb => {
if !fields.insert(__FieldTag::__memory_mb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for memory_mb",
));
}
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.memory_mb = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__vcores => {
if !fields.insert(__FieldTag::__vcores) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for vcores",
));
}
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.vcores = 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::JobScheduling {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__max_failures_per_hour,
__max_failures_total,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for JobScheduling")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"maxFailuresPerHour" => Ok(__FieldTag::__max_failures_per_hour),
"max_failures_per_hour" => Ok(__FieldTag::__max_failures_per_hour),
"maxFailuresTotal" => Ok(__FieldTag::__max_failures_total),
"max_failures_total" => Ok(__FieldTag::__max_failures_total),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JobScheduling;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JobScheduling")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__max_failures_per_hour => {
if !fields.insert(__FieldTag::__max_failures_per_hour) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_failures_per_hour",
));
}
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.max_failures_per_hour =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__max_failures_total => {
if !fields.insert(__FieldTag::__max_failures_total) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_failures_total",
));
}
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.max_failures_total =
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::SubmitJobRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__job,
__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 SubmitJobRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"job" => Ok(__FieldTag::__job),
"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::SubmitJobRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SubmitJobRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__job => {
if !fields.insert(__FieldTag::__job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job",
));
}
result.job =
map.next_value::<std::option::Option<crate::model::Job>>()?;
}
__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::JobMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__job_id,
__status,
__operation_type,
__start_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 JobMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"jobId" => Ok(__FieldTag::__job_id),
"job_id" => Ok(__FieldTag::__job_id),
"status" => Ok(__FieldTag::__status),
"operationType" => Ok(__FieldTag::__operation_type),
"operation_type" => Ok(__FieldTag::__operation_type),
"startTime" => Ok(__FieldTag::__start_time),
"start_time" => Ok(__FieldTag::__start_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JobMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JobMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__job_id => {
if !fields.insert(__FieldTag::__job_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_id",
));
}
result.job_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__status => {
if !fields.insert(__FieldTag::__status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status",
));
}
result.status =
map.next_value::<std::option::Option<crate::model::JobStatus>>()?;
}
__FieldTag::__operation_type => {
if !fields.insert(__FieldTag::__operation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation_type",
));
}
result.operation_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__start_time => {
if !fields.insert(__FieldTag::__start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_time",
));
}
result.start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetJobRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__job_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 GetJobRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"jobId" => Ok(__FieldTag::__job_id),
"job_id" => Ok(__FieldTag::__job_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetJobRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetJobRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__job_id => {
if !fields.insert(__FieldTag::__job_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_id",
));
}
result.job_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::ListJobsRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__page_size,
__page_token,
__cluster_name,
__job_state_matcher,
__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 ListJobsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"jobStateMatcher" => Ok(__FieldTag::__job_state_matcher),
"job_state_matcher" => Ok(__FieldTag::__job_state_matcher),
"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::ListJobsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListJobsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__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::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__job_state_matcher => {
if !fields.insert(__FieldTag::__job_state_matcher) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_state_matcher",
));
}
result.job_state_matcher = map
.next_value::<std::option::Option<
crate::model::list_jobs_request::JobStateMatcher,
>>()?
.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::UpdateJobRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__job_id,
__job,
__update_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 UpdateJobRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"jobId" => Ok(__FieldTag::__job_id),
"job_id" => Ok(__FieldTag::__job_id),
"job" => Ok(__FieldTag::__job),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateJobRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateJobRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__job_id => {
if !fields.insert(__FieldTag::__job_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_id",
));
}
result.job_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__job => {
if !fields.insert(__FieldTag::__job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job",
));
}
result.job =
map.next_value::<std::option::Option<crate::model::Job>>()?;
}
__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::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListJobsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__jobs,
__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 ListJobsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"jobs" => Ok(__FieldTag::__jobs),
"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::ListJobsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListJobsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__jobs => {
if !fields.insert(__FieldTag::__jobs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jobs",
));
}
result.jobs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Job>>>()?.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::CancelJobRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__job_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 CancelJobRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"jobId" => Ok(__FieldTag::__job_id),
"job_id" => Ok(__FieldTag::__job_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CancelJobRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CancelJobRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__job_id => {
if !fields.insert(__FieldTag::__job_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_id",
));
}
result.job_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::DeleteJobRequest {
fn deserialize<D>(deserializer: D) -> 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_id,
__region,
__job_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 DeleteJobRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"region" => Ok(__FieldTag::__region),
"jobId" => Ok(__FieldTag::__job_id),
"job_id" => Ok(__FieldTag::__job_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteJobRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteJobRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = 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::__job_id => {
if !fields.insert(__FieldTag::__job_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_id",
));
}
result.job_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::CreateNodeGroupRequest {
fn deserialize<D>(deserializer: D) -> 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,
__node_group,
__node_group_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 CreateNodeGroupRequest")
}
fn visit_str<E>(self, 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),
"nodeGroup" => Ok(__FieldTag::__node_group),
"node_group" => Ok(__FieldTag::__node_group),
"nodeGroupId" => Ok(__FieldTag::__node_group_id),
"node_group_id" => Ok(__FieldTag::__node_group_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::CreateNodeGroupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateNodeGroupRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__node_group => {
if !fields.insert(__FieldTag::__node_group) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group",
));
}
result.node_group =
map.next_value::<std::option::Option<crate::model::NodeGroup>>()?;
}
__FieldTag::__node_group_id => {
if !fields.insert(__FieldTag::__node_group_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group_id",
));
}
result.node_group_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::ResizeNodeGroupRequest {
fn deserialize<D>(deserializer: D) -> 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,
__size,
__request_id,
__graceful_decommission_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 ResizeNodeGroupRequest")
}
fn visit_str<E>(self, 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),
"size" => Ok(__FieldTag::__size),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"gracefulDecommissionTimeout" => {
Ok(__FieldTag::__graceful_decommission_timeout)
}
"graceful_decommission_timeout" => {
Ok(__FieldTag::__graceful_decommission_timeout)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ResizeNodeGroupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ResizeNodeGroupRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__size => {
if !fields.insert(__FieldTag::__size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for 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.size = map.next_value::<__With>()?.0.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::__graceful_decommission_timeout => {
if !fields.insert(__FieldTag::__graceful_decommission_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for graceful_decommission_timeout",
));
}
result.graceful_decommission_timeout =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetNodeGroupRequest {
fn deserialize<D>(deserializer: D) -> 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 GetNodeGroupRequest")
}
fn visit_str<E>(self, 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::GetNodeGroupRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetNodeGroupRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::BatchOperationMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__batch,
__batch_uuid,
__create_time,
__done_time,
__operation_type,
__description,
__labels,
__warnings,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchOperationMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"batch" => Ok(__FieldTag::__batch),
"batchUuid" => Ok(__FieldTag::__batch_uuid),
"batch_uuid" => Ok(__FieldTag::__batch_uuid),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"doneTime" => Ok(__FieldTag::__done_time),
"done_time" => Ok(__FieldTag::__done_time),
"operationType" => Ok(__FieldTag::__operation_type),
"operation_type" => Ok(__FieldTag::__operation_type),
"description" => Ok(__FieldTag::__description),
"labels" => Ok(__FieldTag::__labels),
"warnings" => Ok(__FieldTag::__warnings),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchOperationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchOperationMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__batch => {
if !fields.insert(__FieldTag::__batch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batch",
));
}
result.batch = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__batch_uuid => {
if !fields.insert(__FieldTag::__batch_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for batch_uuid",
));
}
result.batch_uuid = 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::__done_time => {
if !fields.insert(__FieldTag::__done_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for done_time",
));
}
result.done_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__operation_type => {
if !fields.insert(__FieldTag::__operation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation_type",
));
}
result.operation_type = map
.next_value::<std::option::Option<
crate::model::batch_operation_metadata::BatchOperationType,
>>()?
.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::__warnings => {
if !fields.insert(__FieldTag::__warnings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for warnings",
));
}
result.warnings = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SessionOperationMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__session,
__session_uuid,
__create_time,
__done_time,
__operation_type,
__description,
__labels,
__warnings,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SessionOperationMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"session" => Ok(__FieldTag::__session),
"sessionUuid" => Ok(__FieldTag::__session_uuid),
"session_uuid" => Ok(__FieldTag::__session_uuid),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"doneTime" => Ok(__FieldTag::__done_time),
"done_time" => Ok(__FieldTag::__done_time),
"operationType" => Ok(__FieldTag::__operation_type),
"operation_type" => Ok(__FieldTag::__operation_type),
"description" => Ok(__FieldTag::__description),
"labels" => Ok(__FieldTag::__labels),
"warnings" => Ok(__FieldTag::__warnings),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SessionOperationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SessionOperationMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__session_uuid => {
if !fields.insert(__FieldTag::__session_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_uuid",
));
}
result.session_uuid = 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::__done_time => {
if !fields.insert(__FieldTag::__done_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for done_time",
));
}
result.done_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__operation_type => {
if !fields.insert(__FieldTag::__operation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation_type",
));
}
result.operation_type = map
.next_value::<std::option::Option<
crate::model::session_operation_metadata::SessionOperationType,
>>()?
.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::__warnings => {
if !fields.insert(__FieldTag::__warnings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for warnings",
));
}
result.warnings = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ClusterOperationStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__state,
__inner_state,
__details,
__state_start_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 ClusterOperationStatus")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"state" => Ok(__FieldTag::__state),
"innerState" => Ok(__FieldTag::__inner_state),
"inner_state" => Ok(__FieldTag::__inner_state),
"details" => Ok(__FieldTag::__details),
"stateStartTime" => Ok(__FieldTag::__state_start_time),
"state_start_time" => Ok(__FieldTag::__state_start_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClusterOperationStatus;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClusterOperationStatus")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::cluster_operation_status::State,
>>()?
.unwrap_or_default();
}
__FieldTag::__inner_state => {
if !fields.insert(__FieldTag::__inner_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inner_state",
));
}
result.inner_state = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__details => {
if !fields.insert(__FieldTag::__details) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for details",
));
}
result.details = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_start_time => {
if !fields.insert(__FieldTag::__state_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_start_time",
));
}
result.state_start_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::ClusterOperationMetadata {
fn deserialize<D>(deserializer: D) -> 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_name,
__cluster_uuid,
__status,
__status_history,
__operation_type,
__description,
__labels,
__warnings,
__child_operation_ids,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ClusterOperationMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"status" => Ok(__FieldTag::__status),
"statusHistory" => Ok(__FieldTag::__status_history),
"status_history" => Ok(__FieldTag::__status_history),
"operationType" => Ok(__FieldTag::__operation_type),
"operation_type" => Ok(__FieldTag::__operation_type),
"description" => Ok(__FieldTag::__description),
"labels" => Ok(__FieldTag::__labels),
"warnings" => Ok(__FieldTag::__warnings),
"childOperationIds" => Ok(__FieldTag::__child_operation_ids),
"child_operation_ids" => Ok(__FieldTag::__child_operation_ids),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClusterOperationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClusterOperationMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__status => {
if !fields.insert(__FieldTag::__status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status",
));
}
result.status = map.next_value::<std::option::Option<crate::model::ClusterOperationStatus>>()?
;
}
__FieldTag::__status_history => {
if !fields.insert(__FieldTag::__status_history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status_history",
));
}
result.status_history = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::ClusterOperationStatus>,
>>()?
.unwrap_or_default();
}
__FieldTag::__operation_type => {
if !fields.insert(__FieldTag::__operation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation_type",
));
}
result.operation_type = 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::__warnings => {
if !fields.insert(__FieldTag::__warnings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for warnings",
));
}
result.warnings = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__child_operation_ids => {
if !fields.insert(__FieldTag::__child_operation_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for child_operation_ids",
));
}
result.child_operation_ids = 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::NodeGroupOperationMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__node_group_id,
__cluster_uuid,
__status,
__status_history,
__operation_type,
__description,
__labels,
__warnings,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for NodeGroupOperationMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"nodeGroupId" => Ok(__FieldTag::__node_group_id),
"node_group_id" => Ok(__FieldTag::__node_group_id),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"status" => Ok(__FieldTag::__status),
"statusHistory" => Ok(__FieldTag::__status_history),
"status_history" => Ok(__FieldTag::__status_history),
"operationType" => Ok(__FieldTag::__operation_type),
"operation_type" => Ok(__FieldTag::__operation_type),
"description" => Ok(__FieldTag::__description),
"labels" => Ok(__FieldTag::__labels),
"warnings" => Ok(__FieldTag::__warnings),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NodeGroupOperationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NodeGroupOperationMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__node_group_id => {
if !fields.insert(__FieldTag::__node_group_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_group_id",
));
}
result.node_group_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__status => {
if !fields.insert(__FieldTag::__status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status",
));
}
result.status = map.next_value::<std::option::Option<crate::model::ClusterOperationStatus>>()?
;
}
__FieldTag::__status_history => {
if !fields.insert(__FieldTag::__status_history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for status_history",
));
}
result.status_history = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::ClusterOperationStatus>,
>>()?
.unwrap_or_default();
}
__FieldTag::__operation_type => {
if !fields.insert(__FieldTag::__operation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation_type",
));
}
result.operation_type = map.next_value::<std::option::Option<crate::model::node_group_operation_metadata::NodeGroupOperationType>>()?.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::__warnings => {
if !fields.insert(__FieldTag::__warnings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for warnings",
));
}
result.warnings = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateSessionTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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,
__session_template,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateSessionTemplateRequest")
}
fn visit_str<E>(self, 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),
"sessionTemplate" => Ok(__FieldTag::__session_template),
"session_template" => Ok(__FieldTag::__session_template),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateSessionTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateSessionTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__session_template => {
if !fields.insert(__FieldTag::__session_template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_template",
));
}
result.session_template = map
.next_value::<std::option::Option<crate::model::SessionTemplate>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateSessionTemplateRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__session_template,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateSessionTemplateRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"sessionTemplate" => Ok(__FieldTag::__session_template),
"session_template" => Ok(__FieldTag::__session_template),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateSessionTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateSessionTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__session_template => {
if !fields.insert(__FieldTag::__session_template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_template",
));
}
result.session_template = map
.next_value::<std::option::Option<crate::model::SessionTemplate>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetSessionTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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 GetSessionTemplateRequest")
}
fn visit_str<E>(self, 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::GetSessionTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetSessionTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListSessionTemplatesRequest {
fn deserialize<D>(deserializer: D) -> 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 ListSessionTemplatesRequest")
}
fn visit_str<E>(self, 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::ListSessionTemplatesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSessionTemplatesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListSessionTemplatesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__session_templates,
__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 ListSessionTemplatesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"sessionTemplates" => Ok(__FieldTag::__session_templates),
"session_templates" => Ok(__FieldTag::__session_templates),
"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::ListSessionTemplatesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSessionTemplatesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__session_templates => {
if !fields.insert(__FieldTag::__session_templates) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_templates",
));
}
result.session_templates =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::SessionTemplate>,
>>()?
.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::DeleteSessionTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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 DeleteSessionTemplateRequest")
}
fn visit_str<E>(self, 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::DeleteSessionTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteSessionTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::SessionTemplate {
fn deserialize<D>(deserializer: D) -> 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,
__jupyter_session,
__spark_connect_session,
__creator,
__labels,
__runtime_config,
__environment_config,
__update_time,
__uuid,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SessionTemplate")
}
fn visit_str<E>(self, 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),
"jupyterSession" => Ok(__FieldTag::__jupyter_session),
"jupyter_session" => Ok(__FieldTag::__jupyter_session),
"sparkConnectSession" => Ok(__FieldTag::__spark_connect_session),
"spark_connect_session" => Ok(__FieldTag::__spark_connect_session),
"creator" => Ok(__FieldTag::__creator),
"labels" => Ok(__FieldTag::__labels),
"runtimeConfig" => Ok(__FieldTag::__runtime_config),
"runtime_config" => Ok(__FieldTag::__runtime_config),
"environmentConfig" => Ok(__FieldTag::__environment_config),
"environment_config" => Ok(__FieldTag::__environment_config),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"uuid" => Ok(__FieldTag::__uuid),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SessionTemplate;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SessionTemplate")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__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::__jupyter_session => {
if !fields.insert(__FieldTag::__jupyter_session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jupyter_session",
));
}
if result.session_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `session_config`, a oneof with full ID .google.cloud.dataproc.v1.SessionTemplate.jupyter_session, latest field was jupyterSession",
));
}
result.session_config = std::option::Option::Some(
crate::model::session_template::SessionConfig::JupyterSession(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::JupyterConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_connect_session => {
if !fields.insert(__FieldTag::__spark_connect_session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_connect_session",
));
}
if result.session_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `session_config`, a oneof with full ID .google.cloud.dataproc.v1.SessionTemplate.spark_connect_session, latest field was sparkConnectSession",
));
}
result.session_config = std::option::Option::Some(
crate::model::session_template::SessionConfig::SparkConnectSession(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkConnectConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__creator => {
if !fields.insert(__FieldTag::__creator) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for creator",
));
}
result.creator = 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::__runtime_config => {
if !fields.insert(__FieldTag::__runtime_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for runtime_config",
));
}
result.runtime_config = map
.next_value::<std::option::Option<crate::model::RuntimeConfig>>()?;
}
__FieldTag::__environment_config => {
if !fields.insert(__FieldTag::__environment_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for environment_config",
));
}
result.environment_config = map
.next_value::<std::option::Option<crate::model::EnvironmentConfig>>(
)?;
}
__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::__uuid => {
if !fields.insert(__FieldTag::__uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uuid",
));
}
result.uuid = 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::CreateSessionRequest {
fn deserialize<D>(deserializer: D) -> 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,
__session,
__session_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 CreateSessionRequest")
}
fn visit_str<E>(self, 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),
"session" => Ok(__FieldTag::__session),
"sessionId" => Ok(__FieldTag::__session_id),
"session_id" => Ok(__FieldTag::__session_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::CreateSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session =
map.next_value::<std::option::Option<crate::model::Session>>()?;
}
__FieldTag::__session_id => {
if !fields.insert(__FieldTag::__session_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_id",
));
}
result.session_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::GetSessionRequest {
fn deserialize<D>(deserializer: D) -> 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 GetSessionRequest")
}
fn visit_str<E>(self, 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::GetSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListSessionsRequest {
fn deserialize<D>(deserializer: D) -> 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 ListSessionsRequest")
}
fn visit_str<E>(self, 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::ListSessionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSessionsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListSessionsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__sessions,
__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 ListSessionsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"sessions" => Ok(__FieldTag::__sessions),
"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::ListSessionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSessionsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__sessions => {
if !fields.insert(__FieldTag::__sessions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sessions",
));
}
result.sessions = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Session>>>()?.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::TerminateSessionRequest {
fn deserialize<D>(deserializer: D) -> 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 TerminateSessionRequest")
}
fn visit_str<E>(self, 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::TerminateSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TerminateSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::DeleteSessionRequest {
fn deserialize<D>(deserializer: D) -> 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 DeleteSessionRequest")
}
fn visit_str<E>(self, 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::DeleteSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::Session {
fn deserialize<D>(deserializer: D) -> 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,
__uuid,
__create_time,
__jupyter_session,
__spark_connect_session,
__runtime_info,
__state,
__state_message,
__state_time,
__creator,
__labels,
__runtime_config,
__environment_config,
__user,
__state_history,
__session_template,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Session")
}
fn visit_str<E>(self, 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),
"uuid" => Ok(__FieldTag::__uuid),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"jupyterSession" => Ok(__FieldTag::__jupyter_session),
"jupyter_session" => Ok(__FieldTag::__jupyter_session),
"sparkConnectSession" => Ok(__FieldTag::__spark_connect_session),
"spark_connect_session" => Ok(__FieldTag::__spark_connect_session),
"runtimeInfo" => Ok(__FieldTag::__runtime_info),
"runtime_info" => Ok(__FieldTag::__runtime_info),
"state" => Ok(__FieldTag::__state),
"stateMessage" => Ok(__FieldTag::__state_message),
"state_message" => Ok(__FieldTag::__state_message),
"stateTime" => Ok(__FieldTag::__state_time),
"state_time" => Ok(__FieldTag::__state_time),
"creator" => Ok(__FieldTag::__creator),
"labels" => Ok(__FieldTag::__labels),
"runtimeConfig" => Ok(__FieldTag::__runtime_config),
"runtime_config" => Ok(__FieldTag::__runtime_config),
"environmentConfig" => Ok(__FieldTag::__environment_config),
"environment_config" => Ok(__FieldTag::__environment_config),
"user" => Ok(__FieldTag::__user),
"stateHistory" => Ok(__FieldTag::__state_history),
"state_history" => Ok(__FieldTag::__state_history),
"sessionTemplate" => Ok(__FieldTag::__session_template),
"session_template" => Ok(__FieldTag::__session_template),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Session;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Session")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__uuid => {
if !fields.insert(__FieldTag::__uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uuid",
));
}
result.uuid = 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::__jupyter_session => {
if !fields.insert(__FieldTag::__jupyter_session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jupyter_session",
));
}
if result.session_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `session_config`, a oneof with full ID .google.cloud.dataproc.v1.Session.jupyter_session, latest field was jupyterSession",
));
}
result.session_config = std::option::Option::Some(
crate::model::session::SessionConfig::JupyterSession(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::JupyterConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_connect_session => {
if !fields.insert(__FieldTag::__spark_connect_session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_connect_session",
));
}
if result.session_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `session_config`, a oneof with full ID .google.cloud.dataproc.v1.Session.spark_connect_session, latest field was sparkConnectSession",
));
}
result.session_config = std::option::Option::Some(
crate::model::session::SessionConfig::SparkConnectSession(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkConnectConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__runtime_info => {
if !fields.insert(__FieldTag::__runtime_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for runtime_info",
));
}
result.runtime_info =
map.next_value::<std::option::Option<crate::model::RuntimeInfo>>()?;
}
__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::session::State>>()?
.unwrap_or_default();
}
__FieldTag::__state_message => {
if !fields.insert(__FieldTag::__state_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_message",
));
}
result.state_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_time => {
if !fields.insert(__FieldTag::__state_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_time",
));
}
result.state_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__creator => {
if !fields.insert(__FieldTag::__creator) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for creator",
));
}
result.creator = 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::__runtime_config => {
if !fields.insert(__FieldTag::__runtime_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for runtime_config",
));
}
result.runtime_config = map
.next_value::<std::option::Option<crate::model::RuntimeConfig>>()?;
}
__FieldTag::__environment_config => {
if !fields.insert(__FieldTag::__environment_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for environment_config",
));
}
result.environment_config = map
.next_value::<std::option::Option<crate::model::EnvironmentConfig>>(
)?;
}
__FieldTag::__user => {
if !fields.insert(__FieldTag::__user) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user",
));
}
result.user = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_history => {
if !fields.insert(__FieldTag::__state_history) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_history",
));
}
result.state_history = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::session::SessionStateHistory>,
>>()?
.unwrap_or_default();
}
__FieldTag::__session_template => {
if !fields.insert(__FieldTag::__session_template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_template",
));
}
result.session_template = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::session::SessionStateHistory {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__state,
__state_message,
__state_start_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 SessionStateHistory")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"state" => Ok(__FieldTag::__state),
"stateMessage" => Ok(__FieldTag::__state_message),
"state_message" => Ok(__FieldTag::__state_message),
"stateStartTime" => Ok(__FieldTag::__state_start_time),
"state_start_time" => Ok(__FieldTag::__state_start_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::session::SessionStateHistory;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SessionStateHistory")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::session::State>>()?
.unwrap_or_default();
}
__FieldTag::__state_message => {
if !fields.insert(__FieldTag::__state_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_message",
));
}
result.state_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state_start_time => {
if !fields.insert(__FieldTag::__state_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state_start_time",
));
}
result.state_start_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::JupyterConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__kernel,
__display_name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for JupyterConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"kernel" => Ok(__FieldTag::__kernel),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::JupyterConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct JupyterConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__kernel => {
if !fields.insert(__FieldTag::__kernel) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kernel",
));
}
result.kernel = map.next_value::<std::option::Option<crate::model::jupyter_config::Kernel>>()?.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SparkConnectConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SparkConnectConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkConnectConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkConnectConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RuntimeConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__version,
__container_image,
__properties,
__repository_config,
__autotuning_config,
__cohort,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RuntimeConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"version" => Ok(__FieldTag::__version),
"containerImage" => Ok(__FieldTag::__container_image),
"container_image" => Ok(__FieldTag::__container_image),
"properties" => Ok(__FieldTag::__properties),
"repositoryConfig" => Ok(__FieldTag::__repository_config),
"repository_config" => Ok(__FieldTag::__repository_config),
"autotuningConfig" => Ok(__FieldTag::__autotuning_config),
"autotuning_config" => Ok(__FieldTag::__autotuning_config),
"cohort" => Ok(__FieldTag::__cohort),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RuntimeConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RuntimeConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
result.version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__container_image => {
if !fields.insert(__FieldTag::__container_image) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for container_image",
));
}
result.container_image = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__repository_config => {
if !fields.insert(__FieldTag::__repository_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for repository_config",
));
}
result.repository_config = map
.next_value::<std::option::Option<crate::model::RepositoryConfig>>(
)?;
}
__FieldTag::__autotuning_config => {
if !fields.insert(__FieldTag::__autotuning_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for autotuning_config",
));
}
result.autotuning_config = map
.next_value::<std::option::Option<crate::model::AutotuningConfig>>(
)?;
}
__FieldTag::__cohort => {
if !fields.insert(__FieldTag::__cohort) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cohort",
));
}
result.cohort = 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::EnvironmentConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__execution_config,
__peripherals_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 EnvironmentConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"executionConfig" => Ok(__FieldTag::__execution_config),
"execution_config" => Ok(__FieldTag::__execution_config),
"peripheralsConfig" => Ok(__FieldTag::__peripherals_config),
"peripherals_config" => Ok(__FieldTag::__peripherals_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::EnvironmentConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EnvironmentConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__execution_config => {
if !fields.insert(__FieldTag::__execution_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for execution_config",
));
}
result.execution_config = map
.next_value::<std::option::Option<crate::model::ExecutionConfig>>(
)?;
}
__FieldTag::__peripherals_config => {
if !fields.insert(__FieldTag::__peripherals_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for peripherals_config",
));
}
result.peripherals_config = map
.next_value::<std::option::Option<crate::model::PeripheralsConfig>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ExecutionConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__service_account,
__network_uri,
__subnetwork_uri,
__network_tags,
__kms_key,
__idle_ttl,
__ttl,
__staging_bucket,
__authentication_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 ExecutionConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"serviceAccount" => Ok(__FieldTag::__service_account),
"service_account" => Ok(__FieldTag::__service_account),
"networkUri" => Ok(__FieldTag::__network_uri),
"network_uri" => Ok(__FieldTag::__network_uri),
"subnetworkUri" => Ok(__FieldTag::__subnetwork_uri),
"subnetwork_uri" => Ok(__FieldTag::__subnetwork_uri),
"networkTags" => Ok(__FieldTag::__network_tags),
"network_tags" => Ok(__FieldTag::__network_tags),
"kmsKey" => Ok(__FieldTag::__kms_key),
"kms_key" => Ok(__FieldTag::__kms_key),
"idleTtl" => Ok(__FieldTag::__idle_ttl),
"idle_ttl" => Ok(__FieldTag::__idle_ttl),
"ttl" => Ok(__FieldTag::__ttl),
"stagingBucket" => Ok(__FieldTag::__staging_bucket),
"staging_bucket" => Ok(__FieldTag::__staging_bucket),
"authenticationConfig" => Ok(__FieldTag::__authentication_config),
"authentication_config" => Ok(__FieldTag::__authentication_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ExecutionConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ExecutionConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::__network_uri => {
if !fields.insert(__FieldTag::__network_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_uri",
));
}
if result.network.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `network`, a oneof with full ID .google.cloud.dataproc.v1.ExecutionConfig.network_uri, latest field was networkUri",
));
}
result.network = std::option::Option::Some(
crate::model::execution_config::Network::NetworkUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__subnetwork_uri => {
if !fields.insert(__FieldTag::__subnetwork_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for subnetwork_uri",
));
}
if result.network.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `network`, a oneof with full ID .google.cloud.dataproc.v1.ExecutionConfig.subnetwork_uri, latest field was subnetworkUri",
));
}
result.network = std::option::Option::Some(
crate::model::execution_config::Network::SubnetworkUri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__network_tags => {
if !fields.insert(__FieldTag::__network_tags) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for network_tags",
));
}
result.network_tags = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__kms_key => {
if !fields.insert(__FieldTag::__kms_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key",
));
}
result.kms_key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__idle_ttl => {
if !fields.insert(__FieldTag::__idle_ttl) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for idle_ttl",
));
}
result.idle_ttl =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__ttl => {
if !fields.insert(__FieldTag::__ttl) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ttl",
));
}
result.ttl = map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__staging_bucket => {
if !fields.insert(__FieldTag::__staging_bucket) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for staging_bucket",
));
}
result.staging_bucket = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__authentication_config => {
if !fields.insert(__FieldTag::__authentication_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for authentication_config",
));
}
result.authentication_config = map.next_value::<std::option::Option<crate::model::AuthenticationConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SparkHistoryServerConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__dataproc_cluster,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SparkHistoryServerConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataprocCluster" => Ok(__FieldTag::__dataproc_cluster),
"dataproc_cluster" => Ok(__FieldTag::__dataproc_cluster),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SparkHistoryServerConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SparkHistoryServerConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__dataproc_cluster => {
if !fields.insert(__FieldTag::__dataproc_cluster) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dataproc_cluster",
));
}
result.dataproc_cluster = 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::PeripheralsConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__metastore_service,
__spark_history_server_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 PeripheralsConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"metastoreService" => Ok(__FieldTag::__metastore_service),
"metastore_service" => Ok(__FieldTag::__metastore_service),
"sparkHistoryServerConfig" => {
Ok(__FieldTag::__spark_history_server_config)
}
"spark_history_server_config" => {
Ok(__FieldTag::__spark_history_server_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PeripheralsConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PeripheralsConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__metastore_service => {
if !fields.insert(__FieldTag::__metastore_service) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metastore_service",
));
}
result.metastore_service = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__spark_history_server_config => {
if !fields.insert(__FieldTag::__spark_history_server_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_history_server_config",
));
}
result.spark_history_server_config = map.next_value::<std::option::Option<crate::model::SparkHistoryServerConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RuntimeInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__endpoints,
__output_uri,
__diagnostic_output_uri,
__approximate_usage,
__current_usage,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RuntimeInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"endpoints" => Ok(__FieldTag::__endpoints),
"outputUri" => Ok(__FieldTag::__output_uri),
"output_uri" => Ok(__FieldTag::__output_uri),
"diagnosticOutputUri" => Ok(__FieldTag::__diagnostic_output_uri),
"diagnostic_output_uri" => Ok(__FieldTag::__diagnostic_output_uri),
"approximateUsage" => Ok(__FieldTag::__approximate_usage),
"approximate_usage" => Ok(__FieldTag::__approximate_usage),
"currentUsage" => Ok(__FieldTag::__current_usage),
"current_usage" => Ok(__FieldTag::__current_usage),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RuntimeInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RuntimeInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__endpoints => {
if !fields.insert(__FieldTag::__endpoints) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for endpoints",
));
}
result.endpoints = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__output_uri => {
if !fields.insert(__FieldTag::__output_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for output_uri",
));
}
result.output_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__diagnostic_output_uri => {
if !fields.insert(__FieldTag::__diagnostic_output_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for diagnostic_output_uri",
));
}
result.diagnostic_output_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__approximate_usage => {
if !fields.insert(__FieldTag::__approximate_usage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for approximate_usage",
));
}
result.approximate_usage = map
.next_value::<std::option::Option<crate::model::UsageMetrics>>()?;
}
__FieldTag::__current_usage => {
if !fields.insert(__FieldTag::__current_usage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for current_usage",
));
}
result.current_usage = map
.next_value::<std::option::Option<crate::model::UsageSnapshot>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UsageMetrics {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__milli_dcu_seconds,
__shuffle_storage_gb_seconds,
__milli_accelerator_seconds,
__accelerator_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 UsageMetrics")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"milliDcuSeconds" => Ok(__FieldTag::__milli_dcu_seconds),
"milli_dcu_seconds" => Ok(__FieldTag::__milli_dcu_seconds),
"shuffleStorageGbSeconds" => {
Ok(__FieldTag::__shuffle_storage_gb_seconds)
}
"shuffle_storage_gb_seconds" => {
Ok(__FieldTag::__shuffle_storage_gb_seconds)
}
"milliAcceleratorSeconds" => {
Ok(__FieldTag::__milli_accelerator_seconds)
}
"milli_accelerator_seconds" => {
Ok(__FieldTag::__milli_accelerator_seconds)
}
"acceleratorType" => Ok(__FieldTag::__accelerator_type),
"accelerator_type" => Ok(__FieldTag::__accelerator_type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UsageMetrics;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UsageMetrics")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__milli_dcu_seconds => {
if !fields.insert(__FieldTag::__milli_dcu_seconds) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for milli_dcu_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.milli_dcu_seconds =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__shuffle_storage_gb_seconds => {
if !fields.insert(__FieldTag::__shuffle_storage_gb_seconds) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for shuffle_storage_gb_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.shuffle_storage_gb_seconds =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__milli_accelerator_seconds => {
if !fields.insert(__FieldTag::__milli_accelerator_seconds) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for milli_accelerator_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.milli_accelerator_seconds =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__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>>()?
.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::UsageSnapshot {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__milli_dcu,
__shuffle_storage_gb,
__milli_dcu_premium,
__shuffle_storage_gb_premium,
__milli_accelerator,
__accelerator_type,
__snapshot_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 UsageSnapshot")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"milliDcu" => Ok(__FieldTag::__milli_dcu),
"milli_dcu" => Ok(__FieldTag::__milli_dcu),
"shuffleStorageGb" => Ok(__FieldTag::__shuffle_storage_gb),
"shuffle_storage_gb" => Ok(__FieldTag::__shuffle_storage_gb),
"milliDcuPremium" => Ok(__FieldTag::__milli_dcu_premium),
"milli_dcu_premium" => Ok(__FieldTag::__milli_dcu_premium),
"shuffleStorageGbPremium" => {
Ok(__FieldTag::__shuffle_storage_gb_premium)
}
"shuffle_storage_gb_premium" => {
Ok(__FieldTag::__shuffle_storage_gb_premium)
}
"milliAccelerator" => Ok(__FieldTag::__milli_accelerator),
"milli_accelerator" => Ok(__FieldTag::__milli_accelerator),
"acceleratorType" => Ok(__FieldTag::__accelerator_type),
"accelerator_type" => Ok(__FieldTag::__accelerator_type),
"snapshotTime" => Ok(__FieldTag::__snapshot_time),
"snapshot_time" => Ok(__FieldTag::__snapshot_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UsageSnapshot;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UsageSnapshot")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__milli_dcu => {
if !fields.insert(__FieldTag::__milli_dcu) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for milli_dcu",
));
}
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.milli_dcu = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__shuffle_storage_gb => {
if !fields.insert(__FieldTag::__shuffle_storage_gb) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for shuffle_storage_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.shuffle_storage_gb =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__milli_dcu_premium => {
if !fields.insert(__FieldTag::__milli_dcu_premium) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for milli_dcu_premium",
));
}
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.milli_dcu_premium =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__shuffle_storage_gb_premium => {
if !fields.insert(__FieldTag::__shuffle_storage_gb_premium) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for shuffle_storage_gb_premium",
));
}
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.shuffle_storage_gb_premium =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__milli_accelerator => {
if !fields.insert(__FieldTag::__milli_accelerator) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for milli_accelerator",
));
}
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.milli_accelerator =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__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>>()?
.unwrap_or_default();
}
__FieldTag::__snapshot_time => {
if !fields.insert(__FieldTag::__snapshot_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snapshot_time",
));
}
result.snapshot_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::GkeClusterConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__gke_cluster_target,
__node_pool_target,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GkeClusterConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"gkeClusterTarget" => Ok(__FieldTag::__gke_cluster_target),
"gke_cluster_target" => Ok(__FieldTag::__gke_cluster_target),
"nodePoolTarget" => Ok(__FieldTag::__node_pool_target),
"node_pool_target" => Ok(__FieldTag::__node_pool_target),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GkeClusterConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GkeClusterConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__gke_cluster_target => {
if !fields.insert(__FieldTag::__gke_cluster_target) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gke_cluster_target",
));
}
result.gke_cluster_target = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__node_pool_target => {
if !fields.insert(__FieldTag::__node_pool_target) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_pool_target",
));
}
result.node_pool_target =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::GkeNodePoolTarget>,
>>()?
.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::KubernetesClusterConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__kubernetes_namespace,
__gke_cluster_config,
__kubernetes_software_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 KubernetesClusterConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"kubernetesNamespace" => Ok(__FieldTag::__kubernetes_namespace),
"kubernetes_namespace" => Ok(__FieldTag::__kubernetes_namespace),
"gkeClusterConfig" => Ok(__FieldTag::__gke_cluster_config),
"gke_cluster_config" => Ok(__FieldTag::__gke_cluster_config),
"kubernetesSoftwareConfig" => {
Ok(__FieldTag::__kubernetes_software_config)
}
"kubernetes_software_config" => {
Ok(__FieldTag::__kubernetes_software_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::KubernetesClusterConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct KubernetesClusterConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__kubernetes_namespace => {
if !fields.insert(__FieldTag::__kubernetes_namespace) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kubernetes_namespace",
));
}
result.kubernetes_namespace = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__gke_cluster_config => {
if !fields.insert(__FieldTag::__gke_cluster_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gke_cluster_config",
));
}
if result.config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `config`, a oneof with full ID .google.cloud.dataproc.v1.KubernetesClusterConfig.gke_cluster_config, latest field was gkeClusterConfig",
));
}
result.config = std::option::Option::Some(
crate::model::kubernetes_cluster_config::Config::GkeClusterConfig(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::GkeClusterConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__kubernetes_software_config => {
if !fields.insert(__FieldTag::__kubernetes_software_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kubernetes_software_config",
));
}
result.kubernetes_software_config = map.next_value::<std::option::Option<crate::model::KubernetesSoftwareConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::KubernetesSoftwareConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__component_version,
__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 KubernetesSoftwareConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"componentVersion" => Ok(__FieldTag::__component_version),
"component_version" => Ok(__FieldTag::__component_version),
"properties" => Ok(__FieldTag::__properties),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::KubernetesSoftwareConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct KubernetesSoftwareConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__component_version => {
if !fields.insert(__FieldTag::__component_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for component_version",
));
}
result.component_version = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__properties => {
if !fields.insert(__FieldTag::__properties) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for properties",
));
}
result.properties = map
.next_value::<std::option::Option<
std::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::GkeNodePoolTarget {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__node_pool,
__roles,
__node_pool_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 GkeNodePoolTarget")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"nodePool" => Ok(__FieldTag::__node_pool),
"node_pool" => Ok(__FieldTag::__node_pool),
"roles" => Ok(__FieldTag::__roles),
"nodePoolConfig" => Ok(__FieldTag::__node_pool_config),
"node_pool_config" => Ok(__FieldTag::__node_pool_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GkeNodePoolTarget;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GkeNodePoolTarget")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__node_pool => {
if !fields.insert(__FieldTag::__node_pool) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_pool",
));
}
result.node_pool = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__roles => {
if !fields.insert(__FieldTag::__roles) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for roles",
));
}
result.roles = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::gke_node_pool_target::Role>,
>>()?
.unwrap_or_default();
}
__FieldTag::__node_pool_config => {
if !fields.insert(__FieldTag::__node_pool_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for node_pool_config",
));
}
result.node_pool_config = map
.next_value::<std::option::Option<crate::model::GkeNodePoolConfig>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GkeNodePoolConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__config,
__locations,
__autoscaling,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GkeNodePoolConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"config" => Ok(__FieldTag::__config),
"locations" => Ok(__FieldTag::__locations),
"autoscaling" => Ok(__FieldTag::__autoscaling),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GkeNodePoolConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GkeNodePoolConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__config => {
if !fields.insert(__FieldTag::__config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for config",
));
}
result.config = map.next_value::<std::option::Option<
crate::model::gke_node_pool_config::GkeNodeConfig,
>>()?;
}
__FieldTag::__locations => {
if !fields.insert(__FieldTag::__locations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for locations",
));
}
result.locations = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__autoscaling => {
if !fields.insert(__FieldTag::__autoscaling) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for autoscaling",
));
}
result.autoscaling = map.next_value::<std::option::Option<
crate::model::gke_node_pool_config::GkeNodePoolAutoscalingConfig,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::gke_node_pool_config::GkeNodeConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__machine_type,
__local_ssd_count,
__preemptible,
__accelerators,
__min_cpu_platform,
__boot_disk_kms_key,
__spot,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GkeNodeConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"machineType" => Ok(__FieldTag::__machine_type),
"machine_type" => Ok(__FieldTag::__machine_type),
"localSsdCount" => Ok(__FieldTag::__local_ssd_count),
"local_ssd_count" => Ok(__FieldTag::__local_ssd_count),
"preemptible" => Ok(__FieldTag::__preemptible),
"accelerators" => Ok(__FieldTag::__accelerators),
"minCpuPlatform" => Ok(__FieldTag::__min_cpu_platform),
"min_cpu_platform" => Ok(__FieldTag::__min_cpu_platform),
"bootDiskKmsKey" => Ok(__FieldTag::__boot_disk_kms_key),
"boot_disk_kms_key" => Ok(__FieldTag::__boot_disk_kms_key),
"spot" => Ok(__FieldTag::__spot),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::gke_node_pool_config::GkeNodeConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GkeNodeConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::__local_ssd_count => {
if !fields.insert(__FieldTag::__local_ssd_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for local_ssd_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.local_ssd_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__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>>()?
.unwrap_or_default();
}
__FieldTag::__accelerators => {
if !fields.insert(__FieldTag::__accelerators) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for accelerators",
));
}
result.accelerators = map.next_value::<std::option::Option<std::vec::Vec<crate::model::gke_node_pool_config::GkeNodePoolAcceleratorConfig>>>()?.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>>()?
.unwrap_or_default();
}
__FieldTag::__boot_disk_kms_key => {
if !fields.insert(__FieldTag::__boot_disk_kms_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boot_disk_kms_key",
));
}
result.boot_disk_kms_key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__spot => {
if !fields.insert(__FieldTag::__spot) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spot",
));
}
result.spot = 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::gke_node_pool_config::GkeNodePoolAcceleratorConfig
{
fn deserialize<D>(deserializer: D) -> 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_count,
__accelerator_type,
__gpu_partition_size,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GkeNodePoolAcceleratorConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"acceleratorCount" => Ok(__FieldTag::__accelerator_count),
"accelerator_count" => Ok(__FieldTag::__accelerator_count),
"acceleratorType" => Ok(__FieldTag::__accelerator_type),
"accelerator_type" => Ok(__FieldTag::__accelerator_type),
"gpuPartitionSize" => Ok(__FieldTag::__gpu_partition_size),
"gpu_partition_size" => Ok(__FieldTag::__gpu_partition_size),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::gke_node_pool_config::GkeNodePoolAcceleratorConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GkeNodePoolAcceleratorConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_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<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.accelerator_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__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>>()?
.unwrap_or_default();
}
__FieldTag::__gpu_partition_size => {
if !fields.insert(__FieldTag::__gpu_partition_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gpu_partition_size",
));
}
result.gpu_partition_size = 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::gke_node_pool_config::GkeNodePoolAutoscalingConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__min_node_count,
__max_node_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 GkeNodePoolAutoscalingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"minNodeCount" => Ok(__FieldTag::__min_node_count),
"min_node_count" => Ok(__FieldTag::__min_node_count),
"maxNodeCount" => Ok(__FieldTag::__max_node_count),
"max_node_count" => Ok(__FieldTag::__max_node_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::gke_node_pool_config::GkeNodePoolAutoscalingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GkeNodePoolAutoscalingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__min_node_count => {
if !fields.insert(__FieldTag::__min_node_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for min_node_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.min_node_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__max_node_count => {
if !fields.insert(__FieldTag::__max_node_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_node_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.max_node_count =
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::AuthenticationConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_workload_authentication_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 AuthenticationConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userWorkloadAuthenticationType" => {
Ok(__FieldTag::__user_workload_authentication_type)
}
"user_workload_authentication_type" => {
Ok(__FieldTag::__user_workload_authentication_type)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AuthenticationConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AuthenticationConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_workload_authentication_type => {
if !fields.insert(__FieldTag::__user_workload_authentication_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_workload_authentication_type",
));
}
result.user_workload_authentication_type = map
.next_value::<std::option::Option<
crate::model::authentication_config::AuthenticationType,
>>()?
.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::AutotuningConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__scenarios,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AutotuningConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"scenarios" => Ok(__FieldTag::__scenarios),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AutotuningConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AutotuningConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__scenarios => {
if !fields.insert(__FieldTag::__scenarios) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scenarios",
));
}
result.scenarios = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::autotuning_config::Scenario>,
>>()?
.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::RepositoryConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__pypi_repository_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 RepositoryConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"pypiRepositoryConfig" => Ok(__FieldTag::__pypi_repository_config),
"pypi_repository_config" => Ok(__FieldTag::__pypi_repository_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RepositoryConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RepositoryConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__pypi_repository_config => {
if !fields.insert(__FieldTag::__pypi_repository_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pypi_repository_config",
));
}
result.pypi_repository_config = map.next_value::<std::option::Option<crate::model::PyPiRepositoryConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PyPiRepositoryConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__pypi_repository,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PyPiRepositoryConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"pypiRepository" => Ok(__FieldTag::__pypi_repository),
"pypi_repository" => Ok(__FieldTag::__pypi_repository),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PyPiRepositoryConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PyPiRepositoryConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__pypi_repository => {
if !fields.insert(__FieldTag::__pypi_repository) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pypi_repository",
));
}
result.pypi_repository = 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::WorkflowTemplate {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__id,
__name,
__version,
__create_time,
__update_time,
__labels,
__placement,
__jobs,
__parameters,
__dag_timeout,
__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 WorkflowTemplate")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"id" => Ok(__FieldTag::__id),
"name" => Ok(__FieldTag::__name),
"version" => Ok(__FieldTag::__version),
"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),
"placement" => Ok(__FieldTag::__placement),
"jobs" => Ok(__FieldTag::__jobs),
"parameters" => Ok(__FieldTag::__parameters),
"dagTimeout" => Ok(__FieldTag::__dag_timeout),
"dag_timeout" => Ok(__FieldTag::__dag_timeout),
"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::WorkflowTemplate;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkflowTemplate")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__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::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
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.version = map.next_value::<__With>()?.0.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::__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::__placement => {
if !fields.insert(__FieldTag::__placement) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for placement",
));
}
result.placement = map.next_value::<std::option::Option<crate::model::WorkflowTemplatePlacement>>()?
;
}
__FieldTag::__jobs => {
if !fields.insert(__FieldTag::__jobs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for jobs",
));
}
result.jobs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::OrderedJob>>>()?.unwrap_or_default();
}
__FieldTag::__parameters => {
if !fields.insert(__FieldTag::__parameters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parameters",
));
}
result.parameters =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::TemplateParameter>,
>>()?
.unwrap_or_default();
}
__FieldTag::__dag_timeout => {
if !fields.insert(__FieldTag::__dag_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dag_timeout",
));
}
result.dag_timeout =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__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::workflow_template::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::workflow_template::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,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'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 {
"kmsKey" => Ok(__FieldTag::__kms_key),
"kms_key" => Ok(__FieldTag::__kms_key),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::workflow_template::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 => {
if !fields.insert(__FieldTag::__kms_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key",
));
}
result.kms_key = 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::WorkflowTemplatePlacement {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__managed_cluster,
__cluster_selector,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WorkflowTemplatePlacement")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"managedCluster" => Ok(__FieldTag::__managed_cluster),
"managed_cluster" => Ok(__FieldTag::__managed_cluster),
"clusterSelector" => Ok(__FieldTag::__cluster_selector),
"cluster_selector" => Ok(__FieldTag::__cluster_selector),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WorkflowTemplatePlacement;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkflowTemplatePlacement")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__managed_cluster => {
if !fields.insert(__FieldTag::__managed_cluster) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for managed_cluster",
));
}
if result.placement.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `placement`, a oneof with full ID .google.cloud.dataproc.v1.WorkflowTemplatePlacement.managed_cluster, latest field was managedCluster",
));
}
result.placement = std::option::Option::Some(
crate::model::workflow_template_placement::Placement::ManagedCluster(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::ManagedCluster>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__cluster_selector => {
if !fields.insert(__FieldTag::__cluster_selector) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_selector",
));
}
if result.placement.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `placement`, a oneof with full ID .google.cloud.dataproc.v1.WorkflowTemplatePlacement.cluster_selector, latest field was clusterSelector",
));
}
result.placement = std::option::Option::Some(
crate::model::workflow_template_placement::Placement::ClusterSelector(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::ClusterSelector>>>()?.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::ManagedCluster {
fn deserialize<D>(deserializer: D) -> 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_name,
__config,
__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 ManagedCluster")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"config" => Ok(__FieldTag::__config),
"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::ManagedCluster;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ManagedCluster")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__config => {
if !fields.insert(__FieldTag::__config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for config",
));
}
result.config = map
.next_value::<std::option::Option<crate::model::ClusterConfig>>()?;
}
__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::ClusterSelector {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__zone,
__cluster_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 ClusterSelector")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"zone" => Ok(__FieldTag::__zone),
"clusterLabels" => Ok(__FieldTag::__cluster_labels),
"cluster_labels" => Ok(__FieldTag::__cluster_labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClusterSelector;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClusterSelector")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::__cluster_labels => {
if !fields.insert(__FieldTag::__cluster_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_labels",
));
}
result.cluster_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::OrderedJob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__step_id,
__hadoop_job,
__spark_job,
__pyspark_job,
__hive_job,
__pig_job,
__spark_r_job,
__spark_sql_job,
__presto_job,
__trino_job,
__flink_job,
__labels,
__scheduling,
__prerequisite_step_ids,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for OrderedJob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"stepId" => Ok(__FieldTag::__step_id),
"step_id" => Ok(__FieldTag::__step_id),
"hadoopJob" => Ok(__FieldTag::__hadoop_job),
"hadoop_job" => Ok(__FieldTag::__hadoop_job),
"sparkJob" => Ok(__FieldTag::__spark_job),
"spark_job" => Ok(__FieldTag::__spark_job),
"pysparkJob" => Ok(__FieldTag::__pyspark_job),
"pyspark_job" => Ok(__FieldTag::__pyspark_job),
"hiveJob" => Ok(__FieldTag::__hive_job),
"hive_job" => Ok(__FieldTag::__hive_job),
"pigJob" => Ok(__FieldTag::__pig_job),
"pig_job" => Ok(__FieldTag::__pig_job),
"sparkRJob" => Ok(__FieldTag::__spark_r_job),
"spark_r_job" => Ok(__FieldTag::__spark_r_job),
"sparkSqlJob" => Ok(__FieldTag::__spark_sql_job),
"spark_sql_job" => Ok(__FieldTag::__spark_sql_job),
"prestoJob" => Ok(__FieldTag::__presto_job),
"presto_job" => Ok(__FieldTag::__presto_job),
"trinoJob" => Ok(__FieldTag::__trino_job),
"trino_job" => Ok(__FieldTag::__trino_job),
"flinkJob" => Ok(__FieldTag::__flink_job),
"flink_job" => Ok(__FieldTag::__flink_job),
"labels" => Ok(__FieldTag::__labels),
"scheduling" => Ok(__FieldTag::__scheduling),
"prerequisiteStepIds" => Ok(__FieldTag::__prerequisite_step_ids),
"prerequisite_step_ids" => Ok(__FieldTag::__prerequisite_step_ids),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::OrderedJob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct OrderedJob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__step_id => {
if !fields.insert(__FieldTag::__step_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for step_id",
));
}
result.step_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__hadoop_job => {
if !fields.insert(__FieldTag::__hadoop_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hadoop_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.hadoop_job, latest field was hadoopJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::HadoopJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::HadoopJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_job => {
if !fields.insert(__FieldTag::__spark_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.spark_job, latest field was sparkJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::SparkJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__pyspark_job => {
if !fields.insert(__FieldTag::__pyspark_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pyspark_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.pyspark_job, latest field was pysparkJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::PysparkJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::PySparkJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__hive_job => {
if !fields.insert(__FieldTag::__hive_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for hive_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.hive_job, latest field was hiveJob",
));
}
result.job_type =
std::option::Option::Some(
crate::model::ordered_job::JobType::HiveJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::HiveJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__pig_job => {
if !fields.insert(__FieldTag::__pig_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pig_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.pig_job, latest field was pigJob",
));
}
result.job_type =
std::option::Option::Some(
crate::model::ordered_job::JobType::PigJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::PigJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_r_job => {
if !fields.insert(__FieldTag::__spark_r_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_r_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.spark_r_job, latest field was sparkRJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::SparkRJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkRJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spark_sql_job => {
if !fields.insert(__FieldTag::__spark_sql_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spark_sql_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.spark_sql_job, latest field was sparkSqlJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::SparkSqlJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SparkSqlJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__presto_job => {
if !fields.insert(__FieldTag::__presto_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for presto_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.presto_job, latest field was prestoJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::PrestoJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::PrestoJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__trino_job => {
if !fields.insert(__FieldTag::__trino_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for trino_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.trino_job, latest field was trinoJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::TrinoJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::TrinoJob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__flink_job => {
if !fields.insert(__FieldTag::__flink_job) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for flink_job",
));
}
if result.job_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `job_type`, a oneof with full ID .google.cloud.dataproc.v1.OrderedJob.flink_job, latest field was flinkJob",
));
}
result.job_type = std::option::Option::Some(
crate::model::ordered_job::JobType::FlinkJob(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::FlinkJob>,
>>()?
.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::__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::JobScheduling>>()?;
}
__FieldTag::__prerequisite_step_ids => {
if !fields.insert(__FieldTag::__prerequisite_step_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for prerequisite_step_ids",
));
}
result.prerequisite_step_ids = 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::TemplateParameter {
fn deserialize<D>(deserializer: D) -> 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,
__fields,
__description,
__validation,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TemplateParameter")
}
fn visit_str<E>(self, 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),
"fields" => Ok(__FieldTag::__fields),
"description" => Ok(__FieldTag::__description),
"validation" => Ok(__FieldTag::__validation),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TemplateParameter;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TemplateParameter")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__fields => {
if !fields.insert(__FieldTag::__fields) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fields",
));
}
result.fields = map.next_value::<std::option::Option<std::vec::Vec<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::__validation => {
if !fields.insert(__FieldTag::__validation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for validation",
));
}
result.validation = map.next_value::<std::option::Option<crate::model::ParameterValidation>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ParameterValidation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__regex,
__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 ParameterValidation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"regex" => Ok(__FieldTag::__regex),
"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::ParameterValidation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ParameterValidation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__regex => {
if !fields.insert(__FieldTag::__regex) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for regex",
));
}
if result.validation_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `validation_type`, a oneof with full ID .google.cloud.dataproc.v1.ParameterValidation.regex, latest field was regex",
));
}
result.validation_type = std::option::Option::Some(
crate::model::parameter_validation::ValidationType::Regex(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::RegexValidation>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__values => {
if !fields.insert(__FieldTag::__values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for values",
));
}
if result.validation_type.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `validation_type`, a oneof with full ID .google.cloud.dataproc.v1.ParameterValidation.values, latest field was values",
));
}
result.validation_type = std::option::Option::Some(
crate::model::parameter_validation::ValidationType::Values(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::ValueValidation>,
>>()?
.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::RegexValidation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__regexes,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RegexValidation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"regexes" => Ok(__FieldTag::__regexes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RegexValidation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RegexValidation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__regexes => {
if !fields.insert(__FieldTag::__regexes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for regexes",
));
}
result.regexes = 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::ValueValidation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__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 ValueValidation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"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::ValueValidation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ValueValidation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__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::WorkflowMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__template,
__version,
__create_cluster,
__graph,
__delete_cluster,
__state,
__cluster_name,
__parameters,
__start_time,
__end_time,
__cluster_uuid,
__dag_timeout,
__dag_start_time,
__dag_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 WorkflowMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"template" => Ok(__FieldTag::__template),
"version" => Ok(__FieldTag::__version),
"createCluster" => Ok(__FieldTag::__create_cluster),
"create_cluster" => Ok(__FieldTag::__create_cluster),
"graph" => Ok(__FieldTag::__graph),
"deleteCluster" => Ok(__FieldTag::__delete_cluster),
"delete_cluster" => Ok(__FieldTag::__delete_cluster),
"state" => Ok(__FieldTag::__state),
"clusterName" => Ok(__FieldTag::__cluster_name),
"cluster_name" => Ok(__FieldTag::__cluster_name),
"parameters" => Ok(__FieldTag::__parameters),
"startTime" => Ok(__FieldTag::__start_time),
"start_time" => Ok(__FieldTag::__start_time),
"endTime" => Ok(__FieldTag::__end_time),
"end_time" => Ok(__FieldTag::__end_time),
"clusterUuid" => Ok(__FieldTag::__cluster_uuid),
"cluster_uuid" => Ok(__FieldTag::__cluster_uuid),
"dagTimeout" => Ok(__FieldTag::__dag_timeout),
"dag_timeout" => Ok(__FieldTag::__dag_timeout),
"dagStartTime" => Ok(__FieldTag::__dag_start_time),
"dag_start_time" => Ok(__FieldTag::__dag_start_time),
"dagEndTime" => Ok(__FieldTag::__dag_end_time),
"dag_end_time" => Ok(__FieldTag::__dag_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::WorkflowMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkflowMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__template => {
if !fields.insert(__FieldTag::__template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for template",
));
}
result.template = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
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.version = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__create_cluster => {
if !fields.insert(__FieldTag::__create_cluster) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_cluster",
));
}
result.create_cluster = map
.next_value::<std::option::Option<crate::model::ClusterOperation>>(
)?;
}
__FieldTag::__graph => {
if !fields.insert(__FieldTag::__graph) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for graph",
));
}
result.graph = map
.next_value::<std::option::Option<crate::model::WorkflowGraph>>()?;
}
__FieldTag::__delete_cluster => {
if !fields.insert(__FieldTag::__delete_cluster) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for delete_cluster",
));
}
result.delete_cluster = map
.next_value::<std::option::Option<crate::model::ClusterOperation>>(
)?;
}
__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::workflow_metadata::State>>()?.unwrap_or_default();
}
__FieldTag::__cluster_name => {
if !fields.insert(__FieldTag::__cluster_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_name",
));
}
result.cluster_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__parameters => {
if !fields.insert(__FieldTag::__parameters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parameters",
));
}
result.parameters = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__start_time => {
if !fields.insert(__FieldTag::__start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_time",
));
}
result.start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__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::__cluster_uuid => {
if !fields.insert(__FieldTag::__cluster_uuid) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_uuid",
));
}
result.cluster_uuid = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__dag_timeout => {
if !fields.insert(__FieldTag::__dag_timeout) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dag_timeout",
));
}
result.dag_timeout =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__dag_start_time => {
if !fields.insert(__FieldTag::__dag_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dag_start_time",
));
}
result.dag_start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__dag_end_time => {
if !fields.insert(__FieldTag::__dag_end_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dag_end_time",
));
}
result.dag_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::ClusterOperation {
fn deserialize<D>(deserializer: D) -> 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_id,
__error,
__done,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ClusterOperation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"operationId" => Ok(__FieldTag::__operation_id),
"operation_id" => Ok(__FieldTag::__operation_id),
"error" => Ok(__FieldTag::__error),
"done" => Ok(__FieldTag::__done),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ClusterOperation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ClusterOperation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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_id => {
if !fields.insert(__FieldTag::__operation_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for operation_id",
));
}
result.operation_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__error => {
if !fields.insert(__FieldTag::__error) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error",
));
}
result.error = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__done => {
if !fields.insert(__FieldTag::__done) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for done",
));
}
result.done = 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::WorkflowGraph {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__nodes,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WorkflowGraph")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"nodes" => Ok(__FieldTag::__nodes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WorkflowGraph;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkflowGraph")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__nodes => {
if !fields.insert(__FieldTag::__nodes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for nodes",
));
}
result.nodes = map.next_value::<std::option::Option<std::vec::Vec<crate::model::WorkflowNode>>>()?.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::WorkflowNode {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__step_id,
__prerequisite_step_ids,
__job_id,
__state,
__error,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WorkflowNode")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"stepId" => Ok(__FieldTag::__step_id),
"step_id" => Ok(__FieldTag::__step_id),
"prerequisiteStepIds" => Ok(__FieldTag::__prerequisite_step_ids),
"prerequisite_step_ids" => Ok(__FieldTag::__prerequisite_step_ids),
"jobId" => Ok(__FieldTag::__job_id),
"job_id" => Ok(__FieldTag::__job_id),
"state" => Ok(__FieldTag::__state),
"error" => Ok(__FieldTag::__error),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WorkflowNode;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkflowNode")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__step_id => {
if !fields.insert(__FieldTag::__step_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for step_id",
));
}
result.step_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__prerequisite_step_ids => {
if !fields.insert(__FieldTag::__prerequisite_step_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for prerequisite_step_ids",
));
}
result.prerequisite_step_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__job_id => {
if !fields.insert(__FieldTag::__job_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for job_id",
));
}
result.job_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::workflow_node::NodeState>>()?.unwrap_or_default();
}
__FieldTag::__error => {
if !fields.insert(__FieldTag::__error) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error",
));
}
result.error = 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::CreateWorkflowTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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,
__template,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateWorkflowTemplateRequest")
}
fn visit_str<E>(self, 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),
"template" => Ok(__FieldTag::__template),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateWorkflowTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateWorkflowTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__template => {
if !fields.insert(__FieldTag::__template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for template",
));
}
result.template = map
.next_value::<std::option::Option<crate::model::WorkflowTemplate>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetWorkflowTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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,
__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 GetWorkflowTemplateRequest")
}
fn visit_str<E>(self, 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),
"version" => Ok(__FieldTag::__version),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetWorkflowTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetWorkflowTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
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.version = 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::InstantiateWorkflowTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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,
__version,
__request_id,
__parameters,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InstantiateWorkflowTemplateRequest")
}
fn visit_str<E>(self, 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),
"version" => Ok(__FieldTag::__version),
"requestId" => Ok(__FieldTag::__request_id),
"request_id" => Ok(__FieldTag::__request_id),
"parameters" => Ok(__FieldTag::__parameters),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::InstantiateWorkflowTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstantiateWorkflowTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
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.version = map.next_value::<__With>()?.0.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::__parameters => {
if !fields.insert(__FieldTag::__parameters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parameters",
));
}
result.parameters = map
.next_value::<std::option::Option<
std::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::InstantiateInlineWorkflowTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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,
__template,
__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 InstantiateInlineWorkflowTemplateRequest")
}
fn visit_str<E>(self, 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),
"template" => Ok(__FieldTag::__template),
"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::InstantiateInlineWorkflowTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InstantiateInlineWorkflowTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__template => {
if !fields.insert(__FieldTag::__template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for template",
));
}
result.template = map
.next_value::<std::option::Option<crate::model::WorkflowTemplate>>(
)?;
}
__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::UpdateWorkflowTemplateRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__template,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateWorkflowTemplateRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"template" => Ok(__FieldTag::__template),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateWorkflowTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateWorkflowTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__template => {
if !fields.insert(__FieldTag::__template) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for template",
));
}
result.template = map
.next_value::<std::option::Option<crate::model::WorkflowTemplate>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListWorkflowTemplatesRequest {
fn deserialize<D>(deserializer: D) -> 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 ListWorkflowTemplatesRequest")
}
fn visit_str<E>(self, 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::ListWorkflowTemplatesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListWorkflowTemplatesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::ListWorkflowTemplatesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__templates,
__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 ListWorkflowTemplatesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"templates" => Ok(__FieldTag::__templates),
"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::ListWorkflowTemplatesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListWorkflowTemplatesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__templates => {
if !fields.insert(__FieldTag::__templates) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for templates",
));
}
result.templates =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::WorkflowTemplate>,
>>()?
.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::DeleteWorkflowTemplateRequest {
fn deserialize<D>(deserializer: D) -> 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,
__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 DeleteWorkflowTemplateRequest")
}
fn visit_str<E>(self, 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),
"version" => Ok(__FieldTag::__version),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteWorkflowTemplateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteWorkflowTemplateRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::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::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
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.version = 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)
}
}