Struct RelLink 

pub struct RelLink { /* private fields */ }

Implementations

impl RelLink

pub fn new(rel: &str, href: &str, method: HttpMethod) -> Self

Constructs a new RelLink

use hateoas::{HttpMethod, RelLink};

let rel = RelLink::new( "somewhere_obj","/somewhere/", HttpMethod::Get);
let validate = ("somewhere_obj", "/somewhere/", HttpMethod::Get).into();

assert_eq!(rel, validate);

pub fn href(&self) -> &str

Getter for href

use hateoas::{HttpMethod, RelLink};

let rel = RelLink::new( "somewhere_obj","/somewhere/", HttpMethod::Get);

assert_eq!(rel.href(), "/somewhere/");

pub fn href_mut(&mut self) -> &mut String

Getter/Setter for href

use hateoas::{HttpMethod, RelLink};

let mut rel = RelLink::new( "somewhere_obj","/somewhere/", HttpMethod::Get);

*(rel.href_mut()) = "/somewhere_else/".to_string();

assert_eq!(rel.href(), "/somewhere_else/");

pub fn rel(&self) -> &str

Getter for rel

use hateoas::{HttpMethod, RelLink};

let mut rel = RelLink::new( "somewhere_obj","/somewhere/", HttpMethod::Get);
   ///
assert_eq!(rel.rel(), "somewhere_obj");

pub fn rel_mut(&mut self) -> &mut String

Getter/Setter for rel

use hateoas::{HttpMethod, RelLink};

let mut rel = RelLink::new( "somewhere_obj","/somewhere/", HttpMethod::Get);

*(rel.rel_mut()) =  "somewhere_obj_2".to_string();

assert_eq!(rel.rel(),  "somewhere_obj_2");

pub fn method(&self) -> &HttpMethod

Getter for method

use hateoas::{HttpMethod, RelLink};

let mut rel = RelLink::new( "somewhere_obj","/somewhere/", HttpMethod::Get);    ///

assert_eq!(rel.method(), &HttpMethod::Get);

pub fn method_mut(&mut self) -> &mut HttpMethod

Getter/Setter for rel

use hateoas::{HttpMethod, RelLink};

let mut rel = RelLink::new( "somewhere_obj","/somewhere/", HttpMethod::Get);

*(rel.method_mut()) = HttpMethod::Connect;

assert_eq!(rel.method(),  &HttpMethod::Connect);

impl RelLink

pub fn GET(rel: &str, href: &str) -> RelLink

The GET method requests a representation of the specified resource. Requests using GET should only retrieve data.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::GET("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Get));

pub fn HEAD(rel: &str, href: &str) -> RelLink

The HEAD method asks for a response identical to a GET request, but without the response body.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::HEAD("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Head));

pub fn POST(rel: &str, href: &str) -> RelLink

The POST method submits an entity to the specified resource, often causing a change in state or side effects on the server.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::POST("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Post));

pub fn PUT(rel: &str, href: &str) -> RelLink

The PUT method replaces all current representations of the target resource with the request payload.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::PUT("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Put));

pub fn DELETE(rel: &str, href: &str) -> RelLink

The DELETE method deletes the specified resource.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::DELETE("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Delete));

pub fn CONNECT(rel: &str, href: &str) -> RelLink

The CONNECT method establishes a tunnel to the server identified by the target resource.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::CONNECT("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Connect));

pub fn OPTIONS(rel: &str, href: &str) -> RelLink

The OPTIONS method describes the communication options for the target resource.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::OPTIONS("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Options));

pub fn TRACE(rel: &str, href: &str) -> RelLink

The TRACE method performs a message loop-back test along the path to the target resource.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::TRACE("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Trace));

pub fn PATCH(rel: &str, href: &str) -> RelLink

The PATCH method applies partial modifications to a resource.

use hateoas::{HttpMethod, RelLink};
 
let rel = RelLink::PATCH("object", "/path/to/objects");
 
assert_eq!(rel, RelLink::new("object", "/path/to/objects", HttpMethod::Patch));

Trait Implementations

impl Clone for RelLink

fn clone(&self) -> RelLink

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RelLink

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RelLink

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<(&str, &str, HttpMethod)> for RelLink

fn from(r: (&str, &str, HttpMethod)) -> Self

Converts to this type from the input type.

impl From<(String, String, HttpMethod)> for RelLink

fn from(r: (String, String, HttpMethod)) -> Self

Converts to this type from the input type.

impl PartialEq for RelLink

fn eq(&self, other: &RelLink) -> 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 RelLink

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 RelLink