expanded_response_macro.rs

struct StoreResult {
    saved: String,
}

#[allow(unused_variables, non_upper_case_globals)]
const __IMPL_RESPONSE_FOR_StoreResult: () = {
    extern crate tower_web as __tw;
    impl __tw::response::Response for StoreResult {
        type Buf = <Self::Body as __tw::util::BufStream>::Item;
        type Body = __tw::error::Map<__tw::codegen::bytes::Bytes>;
        fn into_http<S: __tw::response::Serializer>(
            self,
            context: &__tw::response::Context<S>,
        ) -> Result<__tw::codegen::http::Response<Self::Body>, __tw::Error> {
            struct Lift<'__a>(&'__a StoreResult);
            impl<'__a> __tw::codegen::serde::Serialize for Lift<'__a> {
                fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
                where
                    S: __tw::codegen::serde::Serializer,
                {
                    ShadowStoreResult::serialize(self.0, serializer)
                }
            }
            #[allow(unused_mut)]
            let mut serializer_context = context.serializer_context();
            let body: __tw::codegen::bytes::Bytes = context
                .serialize(&Lift(&self), &serializer_context)
                .map_err(|_| {
                    __tw::Error::from(
                        __tw::codegen::http::status::StatusCode::INTERNAL_SERVER_ERROR,
                    )
                })?;
            let body = __tw::error::Map::new(body);
            let mut response = __tw::codegen::http::Response::builder()
                .status("200")
                .body(body)
                .unwrap();
            response
                .headers_mut()
                .entry(__tw::codegen::http::header::CONTENT_TYPE)
                .unwrap()
                .or_insert_with(|| {
                    context.content_type_header().cloned().unwrap_or_else(|| {
                        __tw::codegen::http::header::HeaderValue::from_static(
                            "application/octet-stream",
                        )
                    })
                });
            Ok(response)
        }
    }
    #[serde(remote = "StoreResult")]
    struct ShadowStoreResult {
        saved: String,
    }
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _IMPL_SERIALIZE_FOR_ShadowStoreResult: () = {
        #[allow(unknown_lints)]
        #[allow(rust_2018_idioms)]
        extern crate serde as _serde;
        #[allow(unused_macros)]
        macro_rules! try {
            ($ __expr : expr) => {
                match $__expr {
                    _serde::export::Ok(__val) => __val,
                    _serde::export::Err(__err) => {
                        return _serde::export::Err(__err);
                    }
                }
            };
        }
        impl ShadowStoreResult {
            fn serialize<__S>(
                __self: &StoreResult,
                __serializer: __S,
            ) -> _serde::export::Result<__S::Ok, __S::Error>
            where
                __S: _serde::Serializer,
            {
                match _serde::export::None::<ShadowStoreResult> {
                    _serde::export::Some(ShadowStoreResult { saved: ref __v0 }) => {}
                    _ => {}
                }
                let mut __serde_state = match _serde::Serializer::serialize_struct(
                    __serializer,
                    "ShadowStoreResult",
                    false as usize + 1,
                ) {
                    _serde::export::Ok(__val) => __val,
                    _serde::export::Err(__err) => {
                        return _serde::export::Err(__err);
                    }
                };
                match _serde::ser::SerializeStruct::serialize_field(
                    &mut __serde_state,
                    "saved",
                    _serde::private::ser::constrain::<String>(&__self.saved),
                ) {
                    _serde::export::Ok(__val) => __val,
                    _serde::export::Err(__err) => {
                        return _serde::export::Err(__err);
                    }
                };
                _serde::ser::SerializeStruct::end(__serde_state)
            }
        }
    };
};