Struct HttpBindingProtocol 

pub struct HttpBindingProtocol<C> { /* private fields */ }

An HTTP protocol for REST-style APIs that use HTTP bindings.

This protocol splits input members between HTTP locations (headers, query strings, URI labels) and the payload based on HTTP binding traits (@httpHeader, @httpQuery, @httpLabel, @httpPayload, etc.). Non-bound members are serialized into the body using the provided codec.

Type parameters

• C — the payload codec (e.g., JsonCodec, XmlCodec)

Implementations

impl<C: Codec> HttpBindingProtocol<C>

pub fn new( protocol_id: ShapeId<'static>, codec: C, content_type: &'static str, ) -> Self

Creates a new HTTP binding protocol.

pub fn codec(&self) -> &C

Returns a reference to the body codec. Used by wrapper protocols (e.g. AwsRestXmlProtocol) that need to construct and pre-configure a body serializer before delegating to serialize_request_with_body.

pub fn content_type(&self) -> &'static str

Returns the Content-Type string this protocol stamps onto the outgoing request. Used by wrapper protocols that rebuild the inner HttpBindingProtocol when reconfiguring the codec.

pub fn with_codec(self, codec: C) -> Self

Replaces the body codec, returning a new protocol instance with all other fields preserved. Used by wrapper protocols (e.g. AWS REST JSON) that need to swap in a reconfigured codec.

pub fn serialize_request_with_body( &self, body: <C as Codec>::Serializer, input: &dyn SerializableStruct, input_schema: &Schema<'_>, endpoint: &str, cfg: &ConfigBag, ) -> Result<Request, SerdeError>

Body-providable variant of serialize_request. The caller supplies an already-constructed body serializer, allowing codec-specific pre-configuration (e.g. setting one-shot state on the body codec before binding-driven serialization begins). The default serialize_request implementation calls this with a fresh serializer from the codec.

This is the extension point used by AwsRestXmlProtocol to inject the member-level @xmlName for an @httpPayload struct member into the body codec — a value the codec couldn’t otherwise see because codegen passes the target shape’s SCHEMA for that member, which carries the target’s @xmlName but not the member’s.

Trait Implementations

impl<C> ClientProtocolInner for HttpBindingProtocol<C>

where C: Codec + Send + Sync + Debug + 'static, for<'a> C::Deserializer<'a>: ShapeDeserializer,

fn deserialize_response<'a>( &self, response: &'a Response, output_schema: &Schema<'_>, cfg: &'a ConfigBag, ) -> Result<Box<dyn ShapeDeserializer + 'a>, SerdeError>

Returns a deserializer that reads the whole response: @httpHeader, @httpPrefixHeaders, @httpResponseCode, and @httpPayload members from the HTTP message, everything else from the body codec.

This is what makes binding applicability a property of the protocol selected at runtime rather than of the protocol the client was generated from. An output with no response-bound members still gets the bare codec deserializer.

On the body

For a non-streaming response the orchestrator has already loaded the body into an in-memory Once(..), so bytes() returns the payload. For a streaming response — whose output has a @streaming @httpPayload blob or event-stream member — the body is left as a BoxBody, possibly further wrapped by an interceptor such as ResponseChecksumInterceptor, and bytes() returns None.

The codec is therefore built over unwrap_or(&[]), which it reads as “no body members”, while the true Option is what the wrapper uses to tell an unbuffered body apart from an empty one. A @streaming payload is skipped outright, so the live body is never consumed here.

fn deserialize_error_response<'a>( &self, response: &'a Response, cfg: &'a ConfigBag, ) -> Result<Box<dyn ShapeDeserializer + 'a>, SerdeError>

Returns a deserializer for a modeled error response.

Overridden rather than left to the default forwarding, which would hand the error to deserialize_response and therefore to a success-mode wrapper. A success-mode wrapper gives an empty body to the codec, but services do send empty error bodies — an S3 HEAD is the standard case — and those responses must still populate their header and status members. The error helper tolerates that while reading the same bindings.

A protocol with an error envelope (restXml, awsQuery) overrides this again to position the body inside the envelope before wrapping.

type Request = Request

The protocol’s request message type (e.g., http::Request).

type Response = Response

The protocol’s response message type (e.g., http::Response).

fn protocol_id(&self) -> &ShapeId<'static>

Returns the Smithy shape ID of this protocol.

fn serialize_request( &self, input: &dyn SerializableStruct, input_schema: &Schema<'_>, endpoint: &str, cfg: &ConfigBag, ) -> Result<Request, SerdeError>

Serializes an operation input into a request message.

fn payload_codec(&self) -> Option<&dyn DynCodec>

Returns the codec used for payload (de)serialization, if any.

fn update_endpoint( &self, request: &mut Request, endpoint: &Endpoint, cfg: &ConfigBag, ) -> Result<(), SerdeError>

Updates a previously serialized request with a resolved endpoint.

fn parse_error_metadata( &self, response: &Self::Response, cfg: &ConfigBag, ) -> Result<ErrorMetadataBuilder, SerdeError>

Extracts canonical error metadata (code, message, request id) from a response’s wire envelope.

fn event_stream_media_type(&self) -> Option<&str>

The media type used to label a structured event-stream payload, if this protocol supports event streams — for example application/cbor or application/json.

fn parse_event_stream_error_metadata( &self, payload: &[u8], ) -> Result<ErrorMetadataBuilder, SerdeError>

Extracts canonical error metadata from the payload of an event-stream exception frame.

impl<C: Debug> Debug for HttpBindingProtocol<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.