Enum Ricksponse

pub enum Ricksponse<T> {
    Data {
        data: T,
        http_code: Option<u16>,
        message: Option<String>,
    },
    Error {
        error: Option<Box<dyn DebuggableAny>>,
        http_code: Option<u16>,
        message: Option<String>,
    },
}

Variants

Data

Fields

data: T

http_code: Option<u16>

message: Option<String>

Error

Fields

error: Option<Box<dyn DebuggableAny>>

http_code: Option<u16>

message: Option<String>

Implementations

impl<T> Ricksponse<T>

pub fn http_code(&mut self, code: u16)

pub fn message(&mut self, msg: String)

pub fn get_or_with_data(&mut self, data: T) -> &mut T

pub fn new(t: T) -> Self

pub fn new_with_http(t: T, http: u16) -> Self

pub fn new_with_http_and_message(t: T, http: u16, message: &str) -> Self

impl<T> Ricksponse<T>

pub fn CONTINUE(t: T) -> Ricksponse<T>

100 Continue [RFC7231, Section 6.2.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::CONTINUE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn SWITCHING_PROTOCOLS(t: T) -> Ricksponse<T>

101 Switching Protocols [RFC7231, Section 6.2.2]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::SWITCHING_PROTOCOLS("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PROCESSING(t: T) -> Ricksponse<T>

102 Processing [RFC2518]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PROCESSING("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn OK(t: T) -> Ricksponse<T>

200 OK [RFC7231, Section 6.3.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::OK("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn CREATED(t: T) -> Ricksponse<T>

201 Created [RFC7231, Section 6.3.2]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::CREATED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn ACCEPTED(t: T) -> Ricksponse<T>

202 Accepted [RFC7231, Section 6.3.3]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::ACCEPTED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NON_AUTHORITATIVE_INFORMATION(t: T) -> Ricksponse<T>

203 Non-Authoritative Information [RFC7231, Section 6.3.4]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NON_AUTHORITATIVE_INFORMATION("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NO_CONTENT(t: T) -> Ricksponse<T>

204 No Content [RFC7231, Section 6.3.5]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NO_CONTENT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn RESET_CONTENT(t: T) -> Ricksponse<T>

205 Reset Content [RFC7231, Section 6.3.6]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::RESET_CONTENT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PARTIAL_CONTENT(t: T) -> Ricksponse<T>

206 Partial Content [RFC7233, Section 4.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PARTIAL_CONTENT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn MULTI_STATUS(t: T) -> Ricksponse<T>

207 Multi-Status [RFC4918]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::MULTI_STATUS("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn ALREADY_REPORTED(t: T) -> Ricksponse<T>

208 Already Reported [RFC5842]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::ALREADY_REPORTED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn IM_USED(t: T) -> Ricksponse<T>

226 IM Used [RFC3229]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::IM_USED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn MULTIPLE_CHOICES(t: T) -> Ricksponse<T>

300 Multiple Choices [RFC7231, Section 6.4.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::MULTIPLE_CHOICES("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn MOVED_PERMANENTLY(t: T) -> Ricksponse<T>

301 Moved Permanently [RFC7231, Section 6.4.2]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::MOVED_PERMANENTLY("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn FOUND(t: T) -> Ricksponse<T>

302 Found [RFC7231, Section 6.4.3]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::FOUND("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn SEE_OTHER(t: T) -> Ricksponse<T>

303 See Other [RFC7231, Section 6.4.4]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::SEE_OTHER("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NOT_MODIFIED(t: T) -> Ricksponse<T>

304 Not Modified [RFC7232, Section 4.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NOT_MODIFIED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn USE_PROXY(t: T) -> Ricksponse<T>

305 Use Proxy [RFC7231, Section 6.4.5]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::USE_PROXY("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn TEMPORARY_REDIRECT(t: T) -> Ricksponse<T>

307 Temporary Redirect [RFC7231, Section 6.4.7]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::TEMPORARY_REDIRECT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PERMANENT_REDIRECT(t: T) -> Ricksponse<T>

308 Permanent Redirect [RFC7238]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PERMANENT_REDIRECT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn BAD_REQUEST(t: T) -> Ricksponse<T>

400 Bad Request [RFC7231, Section 6.5.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::BAD_REQUEST("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn UNAUTHORIZED(t: T) -> Ricksponse<T>

401 Unauthorized [RFC7235, Section 3.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::UNAUTHORIZED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PAYMENT_REQUIRED(t: T) -> Ricksponse<T>

402 Payment Required [RFC7231, Section 6.5.2]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PAYMENT_REQUIRED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn FORBIDDEN(t: T) -> Ricksponse<T>

403 Forbidden [RFC7231, Section 6.5.3]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::FORBIDDEN("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NOT_FOUND(t: T) -> Ricksponse<T>

404 Not Found [RFC7231, Section 6.5.4]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NOT_FOUND("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn METHOD_NOT_ALLOWED(t: T) -> Ricksponse<T>

405 Method Not Allowed [RFC7231, Section 6.5.5]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::METHOD_NOT_ALLOWED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NOT_ACCEPTABLE(t: T) -> Ricksponse<T>

406 Not Acceptable [RFC7231, Section 6.5.6]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NOT_ACCEPTABLE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PROXY_AUTHENTICATION_REQUIRED(t: T) -> Ricksponse<T>

407 Proxy Authentication Required [RFC7235, Section 3.2]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PROXY_AUTHENTICATION_REQUIRED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn REQUEST_TIMEOUT(t: T) -> Ricksponse<T>

408 Request Timeout [RFC7231, Section 6.5.7]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::REQUEST_TIMEOUT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn CONFLICT(t: T) -> Ricksponse<T>

409 Conflict [RFC7231, Section 6.5.8]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::CONFLICT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn GONE(t: T) -> Ricksponse<T>

410 Gone [RFC7231, Section 6.5.9]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::GONE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn LENGTH_REQUIRED(t: T) -> Ricksponse<T>

411 Length Required [RFC7231, Section 6.5.10]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::LENGTH_REQUIRED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PRECONDITION_FAILED(t: T) -> Ricksponse<T>

412 Precondition Failed [RFC7232, Section 4.2]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PRECONDITION_FAILED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PAYLOAD_TOO_LARGE(t: T) -> Ricksponse<T>

413 Payload Too Large [RFC7231, Section 6.5.11]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PAYLOAD_TOO_LARGE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn URI_TOO_LONG(t: T) -> Ricksponse<T>

414 URI Too Long [RFC7231, Section 6.5.12]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::URI_TOO_LONG("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn UNSUPPORTED_MEDIA_TYPE(t: T) -> Ricksponse<T>

415 Unsupported Media Type [RFC7231, Section 6.5.13]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::UNSUPPORTED_MEDIA_TYPE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn RANGE_NOT_SATISFIABLE(t: T) -> Ricksponse<T>

416 Range Not Satisfiable [RFC7233, Section 4.4]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::RANGE_NOT_SATISFIABLE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn EXPECTATION_FAILED(t: T) -> Ricksponse<T>

417 Expectation Failed [RFC7231, Section 6.5.14]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::EXPECTATION_FAILED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn IM_A_TEAPOT(t: T) -> Ricksponse<T>

418 I’m a teapot [curiously not registered by IANA but RFC2324]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::IM_A_TEAPOT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn MISDIRECTED_REQUEST(t: T) -> Ricksponse<T>

421 Misdirected Request RFC7540, Section 9.1.2

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::MISDIRECTED_REQUEST("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn UNPROCESSABLE_ENTITY(t: T) -> Ricksponse<T>

422 Unprocessable Entity [RFC4918]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::UNPROCESSABLE_ENTITY("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn LOCKED(t: T) -> Ricksponse<T>

423 Locked [RFC4918]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::LOCKED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn FAILED_DEPENDENCY(t: T) -> Ricksponse<T>

424 Failed Dependency [RFC4918]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::FAILED_DEPENDENCY("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn UPGRADE_REQUIRED(t: T) -> Ricksponse<T>

426 Upgrade Required [RFC7231, Section 6.5.15]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::UPGRADE_REQUIRED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn PRECONDITION_REQUIRED(t: T) -> Ricksponse<T>

428 Precondition Required [RFC6585]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::PRECONDITION_REQUIRED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn TOO_MANY_REQUESTS(t: T) -> Ricksponse<T>

429 Too Many Requests [RFC6585]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::TOO_MANY_REQUESTS("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn REQUEST_HEADER_FIELDS_TOO_LARGE(t: T) -> Ricksponse<T>

431 Request Header Fields Too Large [RFC6585]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::REQUEST_HEADER_FIELDS_TOO_LARGE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn UNAVAILABLE_FOR_LEGAL_REASONS(t: T) -> Ricksponse<T>

451 Unavailable For Legal Reasons [RFC7725]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::UNAVAILABLE_FOR_LEGAL_REASONS("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn INTERNAL_SERVER_ERROR(t: T) -> Ricksponse<T>

500 Internal Server Error [RFC7231, Section 6.6.1]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::INTERNAL_SERVER_ERROR("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NOT_IMPLEMENTED(t: T) -> Ricksponse<T>

501 Not Implemented [RFC7231, Section 6.6.2]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NOT_IMPLEMENTED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn BAD_GATEWAY(t: T) -> Ricksponse<T>

502 Bad Gateway [RFC7231, Section 6.6.3]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::BAD_GATEWAY("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn SERVICE_UNAVAILABLE(t: T) -> Ricksponse<T>

503 Service Unavailable [RFC7231, Section 6.6.4]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::SERVICE_UNAVAILABLE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn GATEWAY_TIMEOUT(t: T) -> Ricksponse<T>

504 Gateway Timeout [RFC7231, Section 6.6.5]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::GATEWAY_TIMEOUT("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn HTTP_VERSION_NOT_SUPPORTED(t: T) -> Ricksponse<T>

505 HTTP Version Not Supported [RFC7231, Section 6.6.6]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::HTTP_VERSION_NOT_SUPPORTED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn VARIANT_ALSO_NEGOTIATES(t: T) -> Ricksponse<T>

506 Variant Also Negotiates [RFC2295]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::VARIANT_ALSO_NEGOTIATES("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn INSUFFICIENT_STORAGE(t: T) -> Ricksponse<T>

507 Insufficient Storage [RFC4918]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::INSUFFICIENT_STORAGE("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn LOOP_DETECTED(t: T) -> Ricksponse<T>

508 Loop Detected [RFC5842]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::LOOP_DETECTED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NOT_EXTENDED(t: T) -> Ricksponse<T>

510 Not Extended [RFC2774]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NOT_EXTENDED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

pub fn NETWORK_AUTHENTICATION_REQUIRED(t: T) -> Ricksponse<T>

511 Network Authentication Required [RFC6585]

use ricksponse::{Ricksponse};
 
let mut response: Ricksponse<String> = Ricksponse::NETWORK_AUTHENTICATION_REQUIRED("test".to_string());
 
assert_eq!(
    response.get_or_with_data("".to_string()),
    &"test".to_string()
);

Trait Implementations

impl<T> Debug for Ricksponse<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Display for Ricksponse<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T: Serialize + HateoasResource + DeserializeOwned + Default> From<Hateoas<T>> for Ricksponse<Hateoas<T>>

fn from(r: Hateoas<T>) -> Self

Converts to this type from the input type.

impl<T, E: DebuggableAny> From<Result<T, E>> for Ricksponse<T>

fn from(r: Result<T, E>) -> Self

Converts to this type from the input type.

impl<T> From<Ricksponse<T>> for HttpResponseBuilder

fn from(r: Ricksponse<T>) -> Self

Converts to this type from the input type.

impl<T> From<Ricksponse<T>> for Result<T, Option<Box<dyn DebuggableAny>>>

fn from(r: Ricksponse<T>) -> Self

Converts to this type from the input type.

impl<T> FromRequest for Ricksponse<T>

where T: DeserializeOwned + PayloadControl,

Example

use actix_web::{web, App};
use serde_derive::Deserialize;
use ricksponse::Ricksponse;
use ricksponse::PayloadControl;

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

impl PayloadControl for Info {
    const MAX_PAYLOAD_SIZE: Option<usize> = None;
    const BUFFER_CAPACITY: Option<usize> = None;
}

/// deserialize `Info` from request's body
async fn index(info: Ricksponse<Info>) -> String {
format!("Welcome {:?}!", info)
}

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

type Error = Error

The associated error which can be returned.

type Future = PayloadFuture<T, T, Ricksponse<T>>

Future that resolves to a Self.

fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously.

impl<T: Serialize> Responder for Ricksponse<T>

type Body = BoxBody

fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body>

Convert self to HttpResponse.

fn customize(self) -> CustomizeResponder<Self>

where Self: Sized,

Wraps responder to allow alteration of its response.