Struct tower_web_protobuf::Proto

pub struct Proto<M: MessagePlus>(pub M);

A wrapper struct for a protobuf message type.

This has to exist because impl<T> Trait for T requires T to be 'covered' by a local type (i.e. Proto), when Self is used (I think). Self is used by Extract (Future: ExtractFuture<Item = Self>) which I think is why:

impl<M, B: BufStream> Extract<B> for M
where
    M: 'static + Message + MessageWrapper<M>
{
    type Future = Immediate<M>;
}

doesn't work.

Niko's excellent blog post has a full writeup.

The effect of this is that you'll have to specify Proto instead of just Message in your functions within impl_web!(). This, in turn hurts testability (you have to wrap your Messages to pass them into the endpoint functions) and kind of works counter to the PORTs (plain old Rust types) philosophy. But, I'm pretty sure it's the best we can do without using macros or modifying tower-web.

Into for Proto and From for Proto are implemented to ease the pain a little bit. Into for Proto instead of From<Proto> for M for the same reasons we aren't just implementing Extract for M.

Deref is also implemented it should be possible to use Proto as an M for most everything.

Implementations

impl<M: MessagePlus> Proto<M>

pub fn move_inner(self) -> M

Unwraps the message (of type M) from it's Proto container, consuming the container in the process.

pub fn new(message: M) -> Self

Creates a new Proto instance from a message of type M.

Trait Implementations

impl<M: MessagePlus> AsRef<M> for Proto<M>

fn as_ref(&self) -> &M

Performs the conversion.

impl<M: MessagePlus + Clone> Clone for Proto<M>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: MessagePlus + Debug> Debug for Proto<M>

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

Formats the value using the given formatter.

impl<M: MessagePlus> Default for Proto<M>

fn default() -> Self

Returns the "default value" for a type.

impl<M: MessagePlus> Deref for Proto<M>

type Target = M

The resulting type after dereferencing.

fn deref(&self) -> &M

Dereferences the value.

impl<B, M> Extract<B> for Proto<M> where
    B: BufStream,
    M: 'static + MessagePlus, 

type Future = MessageFuture<B, M>

The future representing the completion of the extraction logic.

fn extract(_ctx: &Context) -> Self::Future

Extract the argument from the HTTP request.

fn extract_body(ctx: &Context, body: B) -> Self::Future

Extract the argument using the HTTP request body.

fn requires_body(_: &CallSite) -> bool

Returns true if extracting the type requires body.

impl<M: MessagePlus> From<M> for Proto<M>

fn from(message: M) -> Self

Performs the conversion.

impl<M> Response for Proto<M> where
    M: MessagePlus, 

type Buf = Cursor<Bytes>

Data chunk type.

type Body = BytesWrapper

The HTTP response body type.

fn into_http<S: Serializer>(
    self,
    context: &Context<S>
) -> Result<HttpResponse<Self::Body>, Error>

Convert the value into a response future