Struct Protobuf

pub struct Protobuf<T>(pub T);

Available on crate feature protobuf only.

A Protocol Buffer message extractor and response.

This can be used both as an extractor and as a response.

As extractor

When used as an extractor, it can decode request bodies into some type that implements prost::Message. The request will be rejected (and a ProtobufRejection will be returned) if:

• The body couldn’t be decoded into the target Protocol Buffer message type.
• Buffering the request body fails.

See ProtobufRejection for more details.

The extractor does not expect a Content-Type header to be present in the request.

Extractor example

use axum::{routing::post, Router};
use axum_extra::protobuf::Protobuf;

#[derive(prost::Message)]
struct CreateUser {
    #[prost(string, tag="1")]
    email: String,
    #[prost(string, tag="2")]
    password: String,
}

async fn create_user(Protobuf(payload): Protobuf<CreateUser>) {
    // payload is `CreateUser`
}

let app = Router::new().route("/users", post(create_user));

As response

When used as a response, it can encode any type that implements prost::Message to a newly allocated buffer.

If no Content-Type header is set, the Content-Type: application/octet-stream header will be used automatically.

Response example

use axum::{
    extract::Path,
    routing::get,
    Router,
};
use axum_extra::protobuf::Protobuf;

#[derive(prost::Message)]
struct User {
    #[prost(string, tag="1")]
    username: String,
}

async fn get_user(Path(user_id) : Path<String>) -> Protobuf<User> {
    let user = find_user(user_id).await;
    Protobuf(user)
}

async fn find_user(user_id: String) -> User {
    // ...
}

let app = Router::new().route("/users/:id", get(get_user));

Tuple Fields

0: T

Trait Implementations

impl<T: Clone> Clone for Protobuf<T>

fn clone(&self) -> Protobuf<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Protobuf<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Protobuf<T>

fn default() -> Protobuf<T>

Returns the “default value” for a type.

impl<T> Deref for Protobuf<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Protobuf<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> From<T> for Protobuf<T>

fn from(inner: T) -> Self

Converts to this type from the input type.

impl<T, S> FromRequest<S> for Protobuf<T>

where T: Message + Default, S: Send + Sync,

type Rejection = ProtobufRejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request<'life0, 'async_trait>( req: Request, state: &'life0 S, ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Perform the extraction.

impl<T> IntoResponse for Protobuf<T>

where T: Message + Default,

fn into_response(self) -> Response

Create a response.

impl<T: Copy> Copy for Protobuf<T>