Struct Operation 

pub struct Operation<Handler, Inputs = (), Args = (), Transform = ()> { /* private fields */ }

Carries a typed operation declaration as first-order data.

Implementations

impl<Handler> Operation<Handler>

pub fn new(handler: Handler) -> Self

Carries an operation before selecting its HTTP input and output roles.

impl<Handler, Inputs, Args, Transform> Operation<Handler, Inputs, Args, Transform>

pub fn declare<Method>( self, path: &str, ) -> Endpoint<Method, Handler, Inputs, Args, Transform>

Declares this operation at one path under one method selector, with no program around it.

A program that states many endpoints composes their routes rather than their types, so it needs each endpoint on its own. The named declarations below select one method each; this states the same thing for a method held as a type parameter.

impl<Handler, Inputs, Args, Transform> Operation<Handler, Inputs, Args, Transform>

where Inputs: WithAlg, Args: WithAlg,

pub fn with<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Direct<Input>, Input>

Records an argument supplied directly in the interpreter’s input product.

pub fn path<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Path<Input>, Input>

Records a path extractor whose value becomes the next handler argument.

pub fn query<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Query<Input>, Input>

where Input: NamedValuesAlg,

Records a query extractor whose value becomes the next handler argument.

pub fn body<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Body<Input>, Input>

Records a request-body extractor whose value becomes the next handler argument.

pub fn form<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Form<Input>, Input>

Records a form-encoded request-body extractor whose value becomes the next handler argument.

pub fn raw_body<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, RawBody<Input>, Input>

Records the request body as it arrived, becoming the next handler argument.

pub fn in_header<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Header<Input>, Input>

where Input: NamedValuesAlg,

Records an incoming header extractor whose value becomes the next handler argument.

pub fn cookie<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Cookie<Input>, Input>

where Input: NamedValuesAlg,

Records a cookie extractor whose value becomes the next handler argument.

pub fn multipart<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Multipart<Input>, Input>

Records a body arriving as parts, read into the next handler argument.

pub fn auth<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Auth<Input>, Input>

where Input: NamedValuesAlg,

Records an authentication extractor whose value becomes the next handler argument.

pub fn context<Input>( self, ) -> WithInput<Handler, Inputs, Args, Transform, Context<Input>, Input>

Records an endpoint-context extractor whose value becomes the next handler argument.

pub fn out<Kind>( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<Kind>>::Closed>

where Transform: CloseAlg<Kind>,

Closes the declaration with the output kind Kind, inside every wrapper already stated.

The kind is interpreted only after the handler result type is known at the compilation boundary, so a downstream kind closes a declaration exactly as a built-in one does.

pub fn status<const CODE: u16>( self, ) -> Operation<Handler, Inputs, Args, OpenWith<Transform, StatusOut<(), CODE>>>

where Transform: OpenAlg,

Answers with CODE, around what the rest of the declaration states.

pub fn out_header<Name>( self, ) -> Operation<Handler, Inputs, Args, OpenWith<Transform, HeaderOut<(), Name>>>

where Transform: OpenAlg,

Answers with the handler’s header value, around what the rest of the declaration states.

The handler answers with the value and then with what the rest states: (value, rest).

pub fn out_headers<Headers>( self, ) -> Operation<Handler, Inputs, Args, OpenWith<Transform, HeadersOut<(), Headers>>>

where Transform: OpenAlg, Headers: NamedValuesAlg,

Answers with the headers the handler’s named product states, around what the rest states.

The output twin of Operation::in_header: each member of Headers is one header, named by its member name, and the handler answers with (headers, rest).

pub fn result( self, ) -> Operation<Handler, Inputs, Args, OpenWith<Transform, ResultOut<()>>>

where Transform: OpenAlg,

Answers with what the rest of the declaration states when the handler succeeded, and with what its failure means otherwise.

impl<Handler, Inputs, Args, Transform> Operation<Handler, Inputs, Args, Transform>

where Inputs: WithAlg, Args: WithAlg,

pub fn json( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<JsonOut>>::Closed>

where Transform: CloseAlg<JsonOut>,

Closes the declaration with JSON output meaning.

pub fn file( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<FileOut>>::Closed>

where Transform: CloseAlg<FileOut>,

Closes the declaration with streamed-file output meaning.

pub fn text( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<TextOut>>::Closed>

where Transform: CloseAlg<TextOut>,

Closes the declaration with plain-text output meaning.

pub fn html( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<HtmlOut>>::Closed>

where Transform: CloseAlg<HtmlOut>,

Closes the declaration with HTML output meaning.

pub fn bytes( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<BytesOut>>::Closed>

where Transform: CloseAlg<BytesOut>,

Closes the declaration with raw-byte output meaning.

pub fn empty( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<EmptyOut>>::Closed>

where Transform: CloseAlg<EmptyOut>,

Closes the declaration with empty output meaning.

pub fn redirect( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<RedirectOut>>::Closed>

where Transform: CloseAlg<RedirectOut>,

Closes the declaration with redirect output meaning.

pub fn stream( self, ) -> Operation<Handler, Inputs, Args, <Transform as CloseAlg<StreamOut>>::Closed>

where Transform: CloseAlg<StreamOut>,

Closes the declaration with streamed output meaning.

impl<Handler, Inputs, Args, Transform> Operation<Handler, Inputs, Args, Transform>

where Inputs: WithAlg, Args: WithAlg,

pub fn get(self, path: &str) -> Endpoint<Get, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under GET.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn post( self, path: &str, ) -> Endpoint<Post, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under POST.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn put(self, path: &str) -> Endpoint<Put, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under PUT.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn patch( self, path: &str, ) -> Endpoint<Patch, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under PATCH.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn delete( self, path: &str, ) -> Endpoint<Delete, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under DELETE.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn head( self, path: &str, ) -> Endpoint<Head, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under HEAD.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn options( self, path: &str, ) -> Endpoint<Options, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under OPTIONS.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn trace( self, path: &str, ) -> Endpoint<Trace, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under TRACE.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

pub fn connect( self, path: &str, ) -> Endpoint<Connect, Handler, Inputs, Args, Transform>

Declares this operation at an exact path, answered under CONNECT.

This is the same thing the declaration of that name on RouteProgram states, for one endpoint standing on its own rather than one inside a composition.

Trait Implementations

impl<Handler: Debug, Inputs: Debug, Args: Debug, Transform: Debug> Debug for Operation<Handler, Inputs, Args, Transform>

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

Formats the value using the given formatter.