aws-sdk-glacier 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
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_1) = &input.archive_size {
        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(
                        "archive_size",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("x-amz-archive-size", header_value);
        }
    }
    if let Some(inner_3) = &input.checksum {
        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(
                        "checksum",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("x-amz-sha256-tree-hash", header_value);
        }
    }
    Ok(builder)
}

pub fn add_headers_get_job_output(
    input: &crate::input::GetJobOutputInput,
    mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
    if let Some(inner_5) = &input.range {
        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(
                        "range",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("Range", header_value);
        }
    }
    Ok(builder)
}

pub fn add_headers_initiate_multipart_upload(
    input: &crate::input::InitiateMultipartUploadInput,
    mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
    if let Some(inner_7) = &input.archive_description {
        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(
                        "archive_description",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("x-amz-archive-description", header_value);
        }
    }
    if let Some(inner_9) = &input.part_size {
        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(
                        "part_size",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("x-amz-part-size", header_value);
        }
    }
    Ok(builder)
}

pub fn add_headers_upload_archive(
    input: &crate::input::UploadArchiveInput,
    mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
    if let Some(inner_11) = &input.archive_description {
        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(
                        "archive_description",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("x-amz-archive-description", header_value);
        }
    }
    if let Some(inner_13) = &input.checksum {
        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(
                        "checksum",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("x-amz-sha256-tree-hash", header_value);
        }
    }
    Ok(builder)
}

pub fn add_headers_upload_multipart_part(
    input: &crate::input::UploadMultipartPartInput,
    mut builder: http::request::Builder,
) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::error::BuildError> {
    if let Some(inner_15) = &input.checksum {
        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(
                        "checksum",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("x-amz-sha256-tree-hash", header_value);
        }
    }
    if let Some(inner_17) = &input.range {
        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(
                        "range",
                        format!(
                            "`{}` cannot be used as a header value: {}",
                            &header_value, err
                        ),
                    )
                })?;
            builder = builder.header("Content-Range", header_value);
        }
    }
    Ok(builder)
}

pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_archive_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-archive-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_output_checksum(
    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-sha256-tree-hash").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_complete_multipart_upload_complete_multipart_upload_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_vault_create_vault_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_get_job_output_get_job_output_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_get_job_output_get_job_output_output_archive_description(
    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-archive-description").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub fn deser_payload_get_job_output_get_job_output_output_body(
    body: &mut aws_smithy_http::body::SdkBody,
) -> std::result::Result<aws_smithy_http::byte_stream::ByteStream, crate::error::GetJobOutputError>
{
    // replace the body with an empty body
    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_job_output_get_job_output_output_checksum(
    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-sha256-tree-hash").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_get_job_output_get_job_output_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_job_output_get_job_output_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 fn deser_payload_get_vault_access_policy_get_vault_access_policy_output_policy(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::VaultAccessPolicy>,
    crate::error::GetVaultAccessPolicyError,
> {
    (!body.is_empty())
        .then(|| {
            crate::json_deser::deser_structure_crate_model_vault_access_policy_payload(body)
                .map_err(crate::error::GetVaultAccessPolicyError::unhandled)
        })
        .transpose()
}

pub fn deser_payload_get_vault_notifications_get_vault_notifications_output_vault_notification_config(
    body: &[u8],
) -> std::result::Result<
    std::option::Option<crate::model::VaultNotificationConfig>,
    crate::error::GetVaultNotificationsError,
> {
    (!body.is_empty())
        .then(|| {
            crate::json_deser::deser_structure_crate_model_vault_notification_config_payload(body)
                .map_err(crate::error::GetVaultNotificationsError::unhandled)
        })
        .transpose()
}

pub(crate) fn deser_header_initiate_job_initiate_job_output_job_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-job-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_initiate_job_initiate_job_output_job_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-job-output-path").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_initiate_job_initiate_job_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_initiate_multipart_upload_initiate_multipart_upload_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_initiate_multipart_upload_initiate_multipart_upload_output_upload_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-multipart-upload-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_initiate_vault_lock_initiate_vault_lock_output_lock_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-lock-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_purchase_provisioned_capacity_purchase_provisioned_capacity_output_capacity_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-capacity-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_upload_archive_upload_archive_output_archive_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-archive-id").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_upload_archive_upload_archive_output_checksum(
    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-sha256-tree-hash").iter();
    aws_smithy_http::header::one_or_none(headers)
}

pub(crate) fn deser_header_upload_archive_upload_archive_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_upload_multipart_part_upload_multipart_part_output_checksum(
    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-sha256-tree-hash").iter();
    aws_smithy_http::header::one_or_none(headers)
}