Struct Operation 

pub struct Operation { /* private fields */ }

A request the client has not sent yet. Generated service methods build one from a Route; crate::Client::request builds one for anything the model does not cover.

Implementations

impl Operation

pub fn id(&self) -> &str

The operation as the model names it, or METHOD /path for one built by hand.

pub fn method(&self) -> &Method

The HTTP method the operation is sent with.

pub fn path(&self) -> &str

The path the operation is sent to, parameters already filled in.

pub fn query(&mut self, name: &str, value: impl Display) -> &mut Operation

Adds a query parameter. The same name may be added more than once.

pub fn query_optional<T: Display>( &mut self, name: &str, value: Option<&T>, ) -> &mut Operation

Adds a query parameter when there is a value for it, and nothing otherwise.

pub fn json<T: Serialize + ?Sized>( &mut self, body: &T, ) -> Result<&mut Operation, Error>

A JSON body, which is what every modelled write sends.

pub fn form(&mut self, fields: &[(&str, &str)]) -> &mut Operation

A form-encoded body, as a browser would post it.

pub fn multipart(&mut self, content_type: String, body: Bytes) -> &mut Operation

A multipart body the caller assembled, boundary and all. The content type has to name that same boundary for HEY to read the parts.

pub fn body_bytes( &mut self, content_type: impl Into<String>, bytes: Bytes, ) -> &mut Operation

A body the caller encoded, for the representations the model does not describe.

pub fn info(&mut self, info: OperationInfo) -> &mut Operation

Replaces the whole of what the operation announces itself as to the client’s crate::observability::Hooks.

pub fn operation_name( &mut self, name: impl Into<Cow<'static, str>>, ) -> &mut Operation

Announces the operation as something other than the route it sends: HEY stops a time track by updating one, and a wrapper that does so says StopTimeTrack.

pub fn resource_type( &mut self, resource_type: impl Into<Cow<'static, str>>, ) -> &mut Operation

Names the kind of record the operation acts on, in snake_case: box_group.

pub fn resource_id(&mut self, resource_id: i64) -> &mut Operation

Names the record the operation acts on. Generated methods set this from the path parameter that names it.

pub fn idempotent(&mut self, idempotent: bool) -> &mut Operation

Marks the operation as safe to resend, or not, regardless of its HTTP method.

pub fn accept(&mut self, media_type: &'static str) -> &mut Operation

The representation to ask HEY for, sent as Accept.

pub fn without_json_suffix(&mut self) -> &mut Operation

Sends the path as it stands. A modelled route gets a .json suffix put back on the paths Smithy cannot spell it into; a path the caller wrote needs no such repair.

pub fn no_cache(&mut self) -> &mut Operation

Reads past the response cache for this send, so the answer is HEY’s own. A blob is read this way: the cache is for JSON documents.

pub fn capture_redirects(&mut self) -> &mut Operation

Treats a redirect as the answer rather than following it. HEY’s form-backed endpoints answer a 302 or 303 naming what they created, and that Location is the whole of what the request was for.

pub fn form_representation(&mut self) -> &mut Operation

Asks for the HTML representation a form-backed endpoint serves: no .json suffix, and no preference about what comes back.

pub fn quiet(&mut self) -> &mut Operation

Sends this without announcing an operation: no gate, no start, no end. For a request made inside another operation — the read-back a write needs to answer with the record it wrote — so the hooks hear about that operation once rather than twice.

The request hooks still fire, so every send the SDK makes is still reported. So is every layer the announced operation went through: a quiet send is inside its bulkhead permit and under its circuit breaker, not beside them.

Trait Implementations

impl Clone for Operation

fn clone(&self) -> Operation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Operation

An operation prints what it is and where it goes, not what it carries: the path without any query the caller wrote into it, the query’s names without their values, the body’s shape without its bytes. A {:?} is the kind of thing that lands in a log, and the values are the caller’s data.

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

Formats the value using the given formatter.