Struct Status 

pub struct Status { /* private fields */ }

Implementations

impl Status

pub fn new( message: Option<&str>, code: Option<u32>, http_status_code: Option<u16>, session: Option<Uuid>, ) -> Self

pub const fn const_new( message: Option<String>, code: Option<u32>, http_status_code: Option<u16>, session: Option<Uuid>, ) -> Self

pub fn message(&self) -> &Option<String>

Getting Message

This is for getting the message field from the status object.

use hateoas::Status;

let mut status = Status::new(Some("hello world"), None, None, None);

assert_eq!(status.message(), &Some("hello world".to_string()));

pub fn message_mut(&mut self) -> &mut Option<String>

Getting Mutable Message

This is for getting the message field from the status object.

use hateoas::Status;

let mut status = Status::new(Some("hello world"), None, None, None);

let mut mut_message = status.message_mut();
*mut_message = Some("Hello Space".to_string());

assert_eq!(status.message(), &Some("Hello Space".to_string()));

pub fn code(&self) -> &Option<u32>

Getting code

Getting the internal status code from the stauts object

use hateoas::Status;

let mut status = Status::new(None, Some(200), None, None);

assert_eq!(status.code(), &Some(200));

pub fn code_mut(&mut self) -> &mut Option<u32>

Getting Mutable Code

Getting the internal status code from the stauts object as a mutable reference allowing for modifications to the internal status code.

use hateoas::Status;

let mut status = Status::new(None, Some(200), None, None);

let mut status_code = status.code_mut();
*status_code = Some(100);

assert_eq!(status.code(), &Some(100));

pub fn http_status_code(&self) -> &Option<u16>

Getter for the HTTP status code

This is for getting the http_status_code.

use hateoas::Status;

let mut status = Status::new(None, None, Some(200), None);

assert_eq!(status.http_status_code(), &Some(200));

pub fn http_status_code_mut(&mut self) -> &mut Option<u16>

Getter for mutable HTTP status code

This is for getting the http_status_code.

use hateoas::Status;

let mut status = Status::new(None, None, Some(200), None);

let mut http_code = status.http_status_code_mut();
*http_code = Some(100);

assert_eq!(status.http_status_code(), &Some(100));

pub fn session(&self) -> &Option<Uuid>

Getter for the Session

use hateoas::Status;

let uuid = uuid::Uuid::new_v4();
let mut status = Status::new(None, None, None, Some(uuid));

assert_eq!(status.session(), &Some(uuid));

pub fn session_mut(&mut self) -> &mut Option<Uuid>

Getter for mutable Session id

use hateoas::Status;

let uuid = uuid::Uuid::new_v4();
let uuid_2 = uuid::Uuid::new_v4();
let mut status = Status::default();

let mut mut_session = status.session_mut();
*mut_session = Some(uuid_2);

assert_eq!(status.session(), &Some(uuid_2));

pub fn get( &self, ) -> (&Option<String>, &Option<u32>, &Option<u16>, &Option<Uuid>)

pub fn get_mut( &mut self, ) -> (&mut Option<String>, &mut Option<u32>, &mut Option<u16>, &mut Option<Uuid>)

impl Status

pub fn CONTINUE() -> Self

100 Continue [RFC7231, Section 6.2.1]

use hateoas::Status;
 
let status = Status::CONTINUE();
 
assert_eq!(status, Status::const_new(Some("Continue".to_string()), None, Some(100), None));

pub fn SWITCHING_PROTOCOLS() -> Self

101 Switching Protocols [RFC7231, Section 6.2.2]

use hateoas::Status;
 
let status = Status::SWITCHING_PROTOCOLS();
 
assert_eq!(status, Status::const_new(Some("Switching Protocols".to_string()), None, Some(101), None));

pub fn PROCESSING() -> Self

102 Processing [RFC2518]

use hateoas::Status;
 
let status = Status::PROCESSING();
 
assert_eq!(status, Status::const_new(Some("Processing".to_string()), None, Some(102), None));

pub fn OK() -> Self

200 OK [RFC7231, Section 6.3.1]

use hateoas::Status;
 
let status = Status::OK();
 
assert_eq!(status, Status::const_new(Some("OK".to_string()), None, Some(200), None));

pub fn CREATED() -> Self

201 Created [RFC7231, Section 6.3.2]

use hateoas::Status;
 
let status = Status::CREATED();
 
assert_eq!(status, Status::const_new(Some("Created".to_string()), None, Some(201), None));

pub fn ACCEPTED() -> Self

202 Accepted [RFC7231, Section 6.3.3]

use hateoas::Status;
 
let status = Status::ACCEPTED();
 
assert_eq!(status, Status::const_new(Some("Accepted".to_string()), None, Some(202), None));

pub fn NON_AUTHORITATIVE_INFORMATION() -> Self

203 Non-Authoritative Information [RFC7231, Section 6.3.4]

use hateoas::Status;
 
let status = Status::NON_AUTHORITATIVE_INFORMATION();
 
assert_eq!(status, Status::const_new(Some("Non Authoritative Information".to_string()), None, Some(203), None));

pub fn NO_CONTENT() -> Self

204 No Content [RFC7231, Section 6.3.5]

use hateoas::Status;
 
let status = Status::NO_CONTENT();
 
assert_eq!(status, Status::const_new(Some("No Content".to_string()), None, Some(204), None));

pub fn RESET_CONTENT() -> Self

205 Reset Content [RFC7231, Section 6.3.6]

use hateoas::Status;
 
let status = Status::RESET_CONTENT();
 
assert_eq!(status, Status::const_new(Some("Reset Content".to_string()), None, Some(205), None));

pub fn PARTIAL_CONTENT() -> Self

206 Partial Content [RFC7233, Section 4.1]

use hateoas::Status;
 
let status = Status::PARTIAL_CONTENT();
 
assert_eq!(status, Status::const_new(Some("Partial Content".to_string()), None, Some(206), None));

pub fn MULTI_STATUS() -> Self

207 Multi-Status [RFC4918]

use hateoas::Status;
 
let status = Status::MULTI_STATUS();
 
assert_eq!(status, Status::const_new(Some("Multi-Status".to_string()), None, Some(207), None));

pub fn ALREADY_REPORTED() -> Self

208 Already Reported [RFC5842]

use hateoas::Status;
 
let status = Status::ALREADY_REPORTED();
 
assert_eq!(status, Status::const_new(Some("Already Reported".to_string()), None, Some(208), None));

pub fn IM_USED() -> Self

226 IM Used [RFC3229]

use hateoas::Status;
 
let status = Status::IM_USED();
 
assert_eq!(status, Status::const_new(Some("IM Used".to_string()), None, Some(226), None));

pub fn MULTIPLE_CHOICES() -> Self

300 Multiple Choices [RFC7231, Section 6.4.1]

use hateoas::Status;
 
let status = Status::MULTIPLE_CHOICES();
 
assert_eq!(status, Status::const_new(Some("Multiple Choices".to_string()), None, Some(300), None));

pub fn MOVED_PERMANENTLY() -> Self

301 Moved Permanently [RFC7231, Section 6.4.2]

use hateoas::Status;
 
let status = Status::MOVED_PERMANENTLY();
 
assert_eq!(status, Status::const_new(Some("Moved Permanently".to_string()), None, Some(301), None));

pub fn FOUND() -> Self

302 Found [RFC7231, Section 6.4.3]

use hateoas::Status;
 
let status = Status::FOUND();
 
assert_eq!(status, Status::const_new(Some("Found".to_string()), None, Some(302), None));

pub fn SEE_OTHER() -> Self

303 See Other [RFC7231, Section 6.4.4]

use hateoas::Status;
 
let status = Status::SEE_OTHER();
 
assert_eq!(status, Status::const_new(Some("See Other".to_string()), None, Some(303), None));

pub fn NOT_MODIFIED() -> Self

304 Not Modified [RFC7232, Section 4.1]

use hateoas::Status;
 
let status = Status::NOT_MODIFIED();
 
assert_eq!(status, Status::const_new(Some("Not Modified".to_string()), None, Some(304), None));

pub fn USE_PROXY() -> Self

305 Use Proxy [RFC7231, Section 6.4.5]

use hateoas::Status;
 
let status = Status::USE_PROXY();
 
assert_eq!(status, Status::const_new(Some("Use Proxy".to_string()), None, Some(305), None));

pub fn TEMPORARY_REDIRECT() -> Self

307 Temporary Redirect [RFC7231, Section 6.4.7]

use hateoas::Status;
 
let status = Status::TEMPORARY_REDIRECT();
 
assert_eq!(status, Status::const_new(Some("Temporary Redirect".to_string()), None, Some(307), None));

pub fn PERMANENT_REDIRECT() -> Self

308 Permanent Redirect [RFC7238]

use hateoas::Status;
 
let status = Status::PERMANENT_REDIRECT();
 
assert_eq!(status, Status::const_new(Some("Permanent Redirect".to_string()), None, Some(308), None));

pub fn BAD_REQUEST() -> Self

400 Bad Request [RFC7231, Section 6.5.1]

use hateoas::Status;
 
let status = Status::BAD_REQUEST();
 
assert_eq!(status, Status::const_new(Some("Bad Request".to_string()), None, Some(400), None));

pub fn UNAUTHORIZED() -> Self

401 Unauthorized [RFC7235, Section 3.1]

use hateoas::Status;
 
let status = Status::UNAUTHORIZED();
 
assert_eq!(status, Status::const_new(Some("Unauthorized".to_string()), None, Some(401), None));

pub fn PAYMENT_REQUIRED() -> Self

402 Payment Required [RFC7231, Section 6.5.2]

use hateoas::Status;
 
let status = Status::PAYMENT_REQUIRED();
 
assert_eq!(status, Status::const_new(Some("Payment Required".to_string()), None, Some(402), None));

pub fn FORBIDDEN() -> Self

403 Forbidden [RFC7231, Section 6.5.3]

use hateoas::Status;
 
let status = Status::FORBIDDEN();
 
assert_eq!(status, Status::const_new(Some("Forbidden".to_string()), None, Some(403), None));

pub fn NOT_FOUND() -> Self

404 Not Found [RFC7231, Section 6.5.4]

use hateoas::Status;
 
let status = Status::NOT_FOUND();
 
assert_eq!(status, Status::const_new(Some("Not Found".to_string()), None, Some(404), None));

pub fn METHOD_NOT_ALLOWED() -> Self

405 Method Not Allowed [RFC7231, Section 6.5.5]

use hateoas::Status;
 
let status = Status::METHOD_NOT_ALLOWED();
 
assert_eq!(status, Status::const_new(Some("Method Not Allowed".to_string()), None, Some(405), None));

pub fn NOT_ACCEPTABLE() -> Self

406 Not Acceptable [RFC7231, Section 6.5.6]

use hateoas::Status;
 
let status = Status::NOT_ACCEPTABLE();
 
assert_eq!(status, Status::const_new(Some("Not Acceptable".to_string()), None, Some(406), None));

pub fn PROXY_AUTHENTICATION_REQUIRED() -> Self

407 Proxy Authentication Required [RFC7235, Section 3.2]

use hateoas::Status;
 
let status = Status::PROXY_AUTHENTICATION_REQUIRED();
 
assert_eq!(status, Status::const_new(Some("Proxy Authentication Required".to_string()), None, Some(407), None));

pub fn REQUEST_TIMEOUT() -> Self

408 Request Timeout [RFC7231, Section 6.5.7]

use hateoas::Status;
 
let status = Status::REQUEST_TIMEOUT();
 
assert_eq!(status, Status::const_new(Some("Request Timeout".to_string()), None, Some(408), None));

pub fn CONFLICT() -> Self

409 Conflict [RFC7231, Section 6.5.8]

use hateoas::Status;
 
let status = Status::CONFLICT();
 
assert_eq!(status, Status::const_new(Some("Conflict".to_string()), None, Some(409), None));

pub fn GONE() -> Self

410 Gone [RFC7231, Section 6.5.9]

use hateoas::Status;
 
let status = Status::GONE();
 
assert_eq!(status, Status::const_new(Some("Gone".to_string()), None, Some(410), None));

pub fn LENGTH_REQUIRED() -> Self

411 Length Required [RFC7231, Section 6.5.10]

use hateoas::Status;
 
let status = Status::LENGTH_REQUIRED();
 
assert_eq!(status, Status::const_new(Some("Length Required".to_string()), None, Some(411), None));

pub fn PRECONDITION_FAILED() -> Self

412 Precondition Failed [RFC7232, Section 4.2]

use hateoas::Status;
 
let status = Status::PRECONDITION_FAILED();
 
assert_eq!(status, Status::const_new(Some("Precondition Failed".to_string()), None, Some(412), None));

pub fn PAYLOAD_TOO_LARGE() -> Self

413 Payload Too Large [RFC7231, Section 6.5.11]

use hateoas::Status;
 
let status = Status::PAYLOAD_TOO_LARGE();
 
assert_eq!(status, Status::const_new(Some("Payload Too Large".to_string()), None, Some(413), None));

pub fn URI_TOO_LONG() -> Self

414 URI Too Long [RFC7231, Section 6.5.12]

use hateoas::Status;
 
let status = Status::URI_TOO_LONG();
 
assert_eq!(status, Status::const_new(Some("URI Too Long".to_string()), None, Some(414), None));

pub fn UNSUPPORTED_MEDIA_TYPE() -> Self

415 Unsupported Media Type [RFC7231, Section 6.5.13]

use hateoas::Status;
 
let status = Status::UNSUPPORTED_MEDIA_TYPE();
 
assert_eq!(status, Status::const_new(Some("Unsupported Media Type".to_string()), None, Some(415), None));

pub fn RANGE_NOT_SATISFIABLE() -> Self

416 Range Not Satisfiable [RFC7233, Section 4.4]

use hateoas::Status;
 
let status = Status::RANGE_NOT_SATISFIABLE();
 
assert_eq!(status, Status::const_new(Some("Range Not Satisfiable".to_string()), None, Some(416), None));

pub fn EXPECTATION_FAILED() -> Self

417 Expectation Failed [RFC7231, Section 6.5.14]

use hateoas::Status;
 
let status = Status::EXPECTATION_FAILED();
 
assert_eq!(status, Status::const_new(Some("Expectation Failed".to_string()), None, Some(417), None));

pub fn IM_A_TEAPOT() -> Self

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

use hateoas::Status;
 
let status = Status::IM_A_TEAPOT();
 
assert_eq!(status, Status::const_new(Some("I'm a teapot".to_string()), None, Some(418), None));

pub fn MISDIRECTED_REQUEST() -> Self

421 Misdirected Request RFC7540, Section 9.1.2

use hateoas::Status;
 
let status = Status::MISDIRECTED_REQUEST();
 
assert_eq!(status, Status::const_new(Some("Misdirected Request".to_string()), None, Some(421), None));

pub fn UNPROCESSABLE_ENTITY() -> Self

422 Unprocessable Entity [RFC4918]

use hateoas::Status;
 
let status = Status::UNPROCESSABLE_ENTITY();
 
assert_eq!(status, Status::const_new(Some("Unprocessable Entity".to_string()), None, Some(422), None));

pub fn LOCKED() -> Self

423 Locked [RFC4918]

use hateoas::Status;
 
let status = Status::LOCKED();
 
assert_eq!(status, Status::const_new(Some("Locked".to_string()), None, Some(423), None));

pub fn FAILED_DEPENDENCY() -> Self

424 Failed Dependency [RFC4918]

use hateoas::Status;
 
let status = Status::FAILED_DEPENDENCY();
 
assert_eq!(status, Status::const_new(Some("Failed Dependency".to_string()), None, Some(424), None));

pub fn UPGRADE_REQUIRED() -> Self

426 Upgrade Required [RFC7231, Section 6.5.15]

use hateoas::Status;
 
let status = Status::UPGRADE_REQUIRED();
 
assert_eq!(status, Status::const_new(Some("Upgrade Required".to_string()), None, Some(426), None));

pub fn PRECONDITION_REQUIRED() -> Self

428 Precondition Required [RFC6585]

use hateoas::Status;
 
let status = Status::PRECONDITION_REQUIRED();
 
assert_eq!(status, Status::const_new(Some("Precondition Required".to_string()), None, Some(428), None));

pub fn TOO_MANY_REQUESTS() -> Self

429 Too Many Requests [RFC6585]

use hateoas::Status;
 
let status = Status::TOO_MANY_REQUESTS();
 
assert_eq!(status, Status::const_new(Some("Too Many Requests".to_string()), None, Some(429), None));

pub fn REQUEST_HEADER_FIELDS_TOO_LARGE() -> Self

431 Request Header Fields Too Large [RFC6585]

use hateoas::Status;
 
let status = Status::REQUEST_HEADER_FIELDS_TOO_LARGE();
 
assert_eq!(status, Status::const_new(Some("Request Header Fields Too Large".to_string()), None, Some(431), None));

pub fn UNAVAILABLE_FOR_LEGAL_REASONS() -> Self

451 Unavailable For Legal Reasons [RFC7725]

use hateoas::Status;
 
let status = Status::UNAVAILABLE_FOR_LEGAL_REASONS();
 
assert_eq!(status, Status::const_new(Some("Unavailable For Legal Reasons".to_string()), None, Some(451), None));

pub fn INTERNAL_SERVER_ERROR() -> Self

500 Internal Server Error [RFC7231, Section 6.6.1]

use hateoas::Status;
 
let status = Status::INTERNAL_SERVER_ERROR();
 
assert_eq!(status, Status::const_new(Some("Internal Server Error".to_string()), None, Some(500), None));

pub fn NOT_IMPLEMENTED() -> Self

501 Not Implemented [RFC7231, Section 6.6.2]

use hateoas::Status;
 
let status = Status::NOT_IMPLEMENTED();
 
assert_eq!(status, Status::const_new(Some("Not Implemented".to_string()), None, Some(501), None));

pub fn BAD_GATEWAY() -> Self

502 Bad Gateway [RFC7231, Section 6.6.3]

use hateoas::Status;
 
let status = Status::BAD_GATEWAY();
 
assert_eq!(status, Status::const_new(Some("Bad Gateway".to_string()), None, Some(502), None));

pub fn SERVICE_UNAVAILABLE() -> Self

503 Service Unavailable [RFC7231, Section 6.6.4]

use hateoas::Status;
 
let status = Status::SERVICE_UNAVAILABLE();
 
assert_eq!(status, Status::const_new(Some("Service Unavailable".to_string()), None, Some(503), None));

pub fn GATEWAY_TIMEOUT() -> Self

504 Gateway Timeout [RFC7231, Section 6.6.5]

use hateoas::Status;
 
let status = Status::GATEWAY_TIMEOUT();
 
assert_eq!(status, Status::const_new(Some("Gateway Timeout".to_string()), None, Some(504), None));

pub fn HTTP_VERSION_NOT_SUPPORTED() -> Self

505 HTTP Version Not Supported [RFC7231, Section 6.6.6]

use hateoas::Status;
 
let status = Status::HTTP_VERSION_NOT_SUPPORTED();
 
assert_eq!(status, Status::const_new(Some("HTTP Version Not Supported".to_string()), None, Some(505), None));

pub fn VARIANT_ALSO_NEGOTIATES() -> Self

506 Variant Also Negotiates [RFC2295]

use hateoas::Status;
 
let status = Status::VARIANT_ALSO_NEGOTIATES();
 
assert_eq!(status, Status::const_new(Some("Variant Also Negotiates".to_string()), None, Some(506), None));

pub fn INSUFFICIENT_STORAGE() -> Self

507 Insufficient Storage [RFC4918]

use hateoas::Status;
 
let status = Status::INSUFFICIENT_STORAGE();
 
assert_eq!(status, Status::const_new(Some("Insufficient Storage".to_string()), None, Some(507), None));

pub fn LOOP_DETECTED() -> Self

508 Loop Detected [RFC5842]

use hateoas::Status;
 
let status = Status::LOOP_DETECTED();
 
assert_eq!(status, Status::const_new(Some("Loop Detected".to_string()), None, Some(508), None));

pub fn NOT_EXTENDED() -> Self

510 Not Extended [RFC2774]

use hateoas::Status;
 
let status = Status::NOT_EXTENDED();
 
assert_eq!(status, Status::const_new(Some("Not Extended".to_string()), None, Some(510), None));

pub fn NETWORK_AUTHENTICATION_REQUIRED() -> Self

511 Network Authentication Required [RFC6585]

use hateoas::Status;
 
let status = Status::NETWORK_AUTHENTICATION_REQUIRED();
 
assert_eq!(status, Status::const_new(Some("Network Authentication Required".to_string()), None, Some(511), None));

Trait Implementations

impl Debug for Status

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

Formats the value using the given formatter.

impl Default for Status

fn default() -> Status

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Status

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Status

fn eq(&self, other: &Status) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Status

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Status