fn serialize_input()

in crates/amzn-codewhisperer-client/src/operation/list_code_analysis_findings.rs [182:267]

• 86 lines of code
• 5 McCabe index (conditional complexity)

    fn serialize_input(
        &self,
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
    ) -> ::std::result::Result<
        ::aws_smithy_runtime_api::client::orchestrator::HttpRequest,
        ::aws_smithy_runtime_api::box_error::BoxError,
    > {
        let input = input
            .downcast::<crate::operation::list_code_analysis_findings::ListCodeAnalysisFindingsInput>()
            .expect("correct type");
        let _header_serialization_settings = _cfg
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
            .cloned()
            .unwrap_or_default();
        let mut request_builder = {
            fn uri_base(
                _input: &crate::operation::list_code_analysis_findings::ListCodeAnalysisFindingsInput,
                output: &mut ::std::string::String,
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                use ::std::fmt::Write as _;
                ::std::write!(output, "/").expect("formatting should succeed");
                ::std::result::Result::Ok(())
            }
            fn uri_query(
                _input: &crate::operation::list_code_analysis_findings::ListCodeAnalysisFindingsInput,
                mut output: &mut ::std::string::String,
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                let mut query = ::aws_smithy_http::query::Writer::new(output);
                if let ::std::option::Option::Some(inner_1) = &_input.next_token {
                    {
                        query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_1));
                    }
                }
                let inner_2 = &_input.code_analysis_findings_schema;
                let inner_2 = inner_2.as_ref().ok_or_else(|| {
                    ::aws_smithy_types::error::operation::BuildError::missing_field(
                        "code_analysis_findings_schema",
                        "cannot be empty or unset",
                    )
                })?;
                query.push_kv("schema", &::aws_smithy_http::query::fmt_string(inner_2));
                if let ::std::option::Option::Some(inner_3) = &_input.profile_arn {
                    {
                        query.push_kv("profileArn", &::aws_smithy_http::query::fmt_string(inner_3));
                    }
                }
                ::std::result::Result::Ok(())
            }
            #[allow(clippy::unnecessary_wraps)]
            fn update_http_builder(
                input: &crate::operation::list_code_analysis_findings::ListCodeAnalysisFindingsInput,
                builder: ::http::request::Builder,
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError>
            {
                let mut uri = ::std::string::String::new();
                uri_base(input, &mut uri)?;
                uri_query(input, &mut uri)?;
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
            }
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
            builder = _header_serialization_settings.set_default_header(
                builder,
                ::http::header::CONTENT_TYPE,
                "application/x-amz-json-1.0",
            );
            builder = _header_serialization_settings.set_default_header(
                builder,
                ::http::header::HeaderName::from_static("x-amz-target"),
                "AmazonCodeWhispererService.ListCodeAnalysisFindings",
            );
            builder
        };
        let body = ::aws_smithy_types::body::SdkBody::from(
            crate::protocol_serde::shape_list_code_analysis_findings::ser_list_code_analysis_findings_input(&input)?,
        );
        if let Some(content_length) = body.content_length() {
            let content_length = content_length.to_string();
            request_builder = _header_serialization_settings.set_default_header(
                request_builder,
                ::http::header::CONTENT_LENGTH,
                &content_length,
            );
        }
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
    }