pub fn serialize_structure_crate_input_create_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.architecture {
object.key("architecture").string(var_1.as_str());
}
if let Some(var_2) = &input.auto_start_configuration {
#[allow(unused_mut)]
let mut object_3 = object.key("autoStartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_start_config(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.auto_stop_configuration {
#[allow(unused_mut)]
let mut object_5 = object.key("autoStopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_stop_config(&mut object_5, var_4)?;
object_5.finish();
}
if let Some(var_6) = &input.client_token {
object.key("clientToken").string(var_6.as_str());
}
if let Some(var_7) = &input.image_configuration {
#[allow(unused_mut)]
let mut object_8 = object.key("imageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_configuration_input(
&mut object_8,
var_7,
)?;
object_8.finish();
}
if let Some(var_9) = &input.initial_capacity {
#[allow(unused_mut)]
let mut object_10 = object.key("initialCapacity").start_object();
for (key_11, value_12) in var_9 {
{
#[allow(unused_mut)]
let mut object_13 = object_10.key(key_11.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_initial_capacity_config(
&mut object_13,
value_12,
)?;
object_13.finish();
}
}
object_10.finish();
}
if let Some(var_14) = &input.maximum_capacity {
#[allow(unused_mut)]
let mut object_15 = object.key("maximumCapacity").start_object();
crate::json_ser::serialize_structure_crate_model_maximum_allowed_resources(
&mut object_15,
var_14,
)?;
object_15.finish();
}
if let Some(var_16) = &input.name {
object.key("name").string(var_16.as_str());
}
if let Some(var_17) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_18 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_18,
var_17,
)?;
object_18.finish();
}
if let Some(var_19) = &input.release_label {
object.key("releaseLabel").string(var_19.as_str());
}
if let Some(var_20) = &input.tags {
#[allow(unused_mut)]
let mut object_21 = object.key("tags").start_object();
for (key_22, value_23) in var_20 {
{
object_21.key(key_22.as_str()).string(value_23.as_str());
}
}
object_21.finish();
}
if let Some(var_24) = &input.r#type {
object.key("type").string(var_24.as_str());
}
if let Some(var_25) = &input.worker_type_specifications {
#[allow(unused_mut)]
let mut object_26 = object.key("workerTypeSpecifications").start_object();
for (key_27, value_28) in var_25 {
{
#[allow(unused_mut)]
let mut object_29 = object_26.key(key_27.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_worker_type_specification_input(
&mut object_29,
value_28,
)?;
object_29.finish();
}
}
object_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_job_run_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartJobRunInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.client_token {
object.key("clientToken").string(var_30.as_str());
}
if let Some(var_31) = &input.configuration_overrides {
#[allow(unused_mut)]
let mut object_32 = object.key("configurationOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_overrides(
&mut object_32,
var_31,
)?;
object_32.finish();
}
if let Some(var_33) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_33.as_str());
}
if let Some(var_34) = &input.execution_timeout_minutes {
object.key("executionTimeoutMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_34).into()),
);
}
if let Some(var_35) = &input.job_driver {
#[allow(unused_mut)]
let mut object_36 = object.key("jobDriver").start_object();
crate::json_ser::serialize_union_crate_model_job_driver(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.name {
object.key("name").string(var_37.as_str());
}
if let Some(var_38) = &input.tags {
#[allow(unused_mut)]
let mut object_39 = object.key("tags").start_object();
for (key_40, value_41) in var_38 {
{
object_39.key(key_40.as_str()).string(value_41.as_str());
}
}
object_39.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.tags {
#[allow(unused_mut)]
let mut object_43 = object.key("tags").start_object();
for (key_44, value_45) in var_42 {
{
object_43.key(key_44.as_str()).string(value_45.as_str());
}
}
object_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.architecture {
object.key("architecture").string(var_46.as_str());
}
if let Some(var_47) = &input.auto_start_configuration {
#[allow(unused_mut)]
let mut object_48 = object.key("autoStartConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_start_config(&mut object_48, var_47)?;
object_48.finish();
}
if let Some(var_49) = &input.auto_stop_configuration {
#[allow(unused_mut)]
let mut object_50 = object.key("autoStopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_stop_config(&mut object_50, var_49)?;
object_50.finish();
}
if let Some(var_51) = &input.client_token {
object.key("clientToken").string(var_51.as_str());
}
if let Some(var_52) = &input.image_configuration {
#[allow(unused_mut)]
let mut object_53 = object.key("imageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_configuration_input(
&mut object_53,
var_52,
)?;
object_53.finish();
}
if let Some(var_54) = &input.initial_capacity {
#[allow(unused_mut)]
let mut object_55 = object.key("initialCapacity").start_object();
for (key_56, value_57) in var_54 {
{
#[allow(unused_mut)]
let mut object_58 = object_55.key(key_56.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_initial_capacity_config(
&mut object_58,
value_57,
)?;
object_58.finish();
}
}
object_55.finish();
}
if let Some(var_59) = &input.maximum_capacity {
#[allow(unused_mut)]
let mut object_60 = object.key("maximumCapacity").start_object();
crate::json_ser::serialize_structure_crate_model_maximum_allowed_resources(
&mut object_60,
var_59,
)?;
object_60.finish();
}
if let Some(var_61) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_62 = object.key("networkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_62,
var_61,
)?;
object_62.finish();
}
if let Some(var_63) = &input.worker_type_specifications {
#[allow(unused_mut)]
let mut object_64 = object.key("workerTypeSpecifications").start_object();
for (key_65, value_66) in var_63 {
{
#[allow(unused_mut)]
let mut object_67 = object_64.key(key_65.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_worker_type_specification_input(
&mut object_67,
value_66,
)?;
object_67.finish();
}
}
object_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_start_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoStartConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.enabled {
object.key("enabled").boolean(*var_68);
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_stop_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoStopConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.enabled {
object.key("enabled").boolean(*var_69);
}
if let Some(var_70) = &input.idle_timeout_minutes {
object.key("idleTimeoutMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_70).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_image_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImageConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.image_uri {
object.key("imageUri").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_initial_capacity_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InitialCapacityConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("workerCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.worker_count).into()),
);
}
if let Some(var_72) = &input.worker_configuration {
#[allow(unused_mut)]
let mut object_73 = object.key("workerConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_worker_resource_config(
&mut object_73,
var_72,
)?;
object_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_maximum_allowed_resources(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MaximumAllowedResources,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.cpu {
object.key("cpu").string(var_74.as_str());
}
if let Some(var_75) = &input.memory {
object.key("memory").string(var_75.as_str());
}
if let Some(var_76) = &input.disk {
object.key("disk").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_network_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.subnet_ids {
let mut array_78 = object.key("subnetIds").start_array();
for item_79 in var_77 {
{
array_78.value().string(item_79.as_str());
}
}
array_78.finish();
}
if let Some(var_80) = &input.security_group_ids {
let mut array_81 = object.key("securityGroupIds").start_array();
for item_82 in var_80 {
{
array_81.value().string(item_82.as_str());
}
}
array_81.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_worker_type_specification_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkerTypeSpecificationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.image_configuration {
#[allow(unused_mut)]
let mut object_84 = object.key("imageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_configuration_input(
&mut object_84,
var_83,
)?;
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_configuration_overrides(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigurationOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.application_configuration {
let mut array_86 = object.key("applicationConfiguration").start_array();
for item_87 in var_85 {
{
#[allow(unused_mut)]
let mut object_88 = array_86.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_88,
item_87,
)?;
object_88.finish();
}
}
array_86.finish();
}
if let Some(var_89) = &input.monitoring_configuration {
#[allow(unused_mut)]
let mut object_90 = object.key("monitoringConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_configuration(
&mut object_90,
var_89,
)?;
object_90.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_job_driver(
object_36: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobDriver,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::JobDriver::SparkSubmit(inner) => {
#[allow(unused_mut)]
let mut object_91 = object_36.key("sparkSubmit").start_object();
crate::json_ser::serialize_structure_crate_model_spark_submit(&mut object_91, inner)?;
object_91.finish();
}
crate::model::JobDriver::Hive(inner) => {
#[allow(unused_mut)]
let mut object_92 = object_36.key("hive").start_object();
crate::json_ser::serialize_structure_crate_model_hive(&mut object_92, inner)?;
object_92.finish();
}
crate::model::JobDriver::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant("JobDriver"),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_worker_resource_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkerResourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.cpu {
object.key("cpu").string(var_93.as_str());
}
if let Some(var_94) = &input.memory {
object.key("memory").string(var_94.as_str());
}
if let Some(var_95) = &input.disk {
object.key("disk").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Configuration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.classification {
object.key("classification").string(var_96.as_str());
}
if let Some(var_97) = &input.properties {
#[allow(unused_mut)]
let mut object_98 = object.key("properties").start_object();
for (key_99, value_100) in var_97 {
{
object_98.key(key_99.as_str()).string(value_100.as_str());
}
}
object_98.finish();
}
if let Some(var_101) = &input.configurations {
let mut array_102 = object.key("configurations").start_array();
for item_103 in var_101 {
{
#[allow(unused_mut)]
let mut object_104 = array_102.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_104,
item_103,
)?;
object_104.finish();
}
}
array_102.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.s3_monitoring_configuration {
#[allow(unused_mut)]
let mut object_106 = object.key("s3MonitoringConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_s3_monitoring_configuration(
&mut object_106,
var_105,
)?;
object_106.finish();
}
if let Some(var_107) = &input.managed_persistence_monitoring_configuration {
#[allow(unused_mut)]
let mut object_108 = object
.key("managedPersistenceMonitoringConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_managed_persistence_monitoring_configuration(&mut object_108, var_107)?;
object_108.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_spark_submit(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SparkSubmit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.entry_point {
object.key("entryPoint").string(var_109.as_str());
}
if let Some(var_110) = &input.entry_point_arguments {
let mut array_111 = object.key("entryPointArguments").start_array();
for item_112 in var_110 {
{
array_111.value().string(item_112.as_str());
}
}
array_111.finish();
}
if let Some(var_113) = &input.spark_submit_parameters {
object.key("sparkSubmitParameters").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_hive(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Hive,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.query {
object.key("query").string(var_114.as_str());
}
if let Some(var_115) = &input.init_query_file {
object.key("initQueryFile").string(var_115.as_str());
}
if let Some(var_116) = &input.parameters {
object.key("parameters").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3MonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.log_uri {
object.key("logUri").string(var_117.as_str());
}
if let Some(var_118) = &input.encryption_key_arn {
object.key("encryptionKeyArn").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_managed_persistence_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ManagedPersistenceMonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.enabled {
object.key("enabled").boolean(*var_119);
}
if let Some(var_120) = &input.encryption_key_arn {
object.key("encryptionKeyArn").string(var_120.as_str());
}
Ok(())
}