Struct vnd_siren::action::Action

pub struct Action {
    pub class: Option<Vec<String>>,
    pub fields: Option<Vec<Field>>,
    pub name: String,
    pub href: String,
    pub method: Option<Method>,
    pub title: Option<String>,
    pub typ: Option<String>,
}

Actions show available behaviors an entity exposes.

Fields

class: Option<Vec<String>>

Describes the nature of an action based on the current representation. Possible values are implementation-dependent and should be documented.

fields: Option<Vec<Field>>

A collection of fields, expressed as an array of objects in JSON Siren such as { "fields" : [{ ... }] }.

name: String

A string that identifies the action to be performed. Action names MUST be unique within the set of actions for an entity. The behavior of clients when parsing a Siren document that violates this constraint is undefined.

href: String

The URI of the action.

method: Option<Method>

An enumerated attribute mapping to a protocol method. For HTTP, these values may be GET, PUT, POST, DELETE, or PATCH. As new methods are introduced, this list can be extended. If this attribute is omitted, GET should be assumed.

title: Option<String>

Descriptive text about the action.

typ: Option<String>

The encoding type for the request. When omitted and the fields attribute exists, the default value is application/x-www-form-urlencoded.

Implementations

impl Action

pub fn builder(name: impl Into<String>, href: impl Into<String>) -> ActionBuilder

Create a Action builder with the given name and href.

Examples

let action = Action::builder("add-item", "http://api.x.io/orders/42/items");

pub fn classes(&self) -> &Option<Vec<String>>

Returns a reference to the Action’s Classes.

Examples

let action: Action = Action::builder("add-item", "http://api.x.io/orders/42/items")
    .classes(vec!["item"]).into();
 
assert_eq!(&Some(vec!["item".to_string()]), action.classes());

pub fn fields(&self) -> &Option<Vec<Field>>

Returns a reference to the Action’s Fields.

Examples

let action: Action = Action::builder("add-item", "http://api.x.io/orders/42/items")
    .fields(vec![
        Field::builder("orderNumber").typ("hidden").value("42"),
        Field::builder("productCode").typ("text"),
        Field::builder("quantity").typ("number"),
    ]).into();
 
assert_eq!(
    &Some(vec![
        Field::builder("orderNumber").typ("hidden").value("42").into(),
        Field::builder("productCode").typ("text").into(),
        Field::builder("quantity").typ("number").into(),
    ]),
    action.fields(),
);

pub fn method(&self) -> &Option<Method>

Returns a reference to the Action’s Method.

Examples

let action: Action = Action::builder("add-item", "http://api.x.io/orders/42/items")
    .method(Method::Post).into();
 
assert_eq!(&Some(Method::Post), action.method());

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

Returns a reference to the Action’s title.

Examples

let action: Action = Action::builder("add-item", "http://api.x.io/orders/42/items")
    .title("Add Item").into();
 
assert_eq!(&Some("Add Item".to_string()), action.title());

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

Returns a reference to the Action’s type.

Examples

let action: Action = Action::builder("add-item", "http://api.x.io/orders/42/items")
    .typ("application/x-www-form-urlencoded").into();
 
assert_eq!(&Some("application/x-www-form-urlencoded".to_string()), action.typ());

Trait Implementations

impl Clone for Action

fn clone(&self) -> Action

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Action

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Action

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ActionBuilder> for Action

fn from(builder: ActionBuilder) -> Action

Converts to this type from the input type.

impl PartialEq<Action> for Action

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Action

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 Action