Struct rocket_contrib::JSON [] [src]

pub struct JSON<T>(pub T);

The JSON type: implements FromData and Responder, allowing you to easily consume and respond with JSON.

If you're receiving JSON data, simply add a data parameter to your route arguments and ensure the type of the parameter is a JSON<T>, where T is some type you'd like to parse from JSON. T must implement Deserialize from Serde. The data is parsed from the HTTP request body.

#[post("/users/", format = "application/json", data = "<user>")]
fn new_user(user: JSON<User>) {

You don't need to use format = "application/json", but it may be what you want. Using format = application/json means that any request that doesn't specify "application/json" as its Content-Type header value will not be routed to the handler.

If you're responding with JSON data, return a JSON<T> type, where T implements Serialize from Serde. The content type of the response is set to application/json automatically.

fn user(id: usize) -> JSON<User> {
    let user_from_id = User::from(id);


impl<T> JSON<T>

Consumes the JSON wrapper and returns the wrapped item.


let string = "Hello".to_string();
let my_json = JSON(string);
assert_eq!(my_json.into_inner(), "Hello".to_string());

Trait Implementations

impl<T: Debug> Debug for JSON<T>

Formats the value using the given formatter.

impl<T: Deserialize> FromData for JSON<T>

The associated error to be returned when parsing fails.

Parses an instance of Self from the incoming request body data. Read more

impl<T: Serialize> Responder<'static> for JSON<T>

Serializes the wrapped value into JSON. Returns a response with Content-Type JSON and a fixed-size body with the serialized value. If serialization fails, an Err of Status::InternalServerError is returned.

Returns Ok if a Response could be generated successfully. Otherwise, returns an Err with a failing Status. Read more

impl<T> Deref for JSON<T>

The resulting type after dereferencing

The method called to dereference a value

impl<T> DerefMut for JSON<T>

The method called to mutably dereference a value