Struct LazyJson

pub struct LazyJson<T, const LIMIT: usize = DEFAULT_LIMIT> { /* private fields */ }

lazy deserialize type that wrap around Json. It lowers the deserialization to handler function where zero copy deserialize can happen.

Example

// a json object with zero copy deserialization.
#[derive(Deserialize)]
struct Post<'a> {
    title: &'a str,
    content: &'a str    
}

// handler function utilize Lazy type to lower the Json type into handler function.
async fn handler(lazy: LazyJson<Post<'_>>) -> Result<String, Error> {
    // actual deserialize happens here.
    let Post { title, content } = lazy.deserialize()?;
    // the Post type and it's &str referencing LazyJson would live until the handler
    // function return.
    Ok(format!("Post {{ title: {title}, content: {content} }}"))
}

App::new()
    .at("/post", handler_service(handler))

Implementations

impl<T, const LIMIT: usize> LazyJson<T, LIMIT>

pub fn deserialize<'de>(&'de self) -> Result<T, Error>

where T: Deserialize<'de>,

Trait Implementations

impl<'a, 'r, C, B, T, const LIMIT: usize> FromRequest<'a, WebContext<'r, C, B>> for LazyJson<T, LIMIT>

where B: BodyStream + Default, T: Deserialize<'static>,

type Type<'b> = LazyJson<T, LIMIT>

type Error = Error

async fn from_request( ctx: &'a WebContext<'r, C, B>, ) -> Result<Self, Self::Error>