pub fn ser_aws_redshift_cluster_details(
object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::types::AwsRedshiftClusterDetails,
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
if let Some(var_1) = &input.allow_version_upgrade {
object.key("AllowVersionUpgrade").boolean(*var_1);
}
if let Some(var_2) = &input.automated_snapshot_retention_period {
object.key("AutomatedSnapshotRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_2).into()),
);
}
if let Some(var_3) = &input.availability_zone {
object.key("AvailabilityZone").string(var_3.as_str());
}
if let Some(var_4) = &input.cluster_availability_status {
object.key("ClusterAvailabilityStatus").string(var_4.as_str());
}
if let Some(var_5) = &input.cluster_create_time {
object.key("ClusterCreateTime").string(var_5.as_str());
}
if let Some(var_6) = &input.cluster_identifier {
object.key("ClusterIdentifier").string(var_6.as_str());
}
if let Some(var_7) = &input.cluster_nodes {
let mut array_8 = object.key("ClusterNodes").start_array();
for item_9 in var_7 {
{
#[allow(unused_mut)]
let mut object_10 = array_8.value().start_object();
crate::protocol_serde::shape_aws_redshift_cluster_cluster_node::ser_aws_redshift_cluster_cluster_node(&mut object_10, item_9)?;
object_10.finish();
}
}
array_8.finish();
}
if let Some(var_11) = &input.cluster_parameter_groups {
let mut array_12 = object.key("ClusterParameterGroups").start_array();
for item_13 in var_11 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::protocol_serde::shape_aws_redshift_cluster_cluster_parameter_group::ser_aws_redshift_cluster_cluster_parameter_group(
&mut object_14,
item_13,
)?;
object_14.finish();
}
}
array_12.finish();
}
if let Some(var_15) = &input.cluster_public_key {
object.key("ClusterPublicKey").string(var_15.as_str());
}
if let Some(var_16) = &input.cluster_revision_number {
object.key("ClusterRevisionNumber").string(var_16.as_str());
}
if let Some(var_17) = &input.cluster_security_groups {
let mut array_18 = object.key("ClusterSecurityGroups").start_array();
for item_19 in var_17 {
{
#[allow(unused_mut)]
let mut object_20 = array_18.value().start_object();
crate::protocol_serde::shape_aws_redshift_cluster_cluster_security_group::ser_aws_redshift_cluster_cluster_security_group(
&mut object_20,
item_19,
)?;
object_20.finish();
}
}
array_18.finish();
}
if let Some(var_21) = &input.cluster_snapshot_copy_status {
#[allow(unused_mut)]
let mut object_22 = object.key("ClusterSnapshotCopyStatus").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_cluster_snapshot_copy_status::ser_aws_redshift_cluster_cluster_snapshot_copy_status(
&mut object_22,
var_21,
)?;
object_22.finish();
}
if let Some(var_23) = &input.cluster_status {
object.key("ClusterStatus").string(var_23.as_str());
}
if let Some(var_24) = &input.cluster_subnet_group_name {
object.key("ClusterSubnetGroupName").string(var_24.as_str());
}
if let Some(var_25) = &input.cluster_version {
object.key("ClusterVersion").string(var_25.as_str());
}
if let Some(var_26) = &input.db_name {
object.key("DBName").string(var_26.as_str());
}
if let Some(var_27) = &input.deferred_maintenance_windows {
let mut array_28 = object.key("DeferredMaintenanceWindows").start_array();
for item_29 in var_27 {
{
#[allow(unused_mut)]
let mut object_30 = array_28.value().start_object();
crate::protocol_serde::shape_aws_redshift_cluster_deferred_maintenance_window::ser_aws_redshift_cluster_deferred_maintenance_window(
&mut object_30,
item_29,
)?;
object_30.finish();
}
}
array_28.finish();
}
if let Some(var_31) = &input.elastic_ip_status {
#[allow(unused_mut)]
let mut object_32 = object.key("ElasticIpStatus").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_elastic_ip_status::ser_aws_redshift_cluster_elastic_ip_status(&mut object_32, var_31)?;
object_32.finish();
}
if let Some(var_33) = &input.elastic_resize_number_of_node_options {
object.key("ElasticResizeNumberOfNodeOptions").string(var_33.as_str());
}
if let Some(var_34) = &input.encrypted {
object.key("Encrypted").boolean(*var_34);
}
if let Some(var_35) = &input.endpoint {
#[allow(unused_mut)]
let mut object_36 = object.key("Endpoint").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_endpoint::ser_aws_redshift_cluster_endpoint(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.enhanced_vpc_routing {
object.key("EnhancedVpcRouting").boolean(*var_37);
}
if let Some(var_38) = &input.expected_next_snapshot_schedule_time {
object.key("ExpectedNextSnapshotScheduleTime").string(var_38.as_str());
}
if let Some(var_39) = &input.expected_next_snapshot_schedule_time_status {
object.key("ExpectedNextSnapshotScheduleTimeStatus").string(var_39.as_str());
}
if let Some(var_40) = &input.hsm_status {
#[allow(unused_mut)]
let mut object_41 = object.key("HsmStatus").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_hsm_status::ser_aws_redshift_cluster_hsm_status(&mut object_41, var_40)?;
object_41.finish();
}
if let Some(var_42) = &input.iam_roles {
let mut array_43 = object.key("IamRoles").start_array();
for item_44 in var_42 {
{
#[allow(unused_mut)]
let mut object_45 = array_43.value().start_object();
crate::protocol_serde::shape_aws_redshift_cluster_iam_role::ser_aws_redshift_cluster_iam_role(&mut object_45, item_44)?;
object_45.finish();
}
}
array_43.finish();
}
if let Some(var_46) = &input.kms_key_id {
object.key("KmsKeyId").string(var_46.as_str());
}
if let Some(var_47) = &input.maintenance_track_name {
object.key("MaintenanceTrackName").string(var_47.as_str());
}
if let Some(var_48) = &input.manual_snapshot_retention_period {
object.key("ManualSnapshotRetentionPeriod").number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_48).into()),
);
}
if let Some(var_49) = &input.master_username {
object.key("MasterUsername").string(var_49.as_str());
}
if let Some(var_50) = &input.next_maintenance_window_start_time {
object.key("NextMaintenanceWindowStartTime").string(var_50.as_str());
}
if let Some(var_51) = &input.node_type {
object.key("NodeType").string(var_51.as_str());
}
if let Some(var_52) = &input.number_of_nodes {
object.key("NumberOfNodes").number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_52).into()),
);
}
if let Some(var_53) = &input.pending_actions {
let mut array_54 = object.key("PendingActions").start_array();
for item_55 in var_53 {
{
array_54.value().string(item_55.as_str());
}
}
array_54.finish();
}
if let Some(var_56) = &input.pending_modified_values {
#[allow(unused_mut)]
let mut object_57 = object.key("PendingModifiedValues").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_pending_modified_values::ser_aws_redshift_cluster_pending_modified_values(
&mut object_57,
var_56,
)?;
object_57.finish();
}
if let Some(var_58) = &input.preferred_maintenance_window {
object.key("PreferredMaintenanceWindow").string(var_58.as_str());
}
if let Some(var_59) = &input.publicly_accessible {
object.key("PubliclyAccessible").boolean(*var_59);
}
if let Some(var_60) = &input.resize_info {
#[allow(unused_mut)]
let mut object_61 = object.key("ResizeInfo").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_resize_info::ser_aws_redshift_cluster_resize_info(&mut object_61, var_60)?;
object_61.finish();
}
if let Some(var_62) = &input.restore_status {
#[allow(unused_mut)]
let mut object_63 = object.key("RestoreStatus").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_restore_status::ser_aws_redshift_cluster_restore_status(&mut object_63, var_62)?;
object_63.finish();
}
if let Some(var_64) = &input.snapshot_schedule_identifier {
object.key("SnapshotScheduleIdentifier").string(var_64.as_str());
}
if let Some(var_65) = &input.snapshot_schedule_state {
object.key("SnapshotScheduleState").string(var_65.as_str());
}
if let Some(var_66) = &input.vpc_id {
object.key("VpcId").string(var_66.as_str());
}
if let Some(var_67) = &input.vpc_security_groups {
let mut array_68 = object.key("VpcSecurityGroups").start_array();
for item_69 in var_67 {
{
#[allow(unused_mut)]
let mut object_70 = array_68.value().start_object();
crate::protocol_serde::shape_aws_redshift_cluster_vpc_security_group::ser_aws_redshift_cluster_vpc_security_group(
&mut object_70,
item_69,
)?;
object_70.finish();
}
}
array_68.finish();
}
if let Some(var_71) = &input.logging_status {
#[allow(unused_mut)]
let mut object_72 = object.key("LoggingStatus").start_object();
crate::protocol_serde::shape_aws_redshift_cluster_logging_status::ser_aws_redshift_cluster_logging_status(&mut object_72, var_71)?;
object_72.finish();
}
Ok(())
}
pub(crate) fn de_aws_redshift_cluster_details<'a, I>(
tokens: &mut ::std::iter::Peekable<I>,
_value: &'a [u8],
) -> ::std::result::Result<Option<crate::types::AwsRedshiftClusterDetails>, ::aws_smithy_json::deserialize::error::DeserializeError>
where
I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
{
match tokens.next().transpose()? {
Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
#[allow(unused_mut)]
let mut builder = crate::types::builders::AwsRedshiftClusterDetailsBuilder::default();
loop {
match tokens.next().transpose()? {
Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
"AllowVersionUpgrade" => {
builder = builder.set_allow_version_upgrade(::aws_smithy_json::deserialize::token::expect_bool_or_null(tokens.next())?);
}
"AutomatedSnapshotRetentionPeriod" => {
builder = builder.set_automated_snapshot_retention_period(
::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
.map(i32::try_from)
.transpose()?,
);
}
"AvailabilityZone" => {
builder = builder.set_availability_zone(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterAvailabilityStatus" => {
builder = builder.set_cluster_availability_status(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterCreateTime" => {
builder = builder.set_cluster_create_time(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterIdentifier" => {
builder = builder.set_cluster_identifier(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterNodes" => {
builder = builder.set_cluster_nodes(
crate::protocol_serde::shape_aws_redshift_cluster_cluster_nodes::de_aws_redshift_cluster_cluster_nodes(
tokens, _value,
)?,
);
}
"ClusterParameterGroups" => {
builder = builder.set_cluster_parameter_groups(
crate::protocol_serde::shape_aws_redshift_cluster_cluster_parameter_groups::de_aws_redshift_cluster_cluster_parameter_groups(tokens, _value)?
);
}
"ClusterPublicKey" => {
builder = builder.set_cluster_public_key(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterRevisionNumber" => {
builder = builder.set_cluster_revision_number(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterSecurityGroups" => {
builder = builder.set_cluster_security_groups(
crate::protocol_serde::shape_aws_redshift_cluster_cluster_security_groups::de_aws_redshift_cluster_cluster_security_groups(tokens, _value)?
);
}
"ClusterSnapshotCopyStatus" => {
builder = builder.set_cluster_snapshot_copy_status(
crate::protocol_serde::shape_aws_redshift_cluster_cluster_snapshot_copy_status::de_aws_redshift_cluster_cluster_snapshot_copy_status(tokens, _value)?
);
}
"ClusterStatus" => {
builder = builder.set_cluster_status(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterSubnetGroupName" => {
builder = builder.set_cluster_subnet_group_name(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ClusterVersion" => {
builder = builder.set_cluster_version(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"DBName" => {
builder = builder.set_db_name(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"DeferredMaintenanceWindows" => {
builder = builder.set_deferred_maintenance_windows(
crate::protocol_serde::shape_aws_redshift_cluster_deferred_maintenance_windows::de_aws_redshift_cluster_deferred_maintenance_windows(tokens, _value)?
);
}
"ElasticIpStatus" => {
builder = builder.set_elastic_ip_status(
crate::protocol_serde::shape_aws_redshift_cluster_elastic_ip_status::de_aws_redshift_cluster_elastic_ip_status(
tokens, _value,
)?,
);
}
"ElasticResizeNumberOfNodeOptions" => {
builder = builder.set_elastic_resize_number_of_node_options(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"Encrypted" => {
builder = builder.set_encrypted(::aws_smithy_json::deserialize::token::expect_bool_or_null(tokens.next())?);
}
"Endpoint" => {
builder = builder.set_endpoint(
crate::protocol_serde::shape_aws_redshift_cluster_endpoint::de_aws_redshift_cluster_endpoint(tokens, _value)?,
);
}
"EnhancedVpcRouting" => {
builder = builder.set_enhanced_vpc_routing(::aws_smithy_json::deserialize::token::expect_bool_or_null(tokens.next())?);
}
"ExpectedNextSnapshotScheduleTime" => {
builder = builder.set_expected_next_snapshot_schedule_time(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ExpectedNextSnapshotScheduleTimeStatus" => {
builder = builder.set_expected_next_snapshot_schedule_time_status(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"HsmStatus" => {
builder = builder.set_hsm_status(
crate::protocol_serde::shape_aws_redshift_cluster_hsm_status::de_aws_redshift_cluster_hsm_status(tokens, _value)?,
);
}
"IamRoles" => {
builder = builder.set_iam_roles(
crate::protocol_serde::shape_aws_redshift_cluster_iam_roles::de_aws_redshift_cluster_iam_roles(tokens, _value)?,
);
}
"KmsKeyId" => {
builder = builder.set_kms_key_id(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"MaintenanceTrackName" => {
builder = builder.set_maintenance_track_name(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"ManualSnapshotRetentionPeriod" => {
builder = builder.set_manual_snapshot_retention_period(
::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
.map(i32::try_from)
.transpose()?,
);
}
"MasterUsername" => {
builder = builder.set_master_username(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"NextMaintenanceWindowStartTime" => {
builder = builder.set_next_maintenance_window_start_time(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"NodeType" => {
builder = builder.set_node_type(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"NumberOfNodes" => {
builder = builder.set_number_of_nodes(
::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
.map(i32::try_from)
.transpose()?,
);
}
"PendingActions" => {
builder = builder.set_pending_actions(crate::protocol_serde::shape_string_list::de_string_list(tokens, _value)?);
}
"PendingModifiedValues" => {
builder = builder.set_pending_modified_values(
crate::protocol_serde::shape_aws_redshift_cluster_pending_modified_values::de_aws_redshift_cluster_pending_modified_values(tokens, _value)?
);
}
"PreferredMaintenanceWindow" => {
builder = builder.set_preferred_maintenance_window(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"PubliclyAccessible" => {
builder = builder.set_publicly_accessible(::aws_smithy_json::deserialize::token::expect_bool_or_null(tokens.next())?);
}
"ResizeInfo" => {
builder = builder.set_resize_info(
crate::protocol_serde::shape_aws_redshift_cluster_resize_info::de_aws_redshift_cluster_resize_info(tokens, _value)?,
);
}
"RestoreStatus" => {
builder = builder.set_restore_status(
crate::protocol_serde::shape_aws_redshift_cluster_restore_status::de_aws_redshift_cluster_restore_status(
tokens, _value,
)?,
);
}
"SnapshotScheduleIdentifier" => {
builder = builder.set_snapshot_schedule_identifier(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"SnapshotScheduleState" => {
builder = builder.set_snapshot_schedule_state(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"VpcId" => {
builder = builder.set_vpc_id(
::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
.map(|s| s.to_unescaped().map(|u| u.into_owned()))
.transpose()?,
);
}
"VpcSecurityGroups" => {
builder = builder.set_vpc_security_groups(
crate::protocol_serde::shape_aws_redshift_cluster_vpc_security_groups::de_aws_redshift_cluster_vpc_security_groups(
tokens, _value,
)?,
);
}
"LoggingStatus" => {
builder = builder.set_logging_status(
crate::protocol_serde::shape_aws_redshift_cluster_logging_status::de_aws_redshift_cluster_logging_status(
tokens, _value,
)?,
);
}
_ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
},
other => {
return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
"expected object key or end object, found: {other:?}"
)))
}
}
}
Ok(Some(builder.build()))
}
_ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
"expected start object or null",
)),
}
}