pub fn add_headers_abort_multipart_upload(
input: &crate::input::AbortMultipartUploadInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_1) = &input.request_payer {
let formatted_2 = inner_1.as_str();
if !formatted_2.is_empty() {
let header_value = formatted_2;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_3) = &input.expected_bucket_owner {
let formatted_4 = inner_3.as_str();
if !formatted_4.is_empty() {
let header_value = formatted_4;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_complete_multipart_upload(
input: &crate::input::CompleteMultipartUploadInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_5) = &input.checksum_crc32 {
let formatted_6 = inner_5.as_str();
if !formatted_6.is_empty() {
let header_value = formatted_6;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-crc32", header_value);
}
}
if let Some(inner_7) = &input.checksum_crc32_c {
let formatted_8 = inner_7.as_str();
if !formatted_8.is_empty() {
let header_value = formatted_8;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32_c",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-crc32c", header_value);
}
}
if let Some(inner_9) = &input.checksum_sha1 {
let formatted_10 = inner_9.as_str();
if !formatted_10.is_empty() {
let header_value = formatted_10;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha1",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-sha1", header_value);
}
}
if let Some(inner_11) = &input.checksum_sha256 {
let formatted_12 = inner_11.as_str();
if !formatted_12.is_empty() {
let header_value = formatted_12;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha256",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-sha256", header_value);
}
}
if let Some(inner_13) = &input.request_payer {
let formatted_14 = inner_13.as_str();
if !formatted_14.is_empty() {
let header_value = formatted_14;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_15) = &input.expected_bucket_owner {
let formatted_16 = inner_15.as_str();
if !formatted_16.is_empty() {
let header_value = formatted_16;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_17) = &input.sse_customer_algorithm {
let formatted_18 = inner_17.as_str();
if !formatted_18.is_empty() {
let header_value = formatted_18;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_19) = &input.sse_customer_key {
let formatted_20 = inner_19.as_str();
if !formatted_20.is_empty() {
let header_value = formatted_20;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_21) = &input.sse_customer_key_md5 {
let formatted_22 = inner_21.as_str();
if !formatted_22.is_empty() {
let header_value = formatted_22;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
Ok(builder)
}
pub fn add_headers_copy_object(
input: &crate::input::CopyObjectInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_23) = &input.acl {
let formatted_24 = inner_23.as_str();
if !formatted_24.is_empty() {
let header_value = formatted_24;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"acl",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-acl", header_value);
}
}
if let Some(inner_25) = &input.cache_control {
let formatted_26 = inner_25.as_str();
if !formatted_26.is_empty() {
let header_value = formatted_26;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"cache_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Cache-Control", header_value);
}
}
if let Some(inner_27) = &input.checksum_algorithm {
let formatted_28 = inner_27.as_str();
if !formatted_28.is_empty() {
let header_value = formatted_28;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-algorithm", header_value);
}
}
if let Some(inner_29) = &input.content_disposition {
let formatted_30 = inner_29.as_str();
if !formatted_30.is_empty() {
let header_value = formatted_30;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_disposition",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Disposition", header_value);
}
}
if let Some(inner_31) = &input.content_encoding {
let formatted_32 = inner_31.as_str();
if !formatted_32.is_empty() {
let header_value = formatted_32;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_encoding",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Encoding", header_value);
}
}
if let Some(inner_33) = &input.content_language {
let formatted_34 = inner_33.as_str();
if !formatted_34.is_empty() {
let header_value = formatted_34;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_language",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Language", header_value);
}
}
if let Some(inner_35) = &input.content_type {
let formatted_36 = inner_35.as_str();
if !formatted_36.is_empty() {
let header_value = formatted_36;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Type", header_value);
}
}
if let Some(inner_37) = &input.copy_source {
let formatted_38 = inner_37.as_str();
if !formatted_38.is_empty() {
let header_value = formatted_38;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source", header_value);
}
}
if let Some(inner_39) = &input.copy_source_if_match {
let formatted_40 = inner_39.as_str();
if !formatted_40.is_empty() {
let header_value = formatted_40;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-match", header_value);
}
}
if let Some(inner_41) = &input.copy_source_if_modified_since {
let formatted_42 = inner_41.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_42.is_empty() {
let header_value = formatted_42;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_modified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-modified-since", header_value);
}
}
if let Some(inner_43) = &input.copy_source_if_none_match {
let formatted_44 = inner_43.as_str();
if !formatted_44.is_empty() {
let header_value = formatted_44;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_none_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-none-match", header_value);
}
}
if let Some(inner_45) = &input.copy_source_if_unmodified_since {
let formatted_46 = inner_45.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_46.is_empty() {
let header_value = formatted_46;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_unmodified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-unmodified-since", header_value);
}
}
if let Some(inner_47) = &input.expires {
let formatted_48 = inner_47.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_48.is_empty() {
let header_value = formatted_48;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expires",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Expires", header_value);
}
}
if let Some(inner_49) = &input.grant_full_control {
let formatted_50 = inner_49.as_str();
if !formatted_50.is_empty() {
let header_value = formatted_50;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_full_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-full-control", header_value);
}
}
if let Some(inner_51) = &input.grant_read {
let formatted_52 = inner_51.as_str();
if !formatted_52.is_empty() {
let header_value = formatted_52;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read", header_value);
}
}
if let Some(inner_53) = &input.grant_read_acp {
let formatted_54 = inner_53.as_str();
if !formatted_54.is_empty() {
let header_value = formatted_54;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read-acp", header_value);
}
}
if let Some(inner_55) = &input.grant_write_acp {
let formatted_56 = inner_55.as_str();
if !formatted_56.is_empty() {
let header_value = formatted_56;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write-acp", header_value);
}
}
if let Some(inner_57) = &input.metadata_directive {
let formatted_58 = inner_57.as_str();
if !formatted_58.is_empty() {
let header_value = formatted_58;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata_directive",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-metadata-directive", header_value);
}
}
if let Some(inner_59) = &input.tagging_directive {
let formatted_60 = inner_59.as_str();
if !formatted_60.is_empty() {
let header_value = formatted_60;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"tagging_directive",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-tagging-directive", header_value);
}
}
if let Some(inner_61) = &input.server_side_encryption {
let formatted_62 = inner_61.as_str();
if !formatted_62.is_empty() {
let header_value = formatted_62;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"server_side_encryption",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption", header_value);
}
}
if let Some(inner_63) = &input.storage_class {
let formatted_64 = inner_63.as_str();
if !formatted_64.is_empty() {
let header_value = formatted_64;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"storage_class",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-storage-class", header_value);
}
}
if let Some(inner_65) = &input.website_redirect_location {
let formatted_66 = inner_65.as_str();
if !formatted_66.is_empty() {
let header_value = formatted_66;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"website_redirect_location",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-website-redirect-location", header_value);
}
}
if let Some(inner_67) = &input.sse_customer_algorithm {
let formatted_68 = inner_67.as_str();
if !formatted_68.is_empty() {
let header_value = formatted_68;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_69) = &input.sse_customer_key {
let formatted_70 = inner_69.as_str();
if !formatted_70.is_empty() {
let header_value = formatted_70;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_71) = &input.sse_customer_key_md5 {
let formatted_72 = inner_71.as_str();
if !formatted_72.is_empty() {
let header_value = formatted_72;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_73) = &input.ssekms_key_id {
let formatted_74 = inner_73.as_str();
if !formatted_74.is_empty() {
let header_value = formatted_74;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"ssekms_key_id",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
}
}
if let Some(inner_75) = &input.ssekms_encryption_context {
let formatted_76 = inner_75.as_str();
if !formatted_76.is_empty() {
let header_value = formatted_76;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"ssekms_encryption_context",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-context", header_value);
}
}
if input.bucket_key_enabled {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.bucket_key_enabled);
let formatted_77 = encoder.encode();
if !formatted_77.is_empty() {
let header_value = formatted_77;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"bucket_key_enabled",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-bucket-key-enabled",
header_value,
);
}
}
if let Some(inner_78) = &input.copy_source_sse_customer_algorithm {
let formatted_79 = inner_78.as_str();
if !formatted_79.is_empty() {
let header_value = formatted_79;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-copy-source-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_80) = &input.copy_source_sse_customer_key {
let formatted_81 = inner_80.as_str();
if !formatted_81.is_empty() {
let header_value = formatted_81;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header(
"x-amz-copy-source-server-side-encryption-customer-key",
header_value,
);
}
}
if let Some(inner_82) = &input.copy_source_sse_customer_key_md5 {
let formatted_83 = inner_82.as_str();
if !formatted_83.is_empty() {
let header_value = formatted_83;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-copy-source-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_84) = &input.request_payer {
let formatted_85 = inner_84.as_str();
if !formatted_85.is_empty() {
let header_value = formatted_85;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_86) = &input.tagging {
let formatted_87 = inner_86.as_str();
if !formatted_87.is_empty() {
let header_value = formatted_87;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"tagging",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-tagging", header_value);
}
}
if let Some(inner_88) = &input.object_lock_mode {
let formatted_89 = inner_88.as_str();
if !formatted_89.is_empty() {
let header_value = formatted_89;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_mode",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-mode", header_value);
}
}
if let Some(inner_90) = &input.object_lock_retain_until_date {
let formatted_91 = inner_90.fmt(aws_smithy_types::date_time::Format::DateTime)?;
if !formatted_91.is_empty() {
let header_value = formatted_91;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_retain_until_date",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
}
}
if let Some(inner_92) = &input.object_lock_legal_hold_status {
let formatted_93 = inner_92.as_str();
if !formatted_93.is_empty() {
let header_value = formatted_93;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_legal_hold_status",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-legal-hold", header_value);
}
}
if let Some(inner_94) = &input.expected_bucket_owner {
let formatted_95 = inner_94.as_str();
if !formatted_95.is_empty() {
let header_value = formatted_95;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_96) = &input.expected_source_bucket_owner {
let formatted_97 = inner_96.as_str();
if !formatted_97.is_empty() {
let header_value = formatted_97;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_source_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
}
}
if let Some(inner_98) = &input.metadata {
{
for (k, v) in inner_98 {
use std::str::FromStr;
let header_name =
http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k))
.map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{k}` cannot be used as a header name: {err}"),
)
})?;
let header_value = v.as_str();
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{}` cannot be used as a header value: {}", v, err),
)
})?;
builder = builder.header(header_name, header_value);
}
}
}
Ok(builder)
}
pub fn add_headers_create_bucket(
input: &crate::input::CreateBucketInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_99) = &input.acl {
let formatted_100 = inner_99.as_str();
if !formatted_100.is_empty() {
let header_value = formatted_100;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"acl",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-acl", header_value);
}
}
if let Some(inner_101) = &input.grant_full_control {
let formatted_102 = inner_101.as_str();
if !formatted_102.is_empty() {
let header_value = formatted_102;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_full_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-full-control", header_value);
}
}
if let Some(inner_103) = &input.grant_read {
let formatted_104 = inner_103.as_str();
if !formatted_104.is_empty() {
let header_value = formatted_104;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read", header_value);
}
}
if let Some(inner_105) = &input.grant_read_acp {
let formatted_106 = inner_105.as_str();
if !formatted_106.is_empty() {
let header_value = formatted_106;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read-acp", header_value);
}
}
if let Some(inner_107) = &input.grant_write {
let formatted_108 = inner_107.as_str();
if !formatted_108.is_empty() {
let header_value = formatted_108;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write", header_value);
}
}
if let Some(inner_109) = &input.grant_write_acp {
let formatted_110 = inner_109.as_str();
if !formatted_110.is_empty() {
let header_value = formatted_110;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write-acp", header_value);
}
}
if input.object_lock_enabled_for_bucket {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.object_lock_enabled_for_bucket);
let formatted_111 = encoder.encode();
if !formatted_111.is_empty() {
let header_value = formatted_111;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_enabled_for_bucket",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-bucket-object-lock-enabled", header_value);
}
}
if let Some(inner_112) = &input.object_ownership {
let formatted_113 = inner_112.as_str();
if !formatted_113.is_empty() {
let header_value = formatted_113;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_ownership",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-ownership", header_value);
}
}
Ok(builder)
}
pub fn add_headers_create_multipart_upload(
input: &crate::input::CreateMultipartUploadInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_114) = &input.acl {
let formatted_115 = inner_114.as_str();
if !formatted_115.is_empty() {
let header_value = formatted_115;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"acl",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-acl", header_value);
}
}
if let Some(inner_116) = &input.cache_control {
let formatted_117 = inner_116.as_str();
if !formatted_117.is_empty() {
let header_value = formatted_117;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"cache_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Cache-Control", header_value);
}
}
if let Some(inner_118) = &input.content_disposition {
let formatted_119 = inner_118.as_str();
if !formatted_119.is_empty() {
let header_value = formatted_119;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_disposition",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Disposition", header_value);
}
}
if let Some(inner_120) = &input.content_encoding {
let formatted_121 = inner_120.as_str();
if !formatted_121.is_empty() {
let header_value = formatted_121;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_encoding",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Encoding", header_value);
}
}
if let Some(inner_122) = &input.content_language {
let formatted_123 = inner_122.as_str();
if !formatted_123.is_empty() {
let header_value = formatted_123;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_language",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Language", header_value);
}
}
if let Some(inner_124) = &input.content_type {
let formatted_125 = inner_124.as_str();
if !formatted_125.is_empty() {
let header_value = formatted_125;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Type", header_value);
}
}
if let Some(inner_126) = &input.expires {
let formatted_127 = inner_126.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_127.is_empty() {
let header_value = formatted_127;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expires",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Expires", header_value);
}
}
if let Some(inner_128) = &input.grant_full_control {
let formatted_129 = inner_128.as_str();
if !formatted_129.is_empty() {
let header_value = formatted_129;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_full_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-full-control", header_value);
}
}
if let Some(inner_130) = &input.grant_read {
let formatted_131 = inner_130.as_str();
if !formatted_131.is_empty() {
let header_value = formatted_131;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read", header_value);
}
}
if let Some(inner_132) = &input.grant_read_acp {
let formatted_133 = inner_132.as_str();
if !formatted_133.is_empty() {
let header_value = formatted_133;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read-acp", header_value);
}
}
if let Some(inner_134) = &input.grant_write_acp {
let formatted_135 = inner_134.as_str();
if !formatted_135.is_empty() {
let header_value = formatted_135;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write-acp", header_value);
}
}
if let Some(inner_136) = &input.server_side_encryption {
let formatted_137 = inner_136.as_str();
if !formatted_137.is_empty() {
let header_value = formatted_137;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"server_side_encryption",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption", header_value);
}
}
if let Some(inner_138) = &input.storage_class {
let formatted_139 = inner_138.as_str();
if !formatted_139.is_empty() {
let header_value = formatted_139;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"storage_class",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-storage-class", header_value);
}
}
if let Some(inner_140) = &input.website_redirect_location {
let formatted_141 = inner_140.as_str();
if !formatted_141.is_empty() {
let header_value = formatted_141;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"website_redirect_location",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-website-redirect-location", header_value);
}
}
if let Some(inner_142) = &input.sse_customer_algorithm {
let formatted_143 = inner_142.as_str();
if !formatted_143.is_empty() {
let header_value = formatted_143;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_144) = &input.sse_customer_key {
let formatted_145 = inner_144.as_str();
if !formatted_145.is_empty() {
let header_value = formatted_145;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_146) = &input.sse_customer_key_md5 {
let formatted_147 = inner_146.as_str();
if !formatted_147.is_empty() {
let header_value = formatted_147;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_148) = &input.ssekms_key_id {
let formatted_149 = inner_148.as_str();
if !formatted_149.is_empty() {
let header_value = formatted_149;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"ssekms_key_id",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
}
}
if let Some(inner_150) = &input.ssekms_encryption_context {
let formatted_151 = inner_150.as_str();
if !formatted_151.is_empty() {
let header_value = formatted_151;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"ssekms_encryption_context",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-context", header_value);
}
}
if input.bucket_key_enabled {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.bucket_key_enabled);
let formatted_152 = encoder.encode();
if !formatted_152.is_empty() {
let header_value = formatted_152;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"bucket_key_enabled",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-bucket-key-enabled",
header_value,
);
}
}
if let Some(inner_153) = &input.request_payer {
let formatted_154 = inner_153.as_str();
if !formatted_154.is_empty() {
let header_value = formatted_154;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_155) = &input.tagging {
let formatted_156 = inner_155.as_str();
if !formatted_156.is_empty() {
let header_value = formatted_156;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"tagging",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-tagging", header_value);
}
}
if let Some(inner_157) = &input.object_lock_mode {
let formatted_158 = inner_157.as_str();
if !formatted_158.is_empty() {
let header_value = formatted_158;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_mode",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-mode", header_value);
}
}
if let Some(inner_159) = &input.object_lock_retain_until_date {
let formatted_160 = inner_159.fmt(aws_smithy_types::date_time::Format::DateTime)?;
if !formatted_160.is_empty() {
let header_value = formatted_160;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_retain_until_date",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
}
}
if let Some(inner_161) = &input.object_lock_legal_hold_status {
let formatted_162 = inner_161.as_str();
if !formatted_162.is_empty() {
let header_value = formatted_162;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_legal_hold_status",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-legal-hold", header_value);
}
}
if let Some(inner_163) = &input.expected_bucket_owner {
let formatted_164 = inner_163.as_str();
if !formatted_164.is_empty() {
let header_value = formatted_164;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_165) = &input.checksum_algorithm {
let formatted_166 = inner_165.as_str();
if !formatted_166.is_empty() {
let header_value = formatted_166;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-algorithm", header_value);
}
}
if let Some(inner_167) = &input.metadata {
{
for (k, v) in inner_167 {
use std::str::FromStr;
let header_name =
http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k))
.map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{k}` cannot be used as a header name: {err}"),
)
})?;
let header_value = v.as_str();
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{}` cannot be used as a header value: {}", v, err),
)
})?;
builder = builder.header(header_name, header_value);
}
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket(
input: &crate::input::DeleteBucketInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_168) = &input.expected_bucket_owner {
let formatted_169 = inner_168.as_str();
if !formatted_169.is_empty() {
let header_value = formatted_169;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_analytics_configuration(
input: &crate::input::DeleteBucketAnalyticsConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_170) = &input.expected_bucket_owner {
let formatted_171 = inner_170.as_str();
if !formatted_171.is_empty() {
let header_value = formatted_171;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_cors(
input: &crate::input::DeleteBucketCorsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_172) = &input.expected_bucket_owner {
let formatted_173 = inner_172.as_str();
if !formatted_173.is_empty() {
let header_value = formatted_173;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_encryption(
input: &crate::input::DeleteBucketEncryptionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_174) = &input.expected_bucket_owner {
let formatted_175 = inner_174.as_str();
if !formatted_175.is_empty() {
let header_value = formatted_175;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_inventory_configuration(
input: &crate::input::DeleteBucketInventoryConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_176) = &input.expected_bucket_owner {
let formatted_177 = inner_176.as_str();
if !formatted_177.is_empty() {
let header_value = formatted_177;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_lifecycle(
input: &crate::input::DeleteBucketLifecycleInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_178) = &input.expected_bucket_owner {
let formatted_179 = inner_178.as_str();
if !formatted_179.is_empty() {
let header_value = formatted_179;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_metrics_configuration(
input: &crate::input::DeleteBucketMetricsConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_180) = &input.expected_bucket_owner {
let formatted_181 = inner_180.as_str();
if !formatted_181.is_empty() {
let header_value = formatted_181;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_ownership_controls(
input: &crate::input::DeleteBucketOwnershipControlsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_182) = &input.expected_bucket_owner {
let formatted_183 = inner_182.as_str();
if !formatted_183.is_empty() {
let header_value = formatted_183;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_policy(
input: &crate::input::DeleteBucketPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_184) = &input.expected_bucket_owner {
let formatted_185 = inner_184.as_str();
if !formatted_185.is_empty() {
let header_value = formatted_185;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_replication(
input: &crate::input::DeleteBucketReplicationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_186) = &input.expected_bucket_owner {
let formatted_187 = inner_186.as_str();
if !formatted_187.is_empty() {
let header_value = formatted_187;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_tagging(
input: &crate::input::DeleteBucketTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_188) = &input.expected_bucket_owner {
let formatted_189 = inner_188.as_str();
if !formatted_189.is_empty() {
let header_value = formatted_189;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_bucket_website(
input: &crate::input::DeleteBucketWebsiteInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_190) = &input.expected_bucket_owner {
let formatted_191 = inner_190.as_str();
if !formatted_191.is_empty() {
let header_value = formatted_191;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_object(
input: &crate::input::DeleteObjectInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_192) = &input.mfa {
let formatted_193 = inner_192.as_str();
if !formatted_193.is_empty() {
let header_value = formatted_193;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"mfa",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-mfa", header_value);
}
}
if let Some(inner_194) = &input.request_payer {
let formatted_195 = inner_194.as_str();
if !formatted_195.is_empty() {
let header_value = formatted_195;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if input.bypass_governance_retention {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.bypass_governance_retention);
let formatted_196 = encoder.encode();
if !formatted_196.is_empty() {
let header_value = formatted_196;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"bypass_governance_retention",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-bypass-governance-retention", header_value);
}
}
if let Some(inner_197) = &input.expected_bucket_owner {
let formatted_198 = inner_197.as_str();
if !formatted_198.is_empty() {
let header_value = formatted_198;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_objects(
input: &crate::input::DeleteObjectsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_199) = &input.mfa {
let formatted_200 = inner_199.as_str();
if !formatted_200.is_empty() {
let header_value = formatted_200;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"mfa",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-mfa", header_value);
}
}
if let Some(inner_201) = &input.request_payer {
let formatted_202 = inner_201.as_str();
if !formatted_202.is_empty() {
let header_value = formatted_202;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if input.bypass_governance_retention {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.bypass_governance_retention);
let formatted_203 = encoder.encode();
if !formatted_203.is_empty() {
let header_value = formatted_203;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"bypass_governance_retention",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-bypass-governance-retention", header_value);
}
}
if let Some(inner_204) = &input.expected_bucket_owner {
let formatted_205 = inner_204.as_str();
if !formatted_205.is_empty() {
let header_value = formatted_205;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_206) = &input.checksum_algorithm {
let formatted_207 = inner_206.as_str();
if !formatted_207.is_empty() {
let header_value = formatted_207;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_object_tagging(
input: &crate::input::DeleteObjectTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_208) = &input.expected_bucket_owner {
let formatted_209 = inner_208.as_str();
if !formatted_209.is_empty() {
let header_value = formatted_209;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_delete_public_access_block(
input: &crate::input::DeletePublicAccessBlockInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_210) = &input.expected_bucket_owner {
let formatted_211 = inner_210.as_str();
if !formatted_211.is_empty() {
let header_value = formatted_211;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_accelerate_configuration(
input: &crate::input::GetBucketAccelerateConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_212) = &input.expected_bucket_owner {
let formatted_213 = inner_212.as_str();
if !formatted_213.is_empty() {
let header_value = formatted_213;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_acl(
input: &crate::input::GetBucketAclInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_214) = &input.expected_bucket_owner {
let formatted_215 = inner_214.as_str();
if !formatted_215.is_empty() {
let header_value = formatted_215;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_analytics_configuration(
input: &crate::input::GetBucketAnalyticsConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_216) = &input.expected_bucket_owner {
let formatted_217 = inner_216.as_str();
if !formatted_217.is_empty() {
let header_value = formatted_217;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_cors(
input: &crate::input::GetBucketCorsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_218) = &input.expected_bucket_owner {
let formatted_219 = inner_218.as_str();
if !formatted_219.is_empty() {
let header_value = formatted_219;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_encryption(
input: &crate::input::GetBucketEncryptionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_220) = &input.expected_bucket_owner {
let formatted_221 = inner_220.as_str();
if !formatted_221.is_empty() {
let header_value = formatted_221;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_inventory_configuration(
input: &crate::input::GetBucketInventoryConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_222) = &input.expected_bucket_owner {
let formatted_223 = inner_222.as_str();
if !formatted_223.is_empty() {
let header_value = formatted_223;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_lifecycle_configuration(
input: &crate::input::GetBucketLifecycleConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_224) = &input.expected_bucket_owner {
let formatted_225 = inner_224.as_str();
if !formatted_225.is_empty() {
let header_value = formatted_225;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_location(
input: &crate::input::GetBucketLocationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_226) = &input.expected_bucket_owner {
let formatted_227 = inner_226.as_str();
if !formatted_227.is_empty() {
let header_value = formatted_227;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_logging(
input: &crate::input::GetBucketLoggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_228) = &input.expected_bucket_owner {
let formatted_229 = inner_228.as_str();
if !formatted_229.is_empty() {
let header_value = formatted_229;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_metrics_configuration(
input: &crate::input::GetBucketMetricsConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_230) = &input.expected_bucket_owner {
let formatted_231 = inner_230.as_str();
if !formatted_231.is_empty() {
let header_value = formatted_231;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_notification_configuration(
input: &crate::input::GetBucketNotificationConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_232) = &input.expected_bucket_owner {
let formatted_233 = inner_232.as_str();
if !formatted_233.is_empty() {
let header_value = formatted_233;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_ownership_controls(
input: &crate::input::GetBucketOwnershipControlsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_234) = &input.expected_bucket_owner {
let formatted_235 = inner_234.as_str();
if !formatted_235.is_empty() {
let header_value = formatted_235;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_policy(
input: &crate::input::GetBucketPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_236) = &input.expected_bucket_owner {
let formatted_237 = inner_236.as_str();
if !formatted_237.is_empty() {
let header_value = formatted_237;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_policy_status(
input: &crate::input::GetBucketPolicyStatusInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_238) = &input.expected_bucket_owner {
let formatted_239 = inner_238.as_str();
if !formatted_239.is_empty() {
let header_value = formatted_239;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_replication(
input: &crate::input::GetBucketReplicationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_240) = &input.expected_bucket_owner {
let formatted_241 = inner_240.as_str();
if !formatted_241.is_empty() {
let header_value = formatted_241;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_request_payment(
input: &crate::input::GetBucketRequestPaymentInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_242) = &input.expected_bucket_owner {
let formatted_243 = inner_242.as_str();
if !formatted_243.is_empty() {
let header_value = formatted_243;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_tagging(
input: &crate::input::GetBucketTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_244) = &input.expected_bucket_owner {
let formatted_245 = inner_244.as_str();
if !formatted_245.is_empty() {
let header_value = formatted_245;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_versioning(
input: &crate::input::GetBucketVersioningInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_246) = &input.expected_bucket_owner {
let formatted_247 = inner_246.as_str();
if !formatted_247.is_empty() {
let header_value = formatted_247;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_bucket_website(
input: &crate::input::GetBucketWebsiteInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_248) = &input.expected_bucket_owner {
let formatted_249 = inner_248.as_str();
if !formatted_249.is_empty() {
let header_value = formatted_249;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_object(
input: &crate::input::GetObjectInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_250) = &input.if_match {
let formatted_251 = inner_250.as_str();
if !formatted_251.is_empty() {
let header_value = formatted_251;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-Match", header_value);
}
}
if let Some(inner_252) = &input.if_modified_since {
let formatted_253 = inner_252.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_253.is_empty() {
let header_value = formatted_253;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_modified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-Modified-Since", header_value);
}
}
if let Some(inner_254) = &input.if_none_match {
let formatted_255 = inner_254.as_str();
if !formatted_255.is_empty() {
let header_value = formatted_255;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_none_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-None-Match", header_value);
}
}
if let Some(inner_256) = &input.if_unmodified_since {
let formatted_257 = inner_256.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_257.is_empty() {
let header_value = formatted_257;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_unmodified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-Unmodified-Since", header_value);
}
}
if let Some(inner_258) = &input.range {
let formatted_259 = inner_258.as_str();
if !formatted_259.is_empty() {
let header_value = formatted_259;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"range",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Range", header_value);
}
}
if let Some(inner_260) = &input.sse_customer_algorithm {
let formatted_261 = inner_260.as_str();
if !formatted_261.is_empty() {
let header_value = formatted_261;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_262) = &input.sse_customer_key {
let formatted_263 = inner_262.as_str();
if !formatted_263.is_empty() {
let header_value = formatted_263;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_264) = &input.sse_customer_key_md5 {
let formatted_265 = inner_264.as_str();
if !formatted_265.is_empty() {
let header_value = formatted_265;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_266) = &input.request_payer {
let formatted_267 = inner_266.as_str();
if !formatted_267.is_empty() {
let header_value = formatted_267;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_268) = &input.expected_bucket_owner {
let formatted_269 = inner_268.as_str();
if !formatted_269.is_empty() {
let header_value = formatted_269;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_270) = &input.checksum_mode {
let formatted_271 = inner_270.as_str();
if !formatted_271.is_empty() {
let header_value = formatted_271;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_mode",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-mode", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_object_acl(
input: &crate::input::GetObjectAclInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_272) = &input.request_payer {
let formatted_273 = inner_272.as_str();
if !formatted_273.is_empty() {
let header_value = formatted_273;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_274) = &input.expected_bucket_owner {
let formatted_275 = inner_274.as_str();
if !formatted_275.is_empty() {
let header_value = formatted_275;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_object_attributes(
input: &crate::input::GetObjectAttributesInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if input.max_parts != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.max_parts);
let formatted_276 = encoder.encode();
if !formatted_276.is_empty() {
let header_value = formatted_276;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"max_parts",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-max-parts", header_value);
}
}
if let Some(inner_277) = &input.part_number_marker {
let formatted_278 = inner_277.as_str();
if !formatted_278.is_empty() {
let header_value = formatted_278;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"part_number_marker",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-part-number-marker", header_value);
}
}
if let Some(inner_279) = &input.sse_customer_algorithm {
let formatted_280 = inner_279.as_str();
if !formatted_280.is_empty() {
let header_value = formatted_280;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_281) = &input.sse_customer_key {
let formatted_282 = inner_281.as_str();
if !formatted_282.is_empty() {
let header_value = formatted_282;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_283) = &input.sse_customer_key_md5 {
let formatted_284 = inner_283.as_str();
if !formatted_284.is_empty() {
let header_value = formatted_284;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_285) = &input.request_payer {
let formatted_286 = inner_285.as_str();
if !formatted_286.is_empty() {
let header_value = formatted_286;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_287) = &input.expected_bucket_owner {
let formatted_288 = inner_287.as_str();
if !formatted_288.is_empty() {
let header_value = formatted_288;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_289) = &input.object_attributes {
for inner_290 in inner_289 {
let formatted_291 = aws_smithy_http::header::quote_header_value(inner_290.as_str());
if !formatted_291.is_empty() {
let header_value = formatted_291;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_attributes",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-attributes", header_value);
}
}
}
Ok(builder)
}
pub fn add_headers_get_object_legal_hold(
input: &crate::input::GetObjectLegalHoldInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_292) = &input.request_payer {
let formatted_293 = inner_292.as_str();
if !formatted_293.is_empty() {
let header_value = formatted_293;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_294) = &input.expected_bucket_owner {
let formatted_295 = inner_294.as_str();
if !formatted_295.is_empty() {
let header_value = formatted_295;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_object_lock_configuration(
input: &crate::input::GetObjectLockConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_296) = &input.expected_bucket_owner {
let formatted_297 = inner_296.as_str();
if !formatted_297.is_empty() {
let header_value = formatted_297;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_object_retention(
input: &crate::input::GetObjectRetentionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_298) = &input.request_payer {
let formatted_299 = inner_298.as_str();
if !formatted_299.is_empty() {
let header_value = formatted_299;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_300) = &input.expected_bucket_owner {
let formatted_301 = inner_300.as_str();
if !formatted_301.is_empty() {
let header_value = formatted_301;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_object_tagging(
input: &crate::input::GetObjectTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_302) = &input.expected_bucket_owner {
let formatted_303 = inner_302.as_str();
if !formatted_303.is_empty() {
let header_value = formatted_303;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_304) = &input.request_payer {
let formatted_305 = inner_304.as_str();
if !formatted_305.is_empty() {
let header_value = formatted_305;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_object_torrent(
input: &crate::input::GetObjectTorrentInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_306) = &input.request_payer {
let formatted_307 = inner_306.as_str();
if !formatted_307.is_empty() {
let header_value = formatted_307;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_308) = &input.expected_bucket_owner {
let formatted_309 = inner_308.as_str();
if !formatted_309.is_empty() {
let header_value = formatted_309;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_get_public_access_block(
input: &crate::input::GetPublicAccessBlockInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_310) = &input.expected_bucket_owner {
let formatted_311 = inner_310.as_str();
if !formatted_311.is_empty() {
let header_value = formatted_311;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_head_bucket(
input: &crate::input::HeadBucketInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_312) = &input.expected_bucket_owner {
let formatted_313 = inner_312.as_str();
if !formatted_313.is_empty() {
let header_value = formatted_313;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_head_object(
input: &crate::input::HeadObjectInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_314) = &input.if_match {
let formatted_315 = inner_314.as_str();
if !formatted_315.is_empty() {
let header_value = formatted_315;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-Match", header_value);
}
}
if let Some(inner_316) = &input.if_modified_since {
let formatted_317 = inner_316.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_317.is_empty() {
let header_value = formatted_317;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_modified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-Modified-Since", header_value);
}
}
if let Some(inner_318) = &input.if_none_match {
let formatted_319 = inner_318.as_str();
if !formatted_319.is_empty() {
let header_value = formatted_319;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_none_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-None-Match", header_value);
}
}
if let Some(inner_320) = &input.if_unmodified_since {
let formatted_321 = inner_320.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_321.is_empty() {
let header_value = formatted_321;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"if_unmodified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("If-Unmodified-Since", header_value);
}
}
if let Some(inner_322) = &input.range {
let formatted_323 = inner_322.as_str();
if !formatted_323.is_empty() {
let header_value = formatted_323;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"range",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Range", header_value);
}
}
if let Some(inner_324) = &input.sse_customer_algorithm {
let formatted_325 = inner_324.as_str();
if !formatted_325.is_empty() {
let header_value = formatted_325;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_326) = &input.sse_customer_key {
let formatted_327 = inner_326.as_str();
if !formatted_327.is_empty() {
let header_value = formatted_327;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_328) = &input.sse_customer_key_md5 {
let formatted_329 = inner_328.as_str();
if !formatted_329.is_empty() {
let header_value = formatted_329;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_330) = &input.request_payer {
let formatted_331 = inner_330.as_str();
if !formatted_331.is_empty() {
let header_value = formatted_331;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_332) = &input.expected_bucket_owner {
let formatted_333 = inner_332.as_str();
if !formatted_333.is_empty() {
let header_value = formatted_333;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_334) = &input.checksum_mode {
let formatted_335 = inner_334.as_str();
if !formatted_335.is_empty() {
let header_value = formatted_335;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_mode",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-mode", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_bucket_analytics_configurations(
input: &crate::input::ListBucketAnalyticsConfigurationsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_336) = &input.expected_bucket_owner {
let formatted_337 = inner_336.as_str();
if !formatted_337.is_empty() {
let header_value = formatted_337;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_bucket_inventory_configurations(
input: &crate::input::ListBucketInventoryConfigurationsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_338) = &input.expected_bucket_owner {
let formatted_339 = inner_338.as_str();
if !formatted_339.is_empty() {
let header_value = formatted_339;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_bucket_metrics_configurations(
input: &crate::input::ListBucketMetricsConfigurationsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_340) = &input.expected_bucket_owner {
let formatted_341 = inner_340.as_str();
if !formatted_341.is_empty() {
let header_value = formatted_341;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_multipart_uploads(
input: &crate::input::ListMultipartUploadsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_342) = &input.expected_bucket_owner {
let formatted_343 = inner_342.as_str();
if !formatted_343.is_empty() {
let header_value = formatted_343;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_objects(
input: &crate::input::ListObjectsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_344) = &input.request_payer {
let formatted_345 = inner_344.as_str();
if !formatted_345.is_empty() {
let header_value = formatted_345;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_346) = &input.expected_bucket_owner {
let formatted_347 = inner_346.as_str();
if !formatted_347.is_empty() {
let header_value = formatted_347;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_objects_v2(
input: &crate::input::ListObjectsV2Input,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_348) = &input.request_payer {
let formatted_349 = inner_348.as_str();
if !formatted_349.is_empty() {
let header_value = formatted_349;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_350) = &input.expected_bucket_owner {
let formatted_351 = inner_350.as_str();
if !formatted_351.is_empty() {
let header_value = formatted_351;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_object_versions(
input: &crate::input::ListObjectVersionsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_352) = &input.expected_bucket_owner {
let formatted_353 = inner_352.as_str();
if !formatted_353.is_empty() {
let header_value = formatted_353;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_list_parts(
input: &crate::input::ListPartsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_354) = &input.request_payer {
let formatted_355 = inner_354.as_str();
if !formatted_355.is_empty() {
let header_value = formatted_355;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_356) = &input.expected_bucket_owner {
let formatted_357 = inner_356.as_str();
if !formatted_357.is_empty() {
let header_value = formatted_357;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_358) = &input.sse_customer_algorithm {
let formatted_359 = inner_358.as_str();
if !formatted_359.is_empty() {
let header_value = formatted_359;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_360) = &input.sse_customer_key {
let formatted_361 = inner_360.as_str();
if !formatted_361.is_empty() {
let header_value = formatted_361;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_362) = &input.sse_customer_key_md5 {
let formatted_363 = inner_362.as_str();
if !formatted_363.is_empty() {
let header_value = formatted_363;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_accelerate_configuration(
input: &crate::input::PutBucketAccelerateConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_364) = &input.expected_bucket_owner {
let formatted_365 = inner_364.as_str();
if !formatted_365.is_empty() {
let header_value = formatted_365;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_366) = &input.checksum_algorithm {
let formatted_367 = inner_366.as_str();
if !formatted_367.is_empty() {
let header_value = formatted_367;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_acl(
input: &crate::input::PutBucketAclInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_368) = &input.acl {
let formatted_369 = inner_368.as_str();
if !formatted_369.is_empty() {
let header_value = formatted_369;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"acl",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-acl", header_value);
}
}
if let Some(inner_370) = &input.content_md5 {
let formatted_371 = inner_370.as_str();
if !formatted_371.is_empty() {
let header_value = formatted_371;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_372) = &input.checksum_algorithm {
let formatted_373 = inner_372.as_str();
if !formatted_373.is_empty() {
let header_value = formatted_373;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_374) = &input.grant_full_control {
let formatted_375 = inner_374.as_str();
if !formatted_375.is_empty() {
let header_value = formatted_375;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_full_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-full-control", header_value);
}
}
if let Some(inner_376) = &input.grant_read {
let formatted_377 = inner_376.as_str();
if !formatted_377.is_empty() {
let header_value = formatted_377;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read", header_value);
}
}
if let Some(inner_378) = &input.grant_read_acp {
let formatted_379 = inner_378.as_str();
if !formatted_379.is_empty() {
let header_value = formatted_379;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read-acp", header_value);
}
}
if let Some(inner_380) = &input.grant_write {
let formatted_381 = inner_380.as_str();
if !formatted_381.is_empty() {
let header_value = formatted_381;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write", header_value);
}
}
if let Some(inner_382) = &input.grant_write_acp {
let formatted_383 = inner_382.as_str();
if !formatted_383.is_empty() {
let header_value = formatted_383;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write-acp", header_value);
}
}
if let Some(inner_384) = &input.expected_bucket_owner {
let formatted_385 = inner_384.as_str();
if !formatted_385.is_empty() {
let header_value = formatted_385;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_analytics_configuration(
input: &crate::input::PutBucketAnalyticsConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_386) = &input.expected_bucket_owner {
let formatted_387 = inner_386.as_str();
if !formatted_387.is_empty() {
let header_value = formatted_387;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_cors(
input: &crate::input::PutBucketCorsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_388) = &input.content_md5 {
let formatted_389 = inner_388.as_str();
if !formatted_389.is_empty() {
let header_value = formatted_389;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_390) = &input.checksum_algorithm {
let formatted_391 = inner_390.as_str();
if !formatted_391.is_empty() {
let header_value = formatted_391;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_392) = &input.expected_bucket_owner {
let formatted_393 = inner_392.as_str();
if !formatted_393.is_empty() {
let header_value = formatted_393;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_encryption(
input: &crate::input::PutBucketEncryptionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_394) = &input.content_md5 {
let formatted_395 = inner_394.as_str();
if !formatted_395.is_empty() {
let header_value = formatted_395;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_396) = &input.checksum_algorithm {
let formatted_397 = inner_396.as_str();
if !formatted_397.is_empty() {
let header_value = formatted_397;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_398) = &input.expected_bucket_owner {
let formatted_399 = inner_398.as_str();
if !formatted_399.is_empty() {
let header_value = formatted_399;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_inventory_configuration(
input: &crate::input::PutBucketInventoryConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_400) = &input.expected_bucket_owner {
let formatted_401 = inner_400.as_str();
if !formatted_401.is_empty() {
let header_value = formatted_401;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_lifecycle_configuration(
input: &crate::input::PutBucketLifecycleConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_402) = &input.checksum_algorithm {
let formatted_403 = inner_402.as_str();
if !formatted_403.is_empty() {
let header_value = formatted_403;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_404) = &input.expected_bucket_owner {
let formatted_405 = inner_404.as_str();
if !formatted_405.is_empty() {
let header_value = formatted_405;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_logging(
input: &crate::input::PutBucketLoggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_406) = &input.content_md5 {
let formatted_407 = inner_406.as_str();
if !formatted_407.is_empty() {
let header_value = formatted_407;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_408) = &input.checksum_algorithm {
let formatted_409 = inner_408.as_str();
if !formatted_409.is_empty() {
let header_value = formatted_409;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_410) = &input.expected_bucket_owner {
let formatted_411 = inner_410.as_str();
if !formatted_411.is_empty() {
let header_value = formatted_411;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_metrics_configuration(
input: &crate::input::PutBucketMetricsConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_412) = &input.expected_bucket_owner {
let formatted_413 = inner_412.as_str();
if !formatted_413.is_empty() {
let header_value = formatted_413;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_notification_configuration(
input: &crate::input::PutBucketNotificationConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_414) = &input.expected_bucket_owner {
let formatted_415 = inner_414.as_str();
if !formatted_415.is_empty() {
let header_value = formatted_415;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if input.skip_destination_validation {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.skip_destination_validation);
let formatted_416 = encoder.encode();
if !formatted_416.is_empty() {
let header_value = formatted_416;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"skip_destination_validation",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-skip-destination-validation", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_ownership_controls(
input: &crate::input::PutBucketOwnershipControlsInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_417) = &input.content_md5 {
let formatted_418 = inner_417.as_str();
if !formatted_418.is_empty() {
let header_value = formatted_418;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_419) = &input.expected_bucket_owner {
let formatted_420 = inner_419.as_str();
if !formatted_420.is_empty() {
let header_value = formatted_420;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_policy(
input: &crate::input::PutBucketPolicyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_421) = &input.content_md5 {
let formatted_422 = inner_421.as_str();
if !formatted_422.is_empty() {
let header_value = formatted_422;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_423) = &input.checksum_algorithm {
let formatted_424 = inner_423.as_str();
if !formatted_424.is_empty() {
let header_value = formatted_424;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if input.confirm_remove_self_bucket_access {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.confirm_remove_self_bucket_access);
let formatted_425 = encoder.encode();
if !formatted_425.is_empty() {
let header_value = formatted_425;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"confirm_remove_self_bucket_access",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-confirm-remove-self-bucket-access", header_value);
}
}
if let Some(inner_426) = &input.expected_bucket_owner {
let formatted_427 = inner_426.as_str();
if !formatted_427.is_empty() {
let header_value = formatted_427;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_replication(
input: &crate::input::PutBucketReplicationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_428) = &input.content_md5 {
let formatted_429 = inner_428.as_str();
if !formatted_429.is_empty() {
let header_value = formatted_429;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_430) = &input.checksum_algorithm {
let formatted_431 = inner_430.as_str();
if !formatted_431.is_empty() {
let header_value = formatted_431;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_432) = &input.token {
let formatted_433 = inner_432.as_str();
if !formatted_433.is_empty() {
let header_value = formatted_433;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"token",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-bucket-object-lock-token", header_value);
}
}
if let Some(inner_434) = &input.expected_bucket_owner {
let formatted_435 = inner_434.as_str();
if !formatted_435.is_empty() {
let header_value = formatted_435;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_request_payment(
input: &crate::input::PutBucketRequestPaymentInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_436) = &input.content_md5 {
let formatted_437 = inner_436.as_str();
if !formatted_437.is_empty() {
let header_value = formatted_437;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_438) = &input.checksum_algorithm {
let formatted_439 = inner_438.as_str();
if !formatted_439.is_empty() {
let header_value = formatted_439;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_440) = &input.expected_bucket_owner {
let formatted_441 = inner_440.as_str();
if !formatted_441.is_empty() {
let header_value = formatted_441;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_tagging(
input: &crate::input::PutBucketTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_442) = &input.content_md5 {
let formatted_443 = inner_442.as_str();
if !formatted_443.is_empty() {
let header_value = formatted_443;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_444) = &input.checksum_algorithm {
let formatted_445 = inner_444.as_str();
if !formatted_445.is_empty() {
let header_value = formatted_445;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_446) = &input.expected_bucket_owner {
let formatted_447 = inner_446.as_str();
if !formatted_447.is_empty() {
let header_value = formatted_447;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_versioning(
input: &crate::input::PutBucketVersioningInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_448) = &input.content_md5 {
let formatted_449 = inner_448.as_str();
if !formatted_449.is_empty() {
let header_value = formatted_449;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_450) = &input.checksum_algorithm {
let formatted_451 = inner_450.as_str();
if !formatted_451.is_empty() {
let header_value = formatted_451;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_452) = &input.mfa {
let formatted_453 = inner_452.as_str();
if !formatted_453.is_empty() {
let header_value = formatted_453;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"mfa",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-mfa", header_value);
}
}
if let Some(inner_454) = &input.expected_bucket_owner {
let formatted_455 = inner_454.as_str();
if !formatted_455.is_empty() {
let header_value = formatted_455;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_bucket_website(
input: &crate::input::PutBucketWebsiteInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_456) = &input.content_md5 {
let formatted_457 = inner_456.as_str();
if !formatted_457.is_empty() {
let header_value = formatted_457;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_458) = &input.checksum_algorithm {
let formatted_459 = inner_458.as_str();
if !formatted_459.is_empty() {
let header_value = formatted_459;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_460) = &input.expected_bucket_owner {
let formatted_461 = inner_460.as_str();
if !formatted_461.is_empty() {
let header_value = formatted_461;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_object(
input: &crate::input::PutObjectInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_462) = &input.acl {
let formatted_463 = inner_462.as_str();
if !formatted_463.is_empty() {
let header_value = formatted_463;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"acl",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-acl", header_value);
}
}
if let Some(inner_464) = &input.cache_control {
let formatted_465 = inner_464.as_str();
if !formatted_465.is_empty() {
let header_value = formatted_465;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"cache_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Cache-Control", header_value);
}
}
if let Some(inner_466) = &input.content_disposition {
let formatted_467 = inner_466.as_str();
if !formatted_467.is_empty() {
let header_value = formatted_467;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_disposition",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Disposition", header_value);
}
}
if let Some(inner_468) = &input.content_encoding {
let formatted_469 = inner_468.as_str();
if !formatted_469.is_empty() {
let header_value = formatted_469;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_encoding",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Encoding", header_value);
}
}
if let Some(inner_470) = &input.content_language {
let formatted_471 = inner_470.as_str();
if !formatted_471.is_empty() {
let header_value = formatted_471;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_language",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Language", header_value);
}
}
if input.content_length != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.content_length);
let formatted_472 = encoder.encode();
if !formatted_472.is_empty() {
let header_value = formatted_472;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_length",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Length", header_value);
}
}
if let Some(inner_473) = &input.content_md5 {
let formatted_474 = inner_473.as_str();
if !formatted_474.is_empty() {
let header_value = formatted_474;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_475) = &input.content_type {
let formatted_476 = inner_475.as_str();
if !formatted_476.is_empty() {
let header_value = formatted_476;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Type", header_value);
}
}
if let Some(inner_477) = &input.checksum_algorithm {
let formatted_478 = inner_477.as_str();
if !formatted_478.is_empty() {
let header_value = formatted_478;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_479) = &input.checksum_crc32 {
let formatted_480 = inner_479.as_str();
if !formatted_480.is_empty() {
let header_value = formatted_480;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-crc32", header_value);
}
}
if let Some(inner_481) = &input.checksum_crc32_c {
let formatted_482 = inner_481.as_str();
if !formatted_482.is_empty() {
let header_value = formatted_482;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32_c",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-crc32c", header_value);
}
}
if let Some(inner_483) = &input.checksum_sha1 {
let formatted_484 = inner_483.as_str();
if !formatted_484.is_empty() {
let header_value = formatted_484;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha1",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-sha1", header_value);
}
}
if let Some(inner_485) = &input.checksum_sha256 {
let formatted_486 = inner_485.as_str();
if !formatted_486.is_empty() {
let header_value = formatted_486;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha256",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-sha256", header_value);
}
}
if let Some(inner_487) = &input.expires {
let formatted_488 = inner_487.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_488.is_empty() {
let header_value = formatted_488;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expires",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Expires", header_value);
}
}
if let Some(inner_489) = &input.grant_full_control {
let formatted_490 = inner_489.as_str();
if !formatted_490.is_empty() {
let header_value = formatted_490;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_full_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-full-control", header_value);
}
}
if let Some(inner_491) = &input.grant_read {
let formatted_492 = inner_491.as_str();
if !formatted_492.is_empty() {
let header_value = formatted_492;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read", header_value);
}
}
if let Some(inner_493) = &input.grant_read_acp {
let formatted_494 = inner_493.as_str();
if !formatted_494.is_empty() {
let header_value = formatted_494;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read-acp", header_value);
}
}
if let Some(inner_495) = &input.grant_write_acp {
let formatted_496 = inner_495.as_str();
if !formatted_496.is_empty() {
let header_value = formatted_496;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write-acp", header_value);
}
}
if let Some(inner_497) = &input.server_side_encryption {
let formatted_498 = inner_497.as_str();
if !formatted_498.is_empty() {
let header_value = formatted_498;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"server_side_encryption",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption", header_value);
}
}
if let Some(inner_499) = &input.storage_class {
let formatted_500 = inner_499.as_str();
if !formatted_500.is_empty() {
let header_value = formatted_500;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"storage_class",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-storage-class", header_value);
}
}
if let Some(inner_501) = &input.website_redirect_location {
let formatted_502 = inner_501.as_str();
if !formatted_502.is_empty() {
let header_value = formatted_502;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"website_redirect_location",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-website-redirect-location", header_value);
}
}
if let Some(inner_503) = &input.sse_customer_algorithm {
let formatted_504 = inner_503.as_str();
if !formatted_504.is_empty() {
let header_value = formatted_504;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_505) = &input.sse_customer_key {
let formatted_506 = inner_505.as_str();
if !formatted_506.is_empty() {
let header_value = formatted_506;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_507) = &input.sse_customer_key_md5 {
let formatted_508 = inner_507.as_str();
if !formatted_508.is_empty() {
let header_value = formatted_508;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_509) = &input.ssekms_key_id {
let formatted_510 = inner_509.as_str();
if !formatted_510.is_empty() {
let header_value = formatted_510;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"ssekms_key_id",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
}
}
if let Some(inner_511) = &input.ssekms_encryption_context {
let formatted_512 = inner_511.as_str();
if !formatted_512.is_empty() {
let header_value = formatted_512;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"ssekms_encryption_context",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-context", header_value);
}
}
if input.bucket_key_enabled {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.bucket_key_enabled);
let formatted_513 = encoder.encode();
if !formatted_513.is_empty() {
let header_value = formatted_513;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"bucket_key_enabled",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-bucket-key-enabled",
header_value,
);
}
}
if let Some(inner_514) = &input.request_payer {
let formatted_515 = inner_514.as_str();
if !formatted_515.is_empty() {
let header_value = formatted_515;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_516) = &input.tagging {
let formatted_517 = inner_516.as_str();
if !formatted_517.is_empty() {
let header_value = formatted_517;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"tagging",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-tagging", header_value);
}
}
if let Some(inner_518) = &input.object_lock_mode {
let formatted_519 = inner_518.as_str();
if !formatted_519.is_empty() {
let header_value = formatted_519;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_mode",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-mode", header_value);
}
}
if let Some(inner_520) = &input.object_lock_retain_until_date {
let formatted_521 = inner_520.fmt(aws_smithy_types::date_time::Format::DateTime)?;
if !formatted_521.is_empty() {
let header_value = formatted_521;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_retain_until_date",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
}
}
if let Some(inner_522) = &input.object_lock_legal_hold_status {
let formatted_523 = inner_522.as_str();
if !formatted_523.is_empty() {
let header_value = formatted_523;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_legal_hold_status",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-object-lock-legal-hold", header_value);
}
}
if let Some(inner_524) = &input.expected_bucket_owner {
let formatted_525 = inner_524.as_str();
if !formatted_525.is_empty() {
let header_value = formatted_525;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_526) = &input.metadata {
{
for (k, v) in inner_526 {
use std::str::FromStr;
let header_name =
http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k))
.map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{k}` cannot be used as a header name: {err}"),
)
})?;
let header_value = v.as_str();
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{}` cannot be used as a header value: {}", v, err),
)
})?;
builder = builder.header(header_name, header_value);
}
}
}
Ok(builder)
}
pub fn add_headers_put_object_acl(
input: &crate::input::PutObjectAclInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_527) = &input.acl {
let formatted_528 = inner_527.as_str();
if !formatted_528.is_empty() {
let header_value = formatted_528;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"acl",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-acl", header_value);
}
}
if let Some(inner_529) = &input.content_md5 {
let formatted_530 = inner_529.as_str();
if !formatted_530.is_empty() {
let header_value = formatted_530;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_531) = &input.checksum_algorithm {
let formatted_532 = inner_531.as_str();
if !formatted_532.is_empty() {
let header_value = formatted_532;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_533) = &input.grant_full_control {
let formatted_534 = inner_533.as_str();
if !formatted_534.is_empty() {
let header_value = formatted_534;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_full_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-full-control", header_value);
}
}
if let Some(inner_535) = &input.grant_read {
let formatted_536 = inner_535.as_str();
if !formatted_536.is_empty() {
let header_value = formatted_536;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read", header_value);
}
}
if let Some(inner_537) = &input.grant_read_acp {
let formatted_538 = inner_537.as_str();
if !formatted_538.is_empty() {
let header_value = formatted_538;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_read_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-read-acp", header_value);
}
}
if let Some(inner_539) = &input.grant_write {
let formatted_540 = inner_539.as_str();
if !formatted_540.is_empty() {
let header_value = formatted_540;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write", header_value);
}
}
if let Some(inner_541) = &input.grant_write_acp {
let formatted_542 = inner_541.as_str();
if !formatted_542.is_empty() {
let header_value = formatted_542;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"grant_write_acp",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-grant-write-acp", header_value);
}
}
if let Some(inner_543) = &input.request_payer {
let formatted_544 = inner_543.as_str();
if !formatted_544.is_empty() {
let header_value = formatted_544;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_545) = &input.expected_bucket_owner {
let formatted_546 = inner_545.as_str();
if !formatted_546.is_empty() {
let header_value = formatted_546;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_object_legal_hold(
input: &crate::input::PutObjectLegalHoldInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_547) = &input.request_payer {
let formatted_548 = inner_547.as_str();
if !formatted_548.is_empty() {
let header_value = formatted_548;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_549) = &input.content_md5 {
let formatted_550 = inner_549.as_str();
if !formatted_550.is_empty() {
let header_value = formatted_550;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_551) = &input.checksum_algorithm {
let formatted_552 = inner_551.as_str();
if !formatted_552.is_empty() {
let header_value = formatted_552;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_553) = &input.expected_bucket_owner {
let formatted_554 = inner_553.as_str();
if !formatted_554.is_empty() {
let header_value = formatted_554;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_object_lock_configuration(
input: &crate::input::PutObjectLockConfigurationInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_555) = &input.request_payer {
let formatted_556 = inner_555.as_str();
if !formatted_556.is_empty() {
let header_value = formatted_556;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_557) = &input.token {
let formatted_558 = inner_557.as_str();
if !formatted_558.is_empty() {
let header_value = formatted_558;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"token",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-bucket-object-lock-token", header_value);
}
}
if let Some(inner_559) = &input.content_md5 {
let formatted_560 = inner_559.as_str();
if !formatted_560.is_empty() {
let header_value = formatted_560;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_561) = &input.checksum_algorithm {
let formatted_562 = inner_561.as_str();
if !formatted_562.is_empty() {
let header_value = formatted_562;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_563) = &input.expected_bucket_owner {
let formatted_564 = inner_563.as_str();
if !formatted_564.is_empty() {
let header_value = formatted_564;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_object_retention(
input: &crate::input::PutObjectRetentionInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_565) = &input.request_payer {
let formatted_566 = inner_565.as_str();
if !formatted_566.is_empty() {
let header_value = formatted_566;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if input.bypass_governance_retention {
let mut encoder =
aws_smithy_types::primitive::Encoder::from(input.bypass_governance_retention);
let formatted_567 = encoder.encode();
if !formatted_567.is_empty() {
let header_value = formatted_567;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"bypass_governance_retention",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-bypass-governance-retention", header_value);
}
}
if let Some(inner_568) = &input.content_md5 {
let formatted_569 = inner_568.as_str();
if !formatted_569.is_empty() {
let header_value = formatted_569;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_570) = &input.checksum_algorithm {
let formatted_571 = inner_570.as_str();
if !formatted_571.is_empty() {
let header_value = formatted_571;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_572) = &input.expected_bucket_owner {
let formatted_573 = inner_572.as_str();
if !formatted_573.is_empty() {
let header_value = formatted_573;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_object_tagging(
input: &crate::input::PutObjectTaggingInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_574) = &input.content_md5 {
let formatted_575 = inner_574.as_str();
if !formatted_575.is_empty() {
let header_value = formatted_575;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_576) = &input.checksum_algorithm {
let formatted_577 = inner_576.as_str();
if !formatted_577.is_empty() {
let header_value = formatted_577;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_578) = &input.expected_bucket_owner {
let formatted_579 = inner_578.as_str();
if !formatted_579.is_empty() {
let header_value = formatted_579;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_580) = &input.request_payer {
let formatted_581 = inner_580.as_str();
if !formatted_581.is_empty() {
let header_value = formatted_581;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
Ok(builder)
}
pub fn add_headers_put_public_access_block(
input: &crate::input::PutPublicAccessBlockInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_582) = &input.content_md5 {
let formatted_583 = inner_582.as_str();
if !formatted_583.is_empty() {
let header_value = formatted_583;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_584) = &input.checksum_algorithm {
let formatted_585 = inner_584.as_str();
if !formatted_585.is_empty() {
let header_value = formatted_585;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_586) = &input.expected_bucket_owner {
let formatted_587 = inner_586.as_str();
if !formatted_587.is_empty() {
let header_value = formatted_587;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_restore_object(
input: &crate::input::RestoreObjectInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_588) = &input.request_payer {
let formatted_589 = inner_588.as_str();
if !formatted_589.is_empty() {
let header_value = formatted_589;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_590) = &input.checksum_algorithm {
let formatted_591 = inner_590.as_str();
if !formatted_591.is_empty() {
let header_value = formatted_591;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_592) = &input.expected_bucket_owner {
let formatted_593 = inner_592.as_str();
if !formatted_593.is_empty() {
let header_value = formatted_593;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_select_object_content(
input: &crate::input::SelectObjectContentInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_594) = &input.sse_customer_algorithm {
let formatted_595 = inner_594.as_str();
if !formatted_595.is_empty() {
let header_value = formatted_595;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_596) = &input.sse_customer_key {
let formatted_597 = inner_596.as_str();
if !formatted_597.is_empty() {
let header_value = formatted_597;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_598) = &input.sse_customer_key_md5 {
let formatted_599 = inner_598.as_str();
if !formatted_599.is_empty() {
let header_value = formatted_599;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_600) = &input.expected_bucket_owner {
let formatted_601 = inner_600.as_str();
if !formatted_601.is_empty() {
let header_value = formatted_601;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_upload_part(
input: &crate::input::UploadPartInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if input.content_length != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.content_length);
let formatted_602 = encoder.encode();
if !formatted_602.is_empty() {
let header_value = formatted_602;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_length",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Length", header_value);
}
}
if let Some(inner_603) = &input.content_md5 {
let formatted_604 = inner_603.as_str();
if !formatted_604.is_empty() {
let header_value = formatted_604;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-MD5", header_value);
}
}
if let Some(inner_605) = &input.checksum_algorithm {
let formatted_606 = inner_605.as_str();
if !formatted_606.is_empty() {
let header_value = formatted_606;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
}
}
if let Some(inner_607) = &input.checksum_crc32 {
let formatted_608 = inner_607.as_str();
if !formatted_608.is_empty() {
let header_value = formatted_608;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-crc32", header_value);
}
}
if let Some(inner_609) = &input.checksum_crc32_c {
let formatted_610 = inner_609.as_str();
if !formatted_610.is_empty() {
let header_value = formatted_610;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32_c",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-crc32c", header_value);
}
}
if let Some(inner_611) = &input.checksum_sha1 {
let formatted_612 = inner_611.as_str();
if !formatted_612.is_empty() {
let header_value = formatted_612;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha1",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-sha1", header_value);
}
}
if let Some(inner_613) = &input.checksum_sha256 {
let formatted_614 = inner_613.as_str();
if !formatted_614.is_empty() {
let header_value = formatted_614;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha256",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-checksum-sha256", header_value);
}
}
if let Some(inner_615) = &input.sse_customer_algorithm {
let formatted_616 = inner_615.as_str();
if !formatted_616.is_empty() {
let header_value = formatted_616;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_617) = &input.sse_customer_key {
let formatted_618 = inner_617.as_str();
if !formatted_618.is_empty() {
let header_value = formatted_618;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_619) = &input.sse_customer_key_md5 {
let formatted_620 = inner_619.as_str();
if !formatted_620.is_empty() {
let header_value = formatted_620;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_621) = &input.request_payer {
let formatted_622 = inner_621.as_str();
if !formatted_622.is_empty() {
let header_value = formatted_622;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_623) = &input.expected_bucket_owner {
let formatted_624 = inner_623.as_str();
if !formatted_624.is_empty() {
let header_value = formatted_624;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_upload_part_copy(
input: &crate::input::UploadPartCopyInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_625) = &input.copy_source {
let formatted_626 = inner_625.as_str();
if !formatted_626.is_empty() {
let header_value = formatted_626;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source", header_value);
}
}
if let Some(inner_627) = &input.copy_source_if_match {
let formatted_628 = inner_627.as_str();
if !formatted_628.is_empty() {
let header_value = formatted_628;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-match", header_value);
}
}
if let Some(inner_629) = &input.copy_source_if_modified_since {
let formatted_630 = inner_629.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_630.is_empty() {
let header_value = formatted_630;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_modified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-modified-since", header_value);
}
}
if let Some(inner_631) = &input.copy_source_if_none_match {
let formatted_632 = inner_631.as_str();
if !formatted_632.is_empty() {
let header_value = formatted_632;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_none_match",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-none-match", header_value);
}
}
if let Some(inner_633) = &input.copy_source_if_unmodified_since {
let formatted_634 = inner_633.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_634.is_empty() {
let header_value = formatted_634;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_if_unmodified_since",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-if-unmodified-since", header_value);
}
}
if let Some(inner_635) = &input.copy_source_range {
let formatted_636 = inner_635.as_str();
if !formatted_636.is_empty() {
let header_value = formatted_636;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_range",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-copy-source-range", header_value);
}
}
if let Some(inner_637) = &input.sse_customer_algorithm {
let formatted_638 = inner_637.as_str();
if !formatted_638.is_empty() {
let header_value = formatted_638;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_639) = &input.sse_customer_key {
let formatted_640 = inner_639.as_str();
if !formatted_640.is_empty() {
let header_value = formatted_640;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
}
}
if let Some(inner_641) = &input.sse_customer_key_md5 {
let formatted_642 = inner_641.as_str();
if !formatted_642.is_empty() {
let header_value = formatted_642;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_643) = &input.copy_source_sse_customer_algorithm {
let formatted_644 = inner_643.as_str();
if !formatted_644.is_empty() {
let header_value = formatted_644;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-copy-source-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_645) = &input.copy_source_sse_customer_key {
let formatted_646 = inner_645.as_str();
if !formatted_646.is_empty() {
let header_value = formatted_646;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_sse_customer_key",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header(
"x-amz-copy-source-server-side-encryption-customer-key",
header_value,
);
}
}
if let Some(inner_647) = &input.copy_source_sse_customer_key_md5 {
let formatted_648 = inner_647.as_str();
if !formatted_648.is_empty() {
let header_value = formatted_648;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"copy_source_sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-copy-source-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_649) = &input.request_payer {
let formatted_650 = inner_649.as_str();
if !formatted_650.is_empty() {
let header_value = formatted_650;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_payer",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-payer", header_value);
}
}
if let Some(inner_651) = &input.expected_bucket_owner {
let formatted_652 = inner_651.as_str();
if !formatted_652.is_empty() {
let header_value = formatted_652;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-expected-bucket-owner", header_value);
}
}
if let Some(inner_653) = &input.expected_source_bucket_owner {
let formatted_654 = inner_653.as_str();
if !formatted_654.is_empty() {
let header_value = formatted_654;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expected_source_bucket_owner",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
}
}
Ok(builder)
}
pub fn add_headers_write_get_object_response(
input: &crate::input::WriteGetObjectResponseInput,
mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
if let Some(inner_655) = &input.request_route {
let formatted_656 = inner_655.as_str();
if !formatted_656.is_empty() {
let header_value = formatted_656;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_route",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-route", header_value);
}
}
if let Some(inner_657) = &input.request_token {
let formatted_658 = inner_657.as_str();
if !formatted_658.is_empty() {
let header_value = formatted_658;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_token",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-request-token", header_value);
}
}
if input.status_code != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.status_code);
let formatted_659 = encoder.encode();
if !formatted_659.is_empty() {
let header_value = formatted_659;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"status_code",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-status", header_value);
}
}
if let Some(inner_660) = &input.error_code {
let formatted_661 = inner_660.as_str();
if !formatted_661.is_empty() {
let header_value = formatted_661;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"error_code",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-error-code", header_value);
}
}
if let Some(inner_662) = &input.error_message {
let formatted_663 = inner_662.as_str();
if !formatted_663.is_empty() {
let header_value = formatted_663;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"error_message",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-error-message", header_value);
}
}
if let Some(inner_664) = &input.accept_ranges {
let formatted_665 = inner_664.as_str();
if !formatted_665.is_empty() {
let header_value = formatted_665;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"accept_ranges",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-accept-ranges", header_value);
}
}
if let Some(inner_666) = &input.cache_control {
let formatted_667 = inner_666.as_str();
if !formatted_667.is_empty() {
let header_value = formatted_667;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"cache_control",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Cache-Control", header_value);
}
}
if let Some(inner_668) = &input.content_disposition {
let formatted_669 = inner_668.as_str();
if !formatted_669.is_empty() {
let header_value = formatted_669;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_disposition",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Content-Disposition", header_value);
}
}
if let Some(inner_670) = &input.content_encoding {
let formatted_671 = inner_670.as_str();
if !formatted_671.is_empty() {
let header_value = formatted_671;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_encoding",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Content-Encoding", header_value);
}
}
if let Some(inner_672) = &input.content_language {
let formatted_673 = inner_672.as_str();
if !formatted_673.is_empty() {
let header_value = formatted_673;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_language",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Content-Language", header_value);
}
}
if input.content_length != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.content_length);
let formatted_674 = encoder.encode();
if !formatted_674.is_empty() {
let header_value = formatted_674;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_length",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("Content-Length", header_value);
}
}
if let Some(inner_675) = &input.content_range {
let formatted_676 = inner_675.as_str();
if !formatted_676.is_empty() {
let header_value = formatted_676;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_range",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Content-Range", header_value);
}
}
if let Some(inner_677) = &input.content_type {
let formatted_678 = inner_677.as_str();
if !formatted_678.is_empty() {
let header_value = formatted_678;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"content_type",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Content-Type", header_value);
}
}
if let Some(inner_679) = &input.checksum_crc32 {
let formatted_680 = inner_679.as_str();
if !formatted_680.is_empty() {
let header_value = formatted_680;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc32", header_value);
}
}
if let Some(inner_681) = &input.checksum_crc32_c {
let formatted_682 = inner_681.as_str();
if !formatted_682.is_empty() {
let header_value = formatted_682;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_crc32_c",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc32c", header_value);
}
}
if let Some(inner_683) = &input.checksum_sha1 {
let formatted_684 = inner_683.as_str();
if !formatted_684.is_empty() {
let header_value = formatted_684;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha1",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-checksum-sha1", header_value);
}
}
if let Some(inner_685) = &input.checksum_sha256 {
let formatted_686 = inner_685.as_str();
if !formatted_686.is_empty() {
let header_value = formatted_686;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"checksum_sha256",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-checksum-sha256", header_value);
}
}
if input.delete_marker {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.delete_marker);
let formatted_687 = encoder.encode();
if !formatted_687.is_empty() {
let header_value = formatted_687;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"delete_marker",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-delete-marker", header_value);
}
}
if let Some(inner_688) = &input.e_tag {
let formatted_689 = inner_688.as_str();
if !formatted_689.is_empty() {
let header_value = formatted_689;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"e_tag",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-ETag", header_value);
}
}
if let Some(inner_690) = &input.expires {
let formatted_691 = inner_690.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_691.is_empty() {
let header_value = formatted_691;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expires",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Expires", header_value);
}
}
if let Some(inner_692) = &input.expiration {
let formatted_693 = inner_692.as_str();
if !formatted_693.is_empty() {
let header_value = formatted_693;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"expiration",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-expiration", header_value);
}
}
if let Some(inner_694) = &input.last_modified {
let formatted_695 = inner_694.fmt(aws_smithy_types::date_time::Format::HttpDate)?;
if !formatted_695.is_empty() {
let header_value = formatted_695;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"last_modified",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-Last-Modified", header_value);
}
}
if input.missing_meta != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.missing_meta);
let formatted_696 = encoder.encode();
if !formatted_696.is_empty() {
let header_value = formatted_696;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"missing_meta",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-missing-meta", header_value);
}
}
if let Some(inner_697) = &input.object_lock_mode {
let formatted_698 = inner_697.as_str();
if !formatted_698.is_empty() {
let header_value = formatted_698;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_mode",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-object-lock-mode", header_value);
}
}
if let Some(inner_699) = &input.object_lock_legal_hold_status {
let formatted_700 = inner_699.as_str();
if !formatted_700.is_empty() {
let header_value = formatted_700;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_legal_hold_status",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-fwd-header-x-amz-object-lock-legal-hold",
header_value,
);
}
}
if let Some(inner_701) = &input.object_lock_retain_until_date {
let formatted_702 = inner_701.fmt(aws_smithy_types::date_time::Format::DateTime)?;
if !formatted_702.is_empty() {
let header_value = formatted_702;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"object_lock_retain_until_date",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-fwd-header-x-amz-object-lock-retain-until-date",
header_value,
);
}
}
if input.parts_count != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.parts_count);
let formatted_703 = encoder.encode();
if !formatted_703.is_empty() {
let header_value = formatted_703;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"parts_count",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-mp-parts-count", header_value);
}
}
if let Some(inner_704) = &input.replication_status {
let formatted_705 = inner_704.as_str();
if !formatted_705.is_empty() {
let header_value = formatted_705;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"replication_status",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-replication-status", header_value);
}
}
if let Some(inner_706) = &input.request_charged {
let formatted_707 = inner_706.as_str();
if !formatted_707.is_empty() {
let header_value = formatted_707;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"request_charged",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-request-charged", header_value);
}
}
if let Some(inner_708) = &input.restore {
let formatted_709 = inner_708.as_str();
if !formatted_709.is_empty() {
let header_value = formatted_709;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"restore",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-restore", header_value);
}
}
if let Some(inner_710) = &input.server_side_encryption {
let formatted_711 = inner_710.as_str();
if !formatted_711.is_empty() {
let header_value = formatted_711;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"server_side_encryption",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-fwd-header-x-amz-server-side-encryption",
header_value,
);
}
}
if let Some(inner_712) = &input.sse_customer_algorithm {
let formatted_713 = inner_712.as_str();
if !formatted_713.is_empty() {
let header_value = formatted_713;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_algorithm",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm",
header_value,
);
}
}
if let Some(inner_714) = &input.ssekms_key_id {
let formatted_715 = inner_714.as_str();
if !formatted_715.is_empty() {
let header_value = formatted_715;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"ssekms_key_id",
format!(
"`{}` cannot be used as a header value: {}",
&"*** Sensitive Data Redacted ***", err
),
)
})?;
builder = builder.header(
"x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id",
header_value,
);
}
}
if let Some(inner_716) = &input.sse_customer_key_md5 {
let formatted_717 = inner_716.as_str();
if !formatted_717.is_empty() {
let header_value = formatted_717;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"sse_customer_key_md5",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-fwd-header-x-amz-server-side-encryption-customer-key-MD5",
header_value,
);
}
}
if let Some(inner_718) = &input.storage_class {
let formatted_719 = inner_718.as_str();
if !formatted_719.is_empty() {
let header_value = formatted_719;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"storage_class",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-storage-class", header_value);
}
}
if input.tag_count != 0 {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.tag_count);
let formatted_720 = encoder.encode();
if !formatted_720.is_empty() {
let header_value = formatted_720;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"tag_count",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-tagging-count", header_value);
}
}
if let Some(inner_721) = &input.version_id {
let formatted_722 = inner_721.as_str();
if !formatted_722.is_empty() {
let header_value = formatted_722;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"version_id",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header("x-amz-fwd-header-x-amz-version-id", header_value);
}
}
if input.bucket_key_enabled {
let mut encoder = aws_smithy_types::primitive::Encoder::from(input.bucket_key_enabled);
let formatted_723 = encoder.encode();
if !formatted_723.is_empty() {
let header_value = formatted_723;
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"bucket_key_enabled",
format!(
"`{}` cannot be used as a header value: {}",
&header_value, err
),
)
})?;
builder = builder.header(
"x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled",
header_value,
);
}
}
if let Some(inner_724) = &input.metadata {
{
for (k, v) in inner_724 {
use std::str::FromStr;
let header_name =
http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k))
.map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{k}` cannot be used as a header name: {err}"),
)
})?;
let header_value = v.as_str();
let header_value =
http::header::HeaderValue::try_from(&*header_value).map_err(|err| {
aws_smithy_http::operation::error::BuildError::invalid_field(
"metadata",
format!("`{}` cannot be used as a header value: {}", v, err),
)
})?;
builder = builder.header(header_name, header_value);
}
}
}
Ok(builder)
}
pub(crate) fn deser_header_abort_multipart_upload_abort_multipart_upload_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_725 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_725.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_725.len()
)))
} else {
let mut var_725 = var_725;
Ok(var_725.pop())
}
}
pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_expiration(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-expiration").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_726 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_726.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_726.len()
)))
} else {
let mut var_726 = var_726;
Ok(var_726.pop())
}
}
pub fn deser_payload_copy_object_copy_object_output_copy_object_result(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::CopyObjectResult>,
crate::error::CopyObjectError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_copy_object_output_copy_object_result(body).map_err(crate::error::CopyObjectError::unhandled)
}).transpose()
}
pub(crate) fn deser_header_copy_object_copy_object_output_copy_source_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-copy-source-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_expiration(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-expiration").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_sse_customer_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-algorithm")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_sse_customer_key_md5(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-key-MD5")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_ssekms_encryption_context(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-context")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_copy_object_copy_object_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_bucket_create_bucket_output_location(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Location").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_abort_date(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-abort-date").iter();
let var_727: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::HttpDate,
)?;
if var_727.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_727.len()
)))
} else {
let mut var_727 = var_727;
Ok(var_727.pop())
}
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_abort_rule_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-abort-rule-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_728 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_728.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_728.len()
)))
} else {
let mut var_728 = var_728;
Ok(var_728.pop())
}
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_checksum_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ChecksumAlgorithm>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-algorithm").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_sse_customer_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-algorithm")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_sse_customer_key_md5(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-key-MD5")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_ssekms_encryption_context(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-context")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_create_multipart_upload_create_multipart_upload_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_delete_object_delete_object_output_delete_marker(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-delete-marker").iter();
let var_729 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_729.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_729.len()
)))
} else {
let mut var_729 = var_729;
Ok(var_729.pop())
}
}
pub(crate) fn deser_header_delete_object_delete_object_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_delete_object_delete_object_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_delete_objects_delete_objects_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_delete_object_tagging_delete_object_tagging_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_get_bucket_analytics_configuration_get_bucket_analytics_configuration_output_analytics_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::AnalyticsConfiguration>,
crate::error::GetBucketAnalyticsConfigurationError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_analytics_configuration_output_analytics_configuration(body).map_err(crate::error::GetBucketAnalyticsConfigurationError::unhandled)
}).transpose()
}
pub fn deser_payload_get_bucket_encryption_get_bucket_encryption_output_server_side_encryption_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryptionConfiguration>,
crate::error::GetBucketEncryptionError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_encryption_output_server_side_encryption_configuration(body).map_err(crate::error::GetBucketEncryptionError::unhandled)
}).transpose()
}
pub fn deser_payload_get_bucket_intelligent_tiering_configuration_get_bucket_intelligent_tiering_configuration_output_intelligent_tiering_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::IntelligentTieringConfiguration>,
crate::error::GetBucketIntelligentTieringConfigurationError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_intelligent_tiering_configuration_output_intelligent_tiering_configuration(body).map_err(crate::error::GetBucketIntelligentTieringConfigurationError::unhandled)
}).transpose()
}
pub fn deser_payload_get_bucket_inventory_configuration_get_bucket_inventory_configuration_output_inventory_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::InventoryConfiguration>,
crate::error::GetBucketInventoryConfigurationError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_inventory_configuration_output_inventory_configuration(body).map_err(crate::error::GetBucketInventoryConfigurationError::unhandled)
}).transpose()
}
pub fn deser_payload_get_bucket_metrics_configuration_get_bucket_metrics_configuration_output_metrics_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::MetricsConfiguration>,
crate::error::GetBucketMetricsConfigurationError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_metrics_configuration_output_metrics_configuration(body).map_err(crate::error::GetBucketMetricsConfigurationError::unhandled)
}).transpose()
}
pub fn deser_payload_get_bucket_ownership_controls_get_bucket_ownership_controls_output_ownership_controls(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::OwnershipControls>,
crate::error::GetBucketOwnershipControlsError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_ownership_controls_output_ownership_controls(body).map_err(crate::error::GetBucketOwnershipControlsError::unhandled)
}).transpose()
}
pub fn deser_payload_get_bucket_policy_get_bucket_policy_output_policy(
body: &[u8],
) -> std::result::Result<std::option::Option<std::string::String>, crate::error::GetBucketPolicyError>
{
(!body.is_empty())
.then(|| {
let body_str =
std::str::from_utf8(body).map_err(crate::error::GetBucketPolicyError::unhandled)?;
Ok(body_str.to_string())
})
.transpose()
}
pub fn deser_payload_get_bucket_policy_status_get_bucket_policy_status_output_policy_status(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::PolicyStatus>,
crate::error::GetBucketPolicyStatusError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_policy_status_output_policy_status(body).map_err(crate::error::GetBucketPolicyStatusError::unhandled)
}).transpose()
}
pub fn deser_payload_get_bucket_replication_get_bucket_replication_output_replication_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::ReplicationConfiguration>,
crate::error::GetBucketReplicationError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_bucket_replication_output_replication_configuration(body).map_err(crate::error::GetBucketReplicationError::unhandled)
}).transpose()
}
pub(crate) fn deser_header_get_object_get_object_output_accept_ranges(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("accept-ranges").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_get_object_get_object_output_body(
body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<aws_smithy_http::byte_stream::ByteStream, crate::error::GetObjectError> {
let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
Ok(aws_smithy_http::byte_stream::ByteStream::new(body))
}
pub(crate) fn deser_header_get_object_get_object_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_730 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_730.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_730.len()
)))
} else {
let mut var_730 = var_730;
Ok(var_730.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_cache_control(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Cache-Control").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_checksum_crc32(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_checksum_crc32_c(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32c").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_checksum_sha1(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha1").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_checksum_sha256(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha256").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_content_disposition(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Disposition").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_content_encoding(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Encoding").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_content_language(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Language").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_content_length(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i64>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("Content-Length").iter();
let var_731 = aws_smithy_http::header::read_many_primitive::<i64>(headers)?;
if var_731.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_731.len()
)))
} else {
let mut var_731 = var_731;
Ok(var_731.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_content_range(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Range").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_content_type(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Type").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_delete_marker(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-delete-marker").iter();
let var_732 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_732.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_732.len()
)))
} else {
let mut var_732 = var_732;
Ok(var_732.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_e_tag(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("ETag").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_expiration(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-expiration").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_expires(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Expires").iter();
let var_733: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::HttpDate,
)?;
if var_733.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_733.len()
)))
} else {
let mut var_733 = var_733;
Ok(var_733.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_last_modified(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Last-Modified").iter();
let var_734: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::HttpDate,
)?;
if var_734.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_734.len()
)))
} else {
let mut var_734 = var_734;
Ok(var_734.pop())
}
}
pub(crate) fn deser_prefix_header_get_object_get_object_output_metadata(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
aws_smithy_http::header::ParseError,
> {
let headers = aws_smithy_http::header::headers_for_prefix(header_map, "x-amz-meta-");
let out: std::result::Result<_, _> = headers.map(|(key, header_name)| {
let values = header_map.get_all(header_name);
crate::http_serde::deser_prefix_header_get_object_get_object_output_metadata_inner(values.iter()).map(|v| (key.to_string(), v.expect(
"we have checked there is at least one value for this header name; please file a bug report under https://github.com/awslabs/smithy-rs/issues"
)))
}).collect();
out.map(Some)
}
pub(crate) fn deser_header_get_object_get_object_output_missing_meta(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-missing-meta").iter();
let var_735 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_735.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_735.len()
)))
} else {
let mut var_735 = var_735;
Ok(var_735.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_object_lock_legal_hold_status(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ObjectLockLegalHoldStatus>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-object-lock-legal-hold").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_object_lock_mode(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ObjectLockMode>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-object-lock-mode").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_object_lock_retain_until_date(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-object-lock-retain-until-date")
.iter();
let var_736: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::DateTime,
)?;
if var_736.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_736.len()
)))
} else {
let mut var_736 = var_736;
Ok(var_736.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_parts_count(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-mp-parts-count").iter();
let var_737 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_737.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_737.len()
)))
} else {
let mut var_737 = var_737;
Ok(var_737.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_replication_status(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ReplicationStatus>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-replication-status").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_restore(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-restore").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_sse_customer_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-algorithm")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_sse_customer_key_md5(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-key-MD5")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_storage_class(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::StorageClass>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-storage-class").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_tag_count(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-tagging-count").iter();
let var_738 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_738.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_738.len()
)))
} else {
let mut var_738 = var_738;
Ok(var_738.pop())
}
}
pub(crate) fn deser_header_get_object_get_object_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_get_object_output_website_redirect_location(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-website-redirect-location").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_acl_get_object_acl_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_attributes_get_object_attributes_output_delete_marker(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-delete-marker").iter();
let var_739 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_739.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_739.len()
)))
} else {
let mut var_739 = var_739;
Ok(var_739.pop())
}
}
pub(crate) fn deser_header_get_object_attributes_get_object_attributes_output_last_modified(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Last-Modified").iter();
let var_740: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::HttpDate,
)?;
if var_740.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_740.len()
)))
} else {
let mut var_740 = var_740;
Ok(var_740.pop())
}
}
pub(crate) fn deser_header_get_object_attributes_get_object_attributes_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_get_object_attributes_get_object_attributes_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_get_object_legal_hold_get_object_legal_hold_output_legal_hold(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::ObjectLockLegalHold>,
crate::error::GetObjectLegalHoldError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_object_legal_hold_output_legal_hold(body).map_err(crate::error::GetObjectLegalHoldError::unhandled)
}).transpose()
}
pub fn deser_payload_get_object_lock_configuration_get_object_lock_configuration_output_object_lock_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::ObjectLockConfiguration>,
crate::error::GetObjectLockConfigurationError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_object_lock_configuration_output_object_lock_configuration(body).map_err(crate::error::GetObjectLockConfigurationError::unhandled)
}).transpose()
}
pub fn deser_payload_get_object_retention_get_object_retention_output_retention(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::ObjectLockRetention>,
crate::error::GetObjectRetentionError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_object_retention_output_retention(body).map_err(crate::error::GetObjectRetentionError::unhandled)
}).transpose()
}
pub(crate) fn deser_header_get_object_tagging_get_object_tagging_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_get_object_torrent_get_object_torrent_output_body(
body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<
aws_smithy_http::byte_stream::ByteStream,
crate::error::GetObjectTorrentError,
> {
let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
Ok(aws_smithy_http::byte_stream::ByteStream::new(body))
}
pub(crate) fn deser_header_get_object_torrent_get_object_torrent_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_get_public_access_block_get_public_access_block_output_public_access_block_configuration(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::PublicAccessBlockConfiguration>,
crate::error::GetPublicAccessBlockError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_get_public_access_block_output_public_access_block_configuration(body).map_err(crate::error::GetPublicAccessBlockError::unhandled)
}).transpose()
}
pub(crate) fn deser_header_head_object_head_object_output_accept_ranges(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("accept-ranges").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_archive_status(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ArchiveStatus>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-archive-status").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_741 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_741.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_741.len()
)))
} else {
let mut var_741 = var_741;
Ok(var_741.pop())
}
}
pub(crate) fn deser_header_head_object_head_object_output_cache_control(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Cache-Control").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_checksum_crc32(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_checksum_crc32_c(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32c").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_checksum_sha1(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha1").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_checksum_sha256(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha256").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_content_disposition(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Disposition").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_content_encoding(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Encoding").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_content_language(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Language").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_content_length(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i64>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("Content-Length").iter();
let var_742 = aws_smithy_http::header::read_many_primitive::<i64>(headers)?;
if var_742.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_742.len()
)))
} else {
let mut var_742 = var_742;
Ok(var_742.pop())
}
}
pub(crate) fn deser_header_head_object_head_object_output_content_type(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Content-Type").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_delete_marker(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-delete-marker").iter();
let var_743 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_743.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_743.len()
)))
} else {
let mut var_743 = var_743;
Ok(var_743.pop())
}
}
pub(crate) fn deser_header_head_object_head_object_output_e_tag(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("ETag").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_expiration(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-expiration").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_expires(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Expires").iter();
let var_744: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::HttpDate,
)?;
if var_744.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_744.len()
)))
} else {
let mut var_744 = var_744;
Ok(var_744.pop())
}
}
pub(crate) fn deser_header_head_object_head_object_output_last_modified(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("Last-Modified").iter();
let var_745: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::HttpDate,
)?;
if var_745.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_745.len()
)))
} else {
let mut var_745 = var_745;
Ok(var_745.pop())
}
}
pub(crate) fn deser_prefix_header_head_object_head_object_output_metadata(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
aws_smithy_http::header::ParseError,
> {
let headers = aws_smithy_http::header::headers_for_prefix(header_map, "x-amz-meta-");
let out: std::result::Result<_, _> = headers.map(|(key, header_name)| {
let values = header_map.get_all(header_name);
crate::http_serde::deser_prefix_header_head_object_head_object_output_metadata_inner(values.iter()).map(|v| (key.to_string(), v.expect(
"we have checked there is at least one value for this header name; please file a bug report under https://github.com/awslabs/smithy-rs/issues"
)))
}).collect();
out.map(Some)
}
pub(crate) fn deser_header_head_object_head_object_output_missing_meta(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-missing-meta").iter();
let var_746 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_746.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_746.len()
)))
} else {
let mut var_746 = var_746;
Ok(var_746.pop())
}
}
pub(crate) fn deser_header_head_object_head_object_output_object_lock_legal_hold_status(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ObjectLockLegalHoldStatus>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-object-lock-legal-hold").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_object_lock_mode(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ObjectLockMode>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-object-lock-mode").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_object_lock_retain_until_date(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-object-lock-retain-until-date")
.iter();
let var_747: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::DateTime,
)?;
if var_747.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_747.len()
)))
} else {
let mut var_747 = var_747;
Ok(var_747.pop())
}
}
pub(crate) fn deser_header_head_object_head_object_output_parts_count(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
let headers = header_map.get_all("x-amz-mp-parts-count").iter();
let var_748 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
if var_748.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_748.len()
)))
} else {
let mut var_748 = var_748;
Ok(var_748.pop())
}
}
pub(crate) fn deser_header_head_object_head_object_output_replication_status(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ReplicationStatus>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-replication-status").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_restore(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-restore").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_sse_customer_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-algorithm")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_sse_customer_key_md5(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-key-MD5")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_storage_class(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::StorageClass>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-storage-class").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_head_object_head_object_output_website_redirect_location(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-website-redirect-location").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_list_parts_list_parts_output_abort_date(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<aws_smithy_types::DateTime>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-abort-date").iter();
let var_749: Vec<aws_smithy_types::DateTime> = aws_smithy_http::header::many_dates(
headers,
aws_smithy_types::date_time::Format::HttpDate,
)?;
if var_749.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_749.len()
)))
} else {
let mut var_749 = var_749;
Ok(var_749.pop())
}
}
pub(crate) fn deser_header_list_parts_list_parts_output_abort_rule_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-abort-rule-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_list_parts_list_parts_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_750 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_750.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_750.len()
)))
} else {
let mut var_750 = var_750;
Ok(var_750.pop())
}
}
pub(crate) fn deser_header_put_object_put_object_output_checksum_crc32(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_checksum_crc32_c(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32c").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_checksum_sha1(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha1").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_checksum_sha256(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha256").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_e_tag(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("ETag").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_expiration(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-expiration").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_sse_customer_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-algorithm")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_sse_customer_key_md5(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-key-MD5")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_ssekms_encryption_context(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-context")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_put_object_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_acl_put_object_acl_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_legal_hold_put_object_legal_hold_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_lock_configuration_put_object_lock_configuration_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_retention_put_object_retention_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_put_object_tagging_put_object_tagging_output_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_restore_object_restore_object_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_restore_object_restore_object_output_restore_output_path(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-restore-output-path").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_payload_select_object_content_select_object_content_output_payload(
body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<
aws_smithy_http::event_stream::Receiver<
crate::model::SelectObjectContentEventStream,
crate::error::SelectObjectContentEventStreamError,
>,
crate::error::SelectObjectContentError,
> {
let unmarshaller = crate::event_stream_serde::SelectObjectContentEventStreamUnmarshaller::new();
let body = std::mem::replace(body, aws_smithy_http::body::SdkBody::taken());
Ok(aws_smithy_http::event_stream::Receiver::new(
unmarshaller,
body,
))
}
pub(crate) fn deser_header_upload_part_upload_part_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_751 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_751.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_751.len()
)))
} else {
let mut var_751 = var_751;
Ok(var_751.pop())
}
}
pub(crate) fn deser_header_upload_part_upload_part_output_checksum_crc32(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_checksum_crc32_c(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-crc32c").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_checksum_sha1(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha1").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_checksum_sha256(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-checksum-sha256").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_e_tag(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("ETag").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_sse_customer_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-algorithm")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_sse_customer_key_md5(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-key-MD5")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_upload_part_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_copy_upload_part_copy_output_bucket_key_enabled(
header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<bool>, aws_smithy_http::header::ParseError> {
let headers = header_map
.get_all("x-amz-server-side-encryption-bucket-key-enabled")
.iter();
let var_752 = aws_smithy_http::header::read_many_primitive::<bool>(headers)?;
if var_752.len() > 1 {
Err(aws_smithy_http::header::ParseError::new(format!(
"expected one item but found {}",
var_752.len()
)))
} else {
let mut var_752 = var_752;
Ok(var_752.pop())
}
}
pub fn deser_payload_upload_part_copy_upload_part_copy_output_copy_part_result(
body: &[u8],
) -> std::result::Result<
std::option::Option<crate::model::CopyPartResult>,
crate::error::UploadPartCopyError,
> {
(!body.is_empty()).then(||{
crate::xml_deser::deser_member_com_amazonaws_s3_synthetic_upload_part_copy_output_copy_part_result(body).map_err(crate::error::UploadPartCopyError::unhandled)
}).transpose()
}
pub(crate) fn deser_header_upload_part_copy_upload_part_copy_output_copy_source_version_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-copy-source-version-id").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_copy_upload_part_copy_output_request_charged(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::RequestCharged>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-request-charged").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_copy_upload_part_copy_output_sse_customer_algorithm(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-algorithm")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_copy_upload_part_copy_output_sse_customer_key_md5(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-customer-key-MD5")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_copy_upload_part_copy_output_ssekms_key_id(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<std::string::String>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map
.get_all("x-amz-server-side-encryption-aws-kms-key-id")
.iter();
aws_smithy_http::header::one_or_none(headers)
}
pub(crate) fn deser_header_upload_part_copy_upload_part_copy_output_server_side_encryption(
header_map: &http::HeaderMap,
) -> std::result::Result<
std::option::Option<crate::model::ServerSideEncryption>,
aws_smithy_http::header::ParseError,
> {
let headers = header_map.get_all("x-amz-server-side-encryption").iter();
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_prefix_header_get_object_get_object_output_metadata_inner(
headers: http::header::ValueIter<http::HeaderValue>,
) -> std::result::Result<Option<std::string::String>, aws_smithy_http::header::ParseError> {
aws_smithy_http::header::one_or_none(headers)
}
pub fn deser_prefix_header_head_object_head_object_output_metadata_inner(
headers: http::header::ValueIter<http::HeaderValue>,
) -> std::result::Result<Option<std::string::String>, aws_smithy_http::header::ParseError> {
aws_smithy_http::header::one_or_none(headers)
}