Struct Json 

pub struct Json<T>(pub T);

Json helper

Json can be used for two different purpose. First is for json response generation and second is for extracting typed information from request’s payload.

To extract typed information from request’s body, the type T must implement the Deserialize trait from serde.

JsonConfig allows to configure extraction process.

Example

use ntex::web;

#[derive(serde::Deserialize)]
struct Info {
    username: String,
}

/// deserialize `Info` from request's body
async fn index(info: web::types::Json<Info>) -> String {
    format!("Welcome {}!", info.username)
}

fn main() {
    let app = web::App::default().service(
       web::resource("/index.html").route(
           web::post().to(index))
    );
}

The Json type allows you to respond with well-formed JSON data: simply return a value of type Json<T> where T is the type of a structure to serialize into JSON. The type T must implement the Serialize trait from serde.

use ntex::web;

#[derive(serde::Serialize)]
struct MyObj {
    name: String,
}

fn index(req: web::HttpRequest) -> Result<web::types::Json<MyObj>, std::io::Error> {
    Ok(web::types::Json(MyObj {
        name: req.match_info().get("name").unwrap().to_string(),
    }))
}

Tuple Fields

0: T

Implementations

impl<T> Json<T>

pub fn into_inner(self) -> T

Deconstruct to an inner value

Trait Implementations

impl<T> Debug for Json<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Json<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for Json<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T> Display for Json<T>

where T: Display,

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

Formats the value using the given formatter.

impl<St, T> FromRequest<St> for Json<T>

where St: State, T: DeserializeOwned + 'static,

Json extractor. Allow to extract typed information from request’s payload.

To extract typed information from request’s body, the type T must implement the Deserialize trait from serde.

JsonConfig allows to configure extraction process.

Example

use ntex::web;

#[derive(serde::Deserialize)]
struct Info {
    username: String,
}

/// deserialize `Info` from request's body
async fn index(info: web::types::Json<Info>) -> String {
    format!("Welcome {}!", info.username)
}

fn main() {
    let app = web::App::default().service(
        web::resource("/index.html").route(
           web::post().to(index))
    );
}

type Error = JsonPayloadError

The error returned when extraction fails.

async fn from_request( _: &St, req: &HttpRequest, payload: &mut Payload, ) -> Result<Self, Self::Error>

Creates the extractor value for this request.

impl<St, T: Serialize> Responder<St> for Json<T>

where St: State, JsonError: WebResponseError<St, St::Error>,

async fn respond_to(self, st: &St, _: &HttpRequest) -> Response

Builds an HTTP response from this value.

fn with_status(self, status: StatusCode) -> CustomResponder<Self, St>

where Self: Sized,

Replaces the status code produced by this responder.

fn with_header<K, V>(self, key: K, value: V) -> CustomResponder<Self, St>

where Self: Sized, HeaderName: TryFrom<K>, HeaderValue: TryFrom<V>, <HeaderName as TryFrom<K>>::Error: Into<HttpError>, <HeaderValue as TryFrom<V>>::Error: Into<HttpError>,

Sets a header on the response produced by this responder.