Struct Hateoas 

pub struct Hateoas<T: Serialize + HateoasResource> {
    pub api_version: String,
    pub kind: String,
    pub metadata: Option<Metadata>,
    pub spec: Option<Content<T>>,
    pub status: Option<Status>,
}

Fields

api_version: String

kind: String

metadata: Option<Metadata>

spec: Option<Content<T>>

status: Option<Status>

Implementations

impl<T: Serialize + Default + HateoasResource> Hateoas<T>

pub fn new( spec: Option<Content<T>>, metadata: Option<Metadata>, status: Option<Status>, ) -> Self

New Hateoas.

this will create a new instance of Hateoas that will make it easier to crate API replyes for services.

use hateoas::Hateoas;

let new_hateoas_response: Hateoas<String> = Hateoas::new(None, None, None);

assert_eq!(new_hateoas_response, Hateoas::default() as Hateoas<String>);
assert_eq!(new_hateoas_response.spec(), &None);
assert_eq!(new_hateoas_response.status(), &None);
assert_eq!(new_hateoas_response.metadata(), &None);
assert_eq!(new_hateoas_response.kind(), &"String".to_string());
assert_eq!(new_hateoas_response.api_version(), &"hateoas.io/0.0.1");

pub fn kind(&self) -> &String

Getting the kind of the resource

This will return the kind of the resource requested.

use hateoas::Hateoas;

let new_hateoas_response: Hateoas<String> = Hateoas::new(None, None, None);

assert_eq!(new_hateoas_response.kind(), &"String".to_string());

pub fn api_version(&self) -> &String

Getting the api version of the resource

This will get the API version of the resource, this will help as API expands and there are multiple versions on the system.

use hateoas::Hateoas;

let new_hateoas_response: Hateoas<String> = Hateoas::new(None, None, None);

assert_eq!(new_hateoas_response.api_version(), &"hateoas.io/0.0.1");

pub fn metadata(&self) -> &Option<Metadata>

Getter for the metadata property

This will get the metadata, if there is no metadata in the system, metadata will no be initialized, in comparison to the setter metadata_mut that will initialize the metadata property with the metadata object.

use hateoas::Hateoas;

let hateoas: Hateoas<()> = Hateoas::default();
let metadata = hateoas.metadata();

assert_eq!(metadata, &None)

pub fn metadata_mut(&mut self) -> &mut Metadata

Getting the metadata from the response. By default metadata is not initialized and will be initialized upon usage.

use hateoas::{Hateoas, Metadata};

let mut response: Hateoas<()> = Hateoas::default();
let mut metadata = Metadata::default();

assert_eq!(&mut metadata, response.metadata_mut());

pub fn status(&self) -> &Option<Status>

Getter for the status property

This will get the status, if there is no status in the system, status will no be initialized, in comparison to the setter status_mut that will initialize the status property with the status object.

use hateoas::Hateoas;

let hateoas: Hateoas<()> = Hateoas::default();
let status = hateoas.status();

assert_eq!(status, &None)

pub fn status_mut(&mut self) -> &mut Status

Get The status information from the response, If this is not initialized it will be initialized and returned.

use hateoas::{Hateoas, Status};

let mut response: Hateoas<()> = Hateoas::default();

let mut status = response.status_mut();
assert_eq!(&mut Status::default(), status)

pub fn spec(&self) -> &Option<Content<T>>

Getter for the spec property

This will get the spec, if there is no spec in the system, spec will no be initialized, in comparison to the setter spec_mut that will initialize the spec property with the spec object.

use hateoas::Hateoas;

let hateoas: Hateoas<()> = Hateoas::default();
let spec = hateoas.spec();

assert_eq!(spec, &None)

pub fn spec_mut(&mut self) -> &mut Content<T>

Get the spec information form the Response payload

use hateoas::{Content, Hateoas};
let mut response: Hateoas<String> = Hateoas::default();

// Here spec will be None at initialization time.
// at [Response.spec_mut()] Spec will be initialized and returned.

let mut spec = response.spec_mut();
assert_eq!(&mut Content::default(), spec)

impl<T: Serialize + HateoasResource + Default> Hateoas<T>

pub fn CONTINUE(data: Option<T>) -> Self

100 Continue [RFC7231, Section 6.2.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::CONTINUE(Some("Continue".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Continue".to_string())), None, Some(Status::CONTINUE())));

pub fn SWITCHING_PROTOCOLS(data: Option<T>) -> Self

101 Switching Protocols [RFC7231, Section 6.2.2]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::SWITCHING_PROTOCOLS(Some("Switching Protocols".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Switching Protocols".to_string())), None, Some(Status::SWITCHING_PROTOCOLS())));

pub fn PROCESSING(data: Option<T>) -> Self

102 Processing [RFC2518]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PROCESSING(Some("Processing".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Processing".to_string())), None, Some(Status::PROCESSING())));

pub fn OK(data: Option<T>) -> Self

200 OK [RFC7231, Section 6.3.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::OK(Some("OK".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("OK".to_string())), None, Some(Status::OK())));

pub fn CREATED(data: Option<T>) -> Self

201 Created [RFC7231, Section 6.3.2]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::CREATED(Some("Created".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Created".to_string())), None, Some(Status::CREATED())));

pub fn ACCEPTED(data: Option<T>) -> Self

202 Accepted [RFC7231, Section 6.3.3]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::ACCEPTED(Some("Accepted".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Accepted".to_string())), None, Some(Status::ACCEPTED())));

pub fn NON_AUTHORITATIVE_INFORMATION(data: Option<T>) -> Self

203 Non-Authoritative Information [RFC7231, Section 6.3.4]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NON_AUTHORITATIVE_INFORMATION(Some("Non Authoritative Information".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Non Authoritative Information".to_string())), None, Some(Status::NON_AUTHORITATIVE_INFORMATION())));

pub fn NO_CONTENT(data: Option<T>) -> Self

204 No Content [RFC7231, Section 6.3.5]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NO_CONTENT(Some("No Content".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("No Content".to_string())), None, Some(Status::NO_CONTENT())));

pub fn RESET_CONTENT(data: Option<T>) -> Self

205 Reset Content [RFC7231, Section 6.3.6]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::RESET_CONTENT(Some("Reset Content".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Reset Content".to_string())), None, Some(Status::RESET_CONTENT())));

pub fn PARTIAL_CONTENT(data: Option<T>) -> Self

206 Partial Content [RFC7233, Section 4.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PARTIAL_CONTENT(Some("Partial Content".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Partial Content".to_string())), None, Some(Status::PARTIAL_CONTENT())));

pub fn MULTI_STATUS(data: Option<T>) -> Self

207 Multi-Status [RFC4918]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::MULTI_STATUS(Some("Multi-Status".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Multi-Status".to_string())), None, Some(Status::MULTI_STATUS())));

pub fn ALREADY_REPORTED(data: Option<T>) -> Self

208 Already Reported [RFC5842]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::ALREADY_REPORTED(Some("Already Reported".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Already Reported".to_string())), None, Some(Status::ALREADY_REPORTED())));

pub fn IM_USED(data: Option<T>) -> Self

226 IM Used [RFC3229]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::IM_USED(Some("IM Used".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("IM Used".to_string())), None, Some(Status::IM_USED())));

pub fn MULTIPLE_CHOICES(data: Option<T>) -> Self

300 Multiple Choices [RFC7231, Section 6.4.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::MULTIPLE_CHOICES(Some("Multiple Choices".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Multiple Choices".to_string())), None, Some(Status::MULTIPLE_CHOICES())));

pub fn MOVED_PERMANENTLY(data: Option<T>) -> Self

301 Moved Permanently [RFC7231, Section 6.4.2]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::MOVED_PERMANENTLY(Some("Moved Permanently".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Moved Permanently".to_string())), None, Some(Status::MOVED_PERMANENTLY())));

pub fn FOUND(data: Option<T>) -> Self

302 Found [RFC7231, Section 6.4.3]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::FOUND(Some("Found".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Found".to_string())), None, Some(Status::FOUND())));

pub fn SEE_OTHER(data: Option<T>) -> Self

303 See Other [RFC7231, Section 6.4.4]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::SEE_OTHER(Some("See Other".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("See Other".to_string())), None, Some(Status::SEE_OTHER())));

pub fn NOT_MODIFIED(data: Option<T>) -> Self

304 Not Modified [RFC7232, Section 4.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NOT_MODIFIED(Some("Not Modified".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Not Modified".to_string())), None, Some(Status::NOT_MODIFIED())));

pub fn USE_PROXY(data: Option<T>) -> Self

305 Use Proxy [RFC7231, Section 6.4.5]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::USE_PROXY(Some("Use Proxy".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Use Proxy".to_string())), None, Some(Status::USE_PROXY())));

pub fn TEMPORARY_REDIRECT(data: Option<T>) -> Self

307 Temporary Redirect [RFC7231, Section 6.4.7]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::TEMPORARY_REDIRECT(Some("Temporary Redirect".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Temporary Redirect".to_string())), None, Some(Status::TEMPORARY_REDIRECT())));

pub fn PERMANENT_REDIRECT(data: Option<T>) -> Self

308 Permanent Redirect [RFC7238]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PERMANENT_REDIRECT(Some("Permanent Redirect".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Permanent Redirect".to_string())), None, Some(Status::PERMANENT_REDIRECT())));

pub fn BAD_REQUEST(data: Option<T>) -> Self

400 Bad Request [RFC7231, Section 6.5.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::BAD_REQUEST(Some("Bad Request".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Bad Request".to_string())), None, Some(Status::BAD_REQUEST())));

pub fn UNAUTHORIZED(data: Option<T>) -> Self

401 Unauthorized [RFC7235, Section 3.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::UNAUTHORIZED(Some("Unauthorized".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Unauthorized".to_string())), None, Some(Status::UNAUTHORIZED())));

pub fn PAYMENT_REQUIRED(data: Option<T>) -> Self

402 Payment Required [RFC7231, Section 6.5.2]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PAYMENT_REQUIRED(Some("Payment Required".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Payment Required".to_string())), None, Some(Status::PAYMENT_REQUIRED())));

pub fn FORBIDDEN(data: Option<T>) -> Self

403 Forbidden [RFC7231, Section 6.5.3]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::FORBIDDEN(Some("Forbidden".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Forbidden".to_string())), None, Some(Status::FORBIDDEN())));

pub fn NOT_FOUND(data: Option<T>) -> Self

404 Not Found [RFC7231, Section 6.5.4]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NOT_FOUND(Some("Not Found".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Not Found".to_string())), None, Some(Status::NOT_FOUND())));

pub fn METHOD_NOT_ALLOWED(data: Option<T>) -> Self

405 Method Not Allowed [RFC7231, Section 6.5.5]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::METHOD_NOT_ALLOWED(Some("Method Not Allowed".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Method Not Allowed".to_string())), None, Some(Status::METHOD_NOT_ALLOWED())));

pub fn NOT_ACCEPTABLE(data: Option<T>) -> Self

406 Not Acceptable [RFC7231, Section 6.5.6]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NOT_ACCEPTABLE(Some("Not Acceptable".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Not Acceptable".to_string())), None, Some(Status::NOT_ACCEPTABLE())));

pub fn PROXY_AUTHENTICATION_REQUIRED(data: Option<T>) -> Self

407 Proxy Authentication Required [RFC7235, Section 3.2]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PROXY_AUTHENTICATION_REQUIRED(Some("Proxy Authentication Required".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Proxy Authentication Required".to_string())), None, Some(Status::PROXY_AUTHENTICATION_REQUIRED())));

pub fn REQUEST_TIMEOUT(data: Option<T>) -> Self

408 Request Timeout [RFC7231, Section 6.5.7]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::REQUEST_TIMEOUT(Some("Request Timeout".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Request Timeout".to_string())), None, Some(Status::REQUEST_TIMEOUT())));

pub fn CONFLICT(data: Option<T>) -> Self

409 Conflict [RFC7231, Section 6.5.8]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::CONFLICT(Some("Conflict".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Conflict".to_string())), None, Some(Status::CONFLICT())));

pub fn GONE(data: Option<T>) -> Self

410 Gone [RFC7231, Section 6.5.9]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::GONE(Some("Gone".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Gone".to_string())), None, Some(Status::GONE())));

pub fn LENGTH_REQUIRED(data: Option<T>) -> Self

411 Length Required [RFC7231, Section 6.5.10]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::LENGTH_REQUIRED(Some("Length Required".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Length Required".to_string())), None, Some(Status::LENGTH_REQUIRED())));

pub fn PRECONDITION_FAILED(data: Option<T>) -> Self

412 Precondition Failed [RFC7232, Section 4.2]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PRECONDITION_FAILED(Some("Precondition Failed".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Precondition Failed".to_string())), None, Some(Status::PRECONDITION_FAILED())));

pub fn PAYLOAD_TOO_LARGE(data: Option<T>) -> Self

413 Payload Too Large [RFC7231, Section 6.5.11]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PAYLOAD_TOO_LARGE(Some("Payload Too Large".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Payload Too Large".to_string())), None, Some(Status::PAYLOAD_TOO_LARGE())));

pub fn URI_TOO_LONG(data: Option<T>) -> Self

414 URI Too Long [RFC7231, Section 6.5.12]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::URI_TOO_LONG(Some("URI Too Long".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("URI Too Long".to_string())), None, Some(Status::URI_TOO_LONG())));

pub fn UNSUPPORTED_MEDIA_TYPE(data: Option<T>) -> Self

415 Unsupported Media Type [RFC7231, Section 6.5.13]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::UNSUPPORTED_MEDIA_TYPE(Some("Unsupported Media Type".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Unsupported Media Type".to_string())), None, Some(Status::UNSUPPORTED_MEDIA_TYPE())));

pub fn RANGE_NOT_SATISFIABLE(data: Option<T>) -> Self

416 Range Not Satisfiable [RFC7233, Section 4.4]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::RANGE_NOT_SATISFIABLE(Some("Range Not Satisfiable".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Range Not Satisfiable".to_string())), None, Some(Status::RANGE_NOT_SATISFIABLE())));

pub fn EXPECTATION_FAILED(data: Option<T>) -> Self

417 Expectation Failed [RFC7231, Section 6.5.14]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::EXPECTATION_FAILED(Some("Expectation Failed".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Expectation Failed".to_string())), None, Some(Status::EXPECTATION_FAILED())));

pub fn IM_A_TEAPOT(data: Option<T>) -> Self

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

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::IM_A_TEAPOT(Some("I'm a teapot".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("I'm a teapot".to_string())), None, Some(Status::IM_A_TEAPOT())));

pub fn MISDIRECTED_REQUEST(data: Option<T>) -> Self

421 Misdirected Request RFC7540, Section 9.1.2

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::MISDIRECTED_REQUEST(Some("Misdirected Request".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Misdirected Request".to_string())), None, Some(Status::MISDIRECTED_REQUEST())));

pub fn UNPROCESSABLE_ENTITY(data: Option<T>) -> Self

422 Unprocessable Entity [RFC4918]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::UNPROCESSABLE_ENTITY(Some("Unprocessable Entity".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Unprocessable Entity".to_string())), None, Some(Status::UNPROCESSABLE_ENTITY())));

pub fn LOCKED(data: Option<T>) -> Self

423 Locked [RFC4918]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::LOCKED(Some("Locked".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Locked".to_string())), None, Some(Status::LOCKED())));

pub fn FAILED_DEPENDENCY(data: Option<T>) -> Self

424 Failed Dependency [RFC4918]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::FAILED_DEPENDENCY(Some("Failed Dependency".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Failed Dependency".to_string())), None, Some(Status::FAILED_DEPENDENCY())));

pub fn UPGRADE_REQUIRED(data: Option<T>) -> Self

426 Upgrade Required [RFC7231, Section 6.5.15]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::UPGRADE_REQUIRED(Some("Upgrade Required".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Upgrade Required".to_string())), None, Some(Status::UPGRADE_REQUIRED())));

pub fn PRECONDITION_REQUIRED(data: Option<T>) -> Self

428 Precondition Required [RFC6585]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::PRECONDITION_REQUIRED(Some("Precondition Required".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Precondition Required".to_string())), None, Some(Status::PRECONDITION_REQUIRED())));

pub fn TOO_MANY_REQUESTS(data: Option<T>) -> Self

429 Too Many Requests [RFC6585]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::TOO_MANY_REQUESTS(Some("Too Many Requests".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Too Many Requests".to_string())), None, Some(Status::TOO_MANY_REQUESTS())));

pub fn REQUEST_HEADER_FIELDS_TOO_LARGE(data: Option<T>) -> Self

431 Request Header Fields Too Large [RFC6585]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::REQUEST_HEADER_FIELDS_TOO_LARGE(Some("Request Header Fields Too Large".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Request Header Fields Too Large".to_string())), None, Some(Status::REQUEST_HEADER_FIELDS_TOO_LARGE())));

pub fn UNAVAILABLE_FOR_LEGAL_REASONS(data: Option<T>) -> Self

451 Unavailable For Legal Reasons [RFC7725]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::UNAVAILABLE_FOR_LEGAL_REASONS(Some("Unavailable For Legal Reasons".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Unavailable For Legal Reasons".to_string())), None, Some(Status::UNAVAILABLE_FOR_LEGAL_REASONS())));

pub fn INTERNAL_SERVER_ERROR(data: Option<T>) -> Self

500 Internal Server Error [RFC7231, Section 6.6.1]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::INTERNAL_SERVER_ERROR(Some("Internal Server Error".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Internal Server Error".to_string())), None, Some(Status::INTERNAL_SERVER_ERROR())));

pub fn NOT_IMPLEMENTED(data: Option<T>) -> Self

501 Not Implemented [RFC7231, Section 6.6.2]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NOT_IMPLEMENTED(Some("Not Implemented".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Not Implemented".to_string())), None, Some(Status::NOT_IMPLEMENTED())));

pub fn BAD_GATEWAY(data: Option<T>) -> Self

502 Bad Gateway [RFC7231, Section 6.6.3]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::BAD_GATEWAY(Some("Bad Gateway".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Bad Gateway".to_string())), None, Some(Status::BAD_GATEWAY())));

pub fn SERVICE_UNAVAILABLE(data: Option<T>) -> Self

503 Service Unavailable [RFC7231, Section 6.6.4]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::SERVICE_UNAVAILABLE(Some("Service Unavailable".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Service Unavailable".to_string())), None, Some(Status::SERVICE_UNAVAILABLE())));

pub fn GATEWAY_TIMEOUT(data: Option<T>) -> Self

504 Gateway Timeout [RFC7231, Section 6.6.5]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::GATEWAY_TIMEOUT(Some("Gateway Timeout".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Gateway Timeout".to_string())), None, Some(Status::GATEWAY_TIMEOUT())));

pub fn HTTP_VERSION_NOT_SUPPORTED(data: Option<T>) -> Self

505 HTTP Version Not Supported [RFC7231, Section 6.6.6]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::HTTP_VERSION_NOT_SUPPORTED(Some("HTTP Version Not Supported".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("HTTP Version Not Supported".to_string())), None, Some(Status::HTTP_VERSION_NOT_SUPPORTED())));

pub fn VARIANT_ALSO_NEGOTIATES(data: Option<T>) -> Self

506 Variant Also Negotiates [RFC2295]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::VARIANT_ALSO_NEGOTIATES(Some("Variant Also Negotiates".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Variant Also Negotiates".to_string())), None, Some(Status::VARIANT_ALSO_NEGOTIATES())));

pub fn INSUFFICIENT_STORAGE(data: Option<T>) -> Self

507 Insufficient Storage [RFC4918]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::INSUFFICIENT_STORAGE(Some("Insufficient Storage".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Insufficient Storage".to_string())), None, Some(Status::INSUFFICIENT_STORAGE())));

pub fn LOOP_DETECTED(data: Option<T>) -> Self

508 Loop Detected [RFC5842]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::LOOP_DETECTED(Some("Loop Detected".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Loop Detected".to_string())), None, Some(Status::LOOP_DETECTED())));

pub fn NOT_EXTENDED(data: Option<T>) -> Self

510 Not Extended [RFC2774]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NOT_EXTENDED(Some("Not Extended".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Not Extended".to_string())), None, Some(Status::NOT_EXTENDED())));

pub fn NETWORK_AUTHENTICATION_REQUIRED(data: Option<T>) -> Self

511 Network Authentication Required [RFC6585]

use hateoas::{Hateoas,Content,Status};
 
let hateoas: Hateoas<String> = Hateoas::NETWORK_AUTHENTICATION_REQUIRED(Some("Network Authentication Required".to_string()));
 
assert_eq!(hateoas, Hateoas::new(Some(Content::new("Network Authentication Required".to_string())), None, Some(Status::NETWORK_AUTHENTICATION_REQUIRED())));

Trait Implementations

impl<T: Debug + Serialize + HateoasResource> Debug for Hateoas<T>

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

Formats the value using the given formatter.

impl<T: Serialize + HateoasResource> Default for Hateoas<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Hateoas<T>

where T: Deserialize<'de> + Serialize + HateoasResource,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq + Serialize + HateoasResource> PartialEq for Hateoas<T>

fn eq(&self, other: &Hateoas<T>) -> 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<T> Serialize for Hateoas<T>

where T: Serialize + Serialize + HateoasResource,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Serialize + HateoasResource> StructuralPartialEq for Hateoas<T>