Struct seamless::handler::body::FromJson

pub struct FromJson<T: ApiBody>(pub T);

If the last argument to a handler is this, we’ll assume that the user needs to provide JSON that decodes to T. Notably, T needs to implement ApiBody with the Deserialize option.

Tuple Fields

0: T

Trait Implementations

impl<T> ApiBody for FromJson<T> where
    T: ApiBody, 

fn api_body_info() -> ApiBodyInfo

This returns information about the shape of the type and description of parts of it.

fn to_json_vec(&self) -> Vec<u8> where
    Self: Serialize, 

Serialize the type to JSON.

fn to_json_value(&self) -> Value where
    Self: Serialize, 

Serialize the type to a serde_json::Value.

fn from_json_slice(bytes: &[u8]) -> Result<Self> where
    Self: DeserializeOwned, 

Deserialize from bytes containing a JSON value.

fn from_json_value(value: Value) -> Result<Self> where
    Self: DeserializeOwned, 

Deserialize from a serde_json::Value.

impl<T: ApiBody> Deref for FromJson<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ApiBody> DerefMut for FromJson<T>

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

Mutably dereferences the value.

impl<T: DeserializeOwned + ApiBody> HandlerBody for FromJson<T>

fn handler_body<'life0, 'async_trait>(
    req: Request<&'life0 mut dyn AsyncReadBody>
) -> Pin<Box<dyn Future<Output = Result<Self, ApiError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Given a request containing arbitrary bytes, this function needs to return an instance of the type that this trait is implemented on (typically by deserializing it from the bytes provided), or else it should return an error describing what went wrong.

fn handler_method() -> Method

Which HTTP method is required for this Body to be valid. By default, if a body is present in the handler we’ll expect the method to be POST. Implement this function to override that.

impl<T: ApiBody> IntoBody for FromJson<T>

type Target = T

The body type that will be extracted. Whatever we extract should itself implement ApiBody to correspond to the generated type information.

fn into_body(self) -> Self::Target

Extract the body of the request with this, unwrapping as many layers of nesting as needed.