Struct Object

pub struct Object {
    pub attributes: Map,
    pub id: String,
    pub kind: Key,
    pub links: Map<Key, Link>,
    pub meta: Map,
    pub relationships: Map<Key, Relationship>,
    /* private fields */
}

A preexisting resource. Commonly found in the document of a response or PATCH request.

Both the id and type field must be present if an Object is deserialized. If you need to represent a resource object that does not already have an id, you can use NewObject. For more information, check out the resource objects section of the JSON API specification.

Equality

Objects are considered to be equal if they have the same id and kind.

use json_api::doc::Object;
use json_api::value::Key;

let person = "person".parse::<Key>()?;
let hero = "hero".parse::<Key>()?;

let mut bruce = Object::new(person.clone(), "🦇".to_owned());
let mut batman = Object::new(person.clone(), "🦇".to_owned());

bruce.attributes.insert("name".parse()?, "Bruce Wayne".into());
batman.attributes.insert("name".parse()?, "Batman".into());

// Bruce and Batman are equal because they have the same `id` and `kind`.
assert!(bruce == batman);

// Let's make Batman a "hero" instead of a "person".
batman.kind = hero.clone();

// Bruce and Batman are no longer equal.
assert!(bruce != batman);

Since an Identifier is a subset of Object with fields necessary for identification, you can compare the two.

use json_api::doc::Identifier;
assert!(Identifier::from(&batman) == batman);

Hashing

Similar to how equality works, object’s are hashed by their id and kind. This allows for easy and efficient deduplication when embedding related resources in a response.

Note: The following example is to demonstrate how object’s are hashed. Deduplication occurs automatically if you use the json_api::to_doc function with a Resource that was implemented with the resource! macro.

use json_api::doc::Object;
use json_api::value::{Key, Set};

let person = "person".parse::<Key>()?;
let hero = "hero".parse::<Key>()?;

let mut included = Set::new();

let mut diana = Object::new(person.clone(), "🛡".to_owned());
let mut wonder_woman = Object::new(person.clone(), "🛡".to_owned());

diana.attributes.insert("name".parse()?, "Diana Prince".into());
wonder_woman.attributes.insert("name".parse()?, "Wonder Woman".into());

included.insert(diana);
assert_eq!(included.len(), 1);

included.insert(wonder_woman.clone());
assert_eq!(included.len(), 1);

// Let's update Wonder Woman's kind to "hero" so we can embed her in the response.
wonder_woman.kind = hero.clone();

included.insert(wonder_woman.clone());
assert_eq!(included.len(), 2);

Fields

attributes: Map

Contains some of the object’s data. If this value of this field is empty, it will not be serialized. For more information, check out the attributes section of the JSON API specification.

id: String

A string that contains a unique identfier for this resource type (kind). For more information, check out the identification section of the JSON API specification.

kind: Key

Describes resources that share common attributes and relationships. This field is derived from the type field if the object is deserialized. For more information, check out the identification section of the JSON API specification.

links: Map<Key, Link>

Contains relevant links. If this value of this field is empty, it will not be serialized. For more information, check out the links section of the JSON API specification.

meta: Map

Non-standard meta information. If this value of this field is empty, it will not be serialized. For more information, check out the meta information section of the JSON API specification.

relationships: Map<Key, Relationship>

Describes relationships between this object and other resource objects. If this value of this field is empty, it will not be serialized. For more information, check out the relationships section of the JSON API specification.

Implementations

impl Object

pub fn new(kind: Key, id: String) -> Self

Returns a new Object.

Example

use json_api::doc::Object;
let mut obj = Object::new("users".parse()?, "1".to_owned());

Trait Implementations

impl Clone for Object

fn clone(&self) -> Object

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Object

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Object

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a Object> for Identifier

fn from(object: &'a Object) -> Self

Converts to this type from the input type.

impl From<Object> for Identifier

fn from(object: Object) -> Self

Converts to this type from the input type.

impl Hash for Object

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Identifier> for Object

fn eq(&self, rhs: &Identifier) -> 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 PartialEq<Object> for Identifier

fn eq(&self, rhs: &Object) -> 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 PartialEq for Object

fn eq(&self, rhs: &Object) -> 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 Render<Identifier> for Object

fn render(self, query: Option<&Query>) -> Result<Document<Identifier>, Error>

Attempts to render the given type as a document.

impl<'a, T: Resource> Render<Object> for &'a [T]

fn render(self, query: Option<&Query>) -> Result<Document<Object>, Error>

Attempts to render the given type as a document.

impl<'a, T: Resource> Render<Object> for &'a T

fn render(self, query: Option<&Query>) -> Result<Document<Object>, Error>

Attempts to render the given type as a document.

impl Render<Object> for Object

fn render(self, _: Option<&Query>) -> Result<Document<Object>, Error>

Attempts to render the given type as a document.

impl Render<Object> for Vec<Object>

fn render(self, _: Option<&Query>) -> Result<Document<Object>, Error>

Attempts to render the given type as a document.

impl Serialize for Object

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Object

impl PrimaryData for Object