Struct json_ld::Node

pub struct Node<T = IriBuf, B = BlankIdBuf, M = ()> { /* private fields */ }

Node object.

A node object represents zero or more properties of a node in the graph serialized by a JSON-LD document. A node is defined by its identifier (@id field), types, properties and reverse properties. In addition, a node may represent a graph (@graph field) and includes nodes (@included field).

Implementations

impl<T, B, M> Node<T, B, M>

pub fn new() -> Node<T, B, M>

Creates a new empty node.

pub fn with_id(id: Entry<Id<T, B>, M>) -> Node<T, B, M>

Creates a new empty node with the given id.

pub fn from_parts(parts: Parts<T, B, M>) -> Node<T, B, M>

pub fn into_parts(self) -> Parts<T, B, M>

pub fn id(&self) -> Option<&Meta<Id<T, B>, M>>

Get the identifier of the node.

This correspond to the @id field of the JSON object.

pub fn id_entry(&self) -> Option<&Entry<Id<T, B>, M>>

Get the identifier of the node.

This correspond to the @id field of the JSON object.

pub fn set_id(&mut self, id: Option<Entry<Id<T, B>, M>>)

Sets the idntifier of this node.

pub fn identify_all_with<V, G>(&mut self, vocabulary: &mut V, generator: &mut G)where
    V: Vocabulary<Iri = T, BlankId = B>,
    G: MetaGenerator<V, M>,
    M: Clone,
    T: Eq + Hash,
    B: Eq + Hash,

Assigns an identifier to this node and every other node included in this one using the given generator.

pub fn identify_all<G>(&mut self, generator: &mut G)where
    G: MetaGenerator<(), M>,
    M: Clone,
    T: Eq + Hash,
    B: Eq + Hash,
    (): Vocabulary<Iri = T, BlankId = B>,

Assigns an identifier to this node and every other node included in this one using the given generator.

pub fn canonicalize_with(&mut self, buffer: &mut Buffer)

Puts this node object literals into canonical form using the given buffer.

The buffer is used to compute the canonical form of numbers.

pub fn canonicalize(&mut self)

Puts this node object literals into canonical form.

pub fn as_iri(&self) -> Option<&T>

Get the node’s as an IRI if possible.

Returns the node’s IRI id if any. Returns None otherwise.

pub fn as_str(&self) -> Option<&str>where
    T: AsRef<str>,

Get the node’s id, is any, as a string slice.

Returns None if the node has no @id field.

pub fn types(&self) -> &[Meta<Id<T, B>, M>]

Get the list of the node’s types.

pub fn types_mut(&mut self) -> &mut [Meta<Id<T, B>, M>]

Returns a mutable reference to the node’s types.

pub fn type_entry_or_default(
    &mut self,
    key_metadata: M,
    value_metadata: M
) -> &mut Entry<Vec<Meta<Id<T, B>, M>, Global>, M>

pub fn type_entry_or_insert(
    &mut self,
    key_metadata: M,
    value: Meta<Vec<Meta<Id<T, B>, M>, Global>, M>
) -> &mut Entry<Vec<Meta<Id<T, B>, M>, Global>, M>

pub fn type_entry_or_insert_with(
    &mut self,
    f: impl FnOnce() -> Entry<Vec<Meta<Id<T, B>, M>, Global>, M>
) -> &mut Entry<Vec<Meta<Id<T, B>, M>, Global>, M>

pub fn type_entry(&self) -> Option<&Entry<Vec<Meta<Id<T, B>, M>, Global>, M>>

pub fn set_type_entry(
    &mut self,
    entry: Option<Entry<Vec<Meta<Id<T, B>, M>, Global>, M>>
)

pub fn has_type<U>(&self, ty: &U) -> boolwhere
    Id<T, B>: PartialEq<U>,

Checks if the node has the given type.

pub fn is_empty(&self) -> bool

Tests if the node is empty.

It is empty is every field other than @id is empty.

pub fn is_graph(&self) -> bool

Tests if the node is a graph object (has a @graph field, and optionally an @id field). Note that node objects may have a @graph entry, but are not considered graph objects if they include any other entries other than @id.

pub fn is_simple_graph(&self) -> bool

Tests if the node is a simple graph object (a graph object without @id field)

pub fn graph(
    &self
) -> Option<&Meta<HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>, RandomState>, M>>

If the node is a graph object, get the graph.

pub fn graph_mut(
    &mut self
) -> Option<&mut Meta<HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>, RandomState>, M>>

If the node is a graph object, get the mutable graph.

pub fn graph_entry(
    &self
) -> Option<&Entry<HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>, RandomState>, M>>

If the node is a graph object, get the graph.

pub fn graph_entry_mut(
    &mut self
) -> Option<&mut Entry<HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>, RandomState>, M>>

If the node is a graph object, get the mutable graph.

pub fn set_graph(
    &mut self,
    graph: Option<Entry<HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>, RandomState>, M>>
)

Set the graph.

pub fn included_entry(
    &self
) -> Option<&Entry<HashSet<Stripped<Meta<Indexed<Node<T, B, M>, M>, M>>, RandomState>, M>>

Get the set of nodes included by this node.

This correspond to the @included field in the JSON representation.

pub fn included_entry_mut(
    &mut self
) -> Option<&mut Entry<HashSet<Stripped<Meta<Indexed<Node<T, B, M>, M>, M>>, RandomState>, M>>

Get the mutable set of nodes included by this node.

This correspond to the @included field in the JSON representation.

pub fn included(
    &self
) -> Option<&Meta<HashSet<Stripped<Meta<Indexed<Node<T, B, M>, M>, M>>, RandomState>, M>>

Returns a reference to the set of @included nodes.

pub fn included_mut(
    &mut self
) -> Option<&mut Meta<HashSet<Stripped<Meta<Indexed<Node<T, B, M>, M>, M>>, RandomState>, M>>

Returns a mutable reference to the set of @included nodes.

pub fn set_included(
    &mut self,
    included: Option<Entry<HashSet<Stripped<Meta<Indexed<Node<T, B, M>, M>, M>>, RandomState>, M>>
)

Set the set of nodes included by the node.

pub fn properties(&self) -> &Properties<T, B, M>

Returns a reference to the properties of the node.

pub fn properties_mut(&mut self) -> &mut Properties<T, B, M>

Returns a mutable reference to the properties of the node.

pub fn reverse_properties(&self) -> Option<&Meta<ReverseProperties<T, B, M>, M>>

Returns a reference to the properties of the node.

pub fn reverse_properties_entry(
    &self
) -> Option<&Entry<ReverseProperties<T, B, M>, M>>

Returns a reference to the reverse properties of the node.

pub fn reverse_properties_mut(
    &mut self
) -> Option<&mut Entry<ReverseProperties<T, B, M>, M>>

Returns a mutable reference to the reverse properties of the node.

pub fn set_reverse_properties(
    &mut self,
    reverse_properties: Option<Entry<ReverseProperties<T, B, M>, M>>
)

pub fn is_unnamed_graph(&self) -> bool

Tests if the node is an unnamed graph object.

Returns true is the only field of the object is a @graph field. Returns false otherwise.

pub fn into_unnamed_graph(
    self
) -> Result<Entry<HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>, RandomState>, M>, Node<T, B, M>>

Returns the node as an unnamed graph, if it is one.

The unnamed graph is returned as a set of indexed objects. Fails and returns itself if the node is not an unnamed graph.

pub fn traverse(&self) -> Traverse<'_, T, B, M>

pub fn entries(&self) -> Entries<'_, T, B, M>

impl<T, B, M> Node<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,

pub fn has_key(&self, key: &Term<T, B>) -> bool

Checks if the node object has the given term as key.

Example

// Checks if the JSON object representation of the node has an `@id` key.
if node.has_key(&Term::Keyword(Keyword::Id)) {
  // ...
}

pub fn get<'a, Q>(&self, prop: &Q) -> Objects<'_, T, B, M> where
    Q: Hash + Equivalent<Id<T, B>> + ?Sized,
    T: 'a,

Get all the objects associated to the node with the given property.

pub fn get_any<'a, Q>(
    &self,
    prop: &Q
) -> Option<&Meta<Indexed<Object<T, B, M>, M>, M>>where
    Q: Hash + Equivalent<Id<T, B>> + ?Sized,
    T: 'a,

Get one of the objects associated to the node with the given property.

If multiple objects are attached to the node with this property, there are no guaranties on which object will be returned.

pub fn insert(
    &mut self,
    prop: Meta<Id<T, B>, M>,
    value: Meta<Indexed<Object<T, B, M>, M>, M>
)

Associates the given object to the node through the given property.

pub fn insert_all<Objects>(&mut self, prop: Meta<Id<T, B>, M>, values: Objects)where
    Objects: Iterator<Item = Meta<Indexed<Object<T, B, M>, M>, M>>,

Associates all the given objects to the node through the given property.

If there already exists objects associated to the given reverse property, reverse_value is added to the list. Duplicate objects are not removed.

pub fn reverse_properties_or_insert(
    &mut self,
    key_metadata: M,
    props: Meta<ReverseProperties<T, B, M>, M>
) -> &mut Entry<ReverseProperties<T, B, M>, M>

pub fn reverse_properties_or_default(
    &mut self,
    key_metadata: M,
    value_metadata: M
) -> &mut Entry<ReverseProperties<T, B, M>, M>

pub fn reverse_properties_or_insert_with(
    &mut self,
    f: impl FnOnce() -> Entry<ReverseProperties<T, B, M>, M>
) -> &mut Entry<ReverseProperties<T, B, M>, M>

pub fn equivalent(&self, other: &Node<T, B, M>) -> bool

Equivalence operator.

Equivalence is different from equality for anonymous objects. Anonymous node objects have an implicit unlabeled blank nodes and thus never equivalent.

Trait Implementations

impl<T, B, M> Any<T, B, M> for Node<T, B, M>

fn as_ref(&self) -> Ref<'_, T, B, M>

fn id_entry<'a>(&'a self) -> Option<&'a Entry<Id<T, B>, M>>where
    M: 'a,

fn id<'a>(&'a self) -> Option<&'a Meta<Id<T, B>, M>>where
    M: 'a,

fn language<'a>(&'a self) -> Option<LenientLanguageTag<'a>>where
    T: 'a,
    B: 'a,
    M: 'a,

fn is_value(&self) -> bool

fn is_node(&self) -> bool

fn is_graph(&self) -> bool

fn is_list(&self) -> bool

impl<T, B, M> Clone for Node<T, B, M>where
    T: Clone,
    B: Clone,
    M: Clone,

fn clone(&self) -> Node<T, B, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, B, M> Default for Node<T, B, M>

fn default() -> Node<T, B, M>

Returns the “default value” for a type.

impl<T, B, M> From<Node<T, B, M>> for Object<T, B, M>

fn from(node: Node<T, B, M>) -> Object<T, B, M>

Converts to this type from the input type.

impl<T, B, M> Hash for Node<T, B, M>where
    T: Hash,
    B: Hash,
    M: Hash,

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

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<T, B, M, N> IntoJsonWithContextMeta<M, N> for Node<T, B, M>where
    M: Clone,
    N: Vocabulary<Iri = T, BlankId = B>,

fn into_json_meta_with(self, meta: M, vocabulary: &N) -> Meta<Value<M>, M>

impl<T, B, M> MappedEq<Node<T, B, M>> for Node<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,

type BlankId = B

fn mapped_eq<'a, 'b, F>(&'a self, other: &Node<T, B, M>, f: F) -> boolwhere
    F: Clone + Fn(&'a B) -> &'b B,
    B: 'a + 'b,

Structural equality with mapped blank identifiers.

impl<T, B, M> PartialEq<Node<T, B, M>> for Node<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,
    M: PartialEq<M>,

fn eq(&self, other: &Node<T, B, M>) -> 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<T, B, M, N> PrecomputeSizeWithContext<N> for Node<T, B, M>where
    N: Vocabulary<Iri = T, BlankId = B>,

fn contextual_pre_compute_size(
    &self,
    vocabulary: &N,
    options: &Options,
    sizes: &mut Vec<Size, Global>
) -> Size

impl<T, B, M, N> PrintWithSizeAndContext<N> for Node<T, B, M>where
    N: Vocabulary<Iri = T, BlankId = B>,

fn contextual_fmt_with_size(
    &self,
    vocabulary: &N,
    f: &mut Formatter<'_>,
    options: &Options,
    indent: usize,
    sizes: &[Size],
    index: &mut usize
) -> Result<(), Error>

impl<T, B, M> Relabel<T, B, M> for Node<T, B, M>

fn relabel_with<N, G>(
    &mut self,
    vocabulary: &mut N,
    generator: &mut G,
    relabeling: &mut HashMap<B, Meta<Subject<T, B>, M>, BuildHasherDefault<AHasher>, Global>
)where
    N: Vocabulary<Iri = T, BlankId = B>,
    G: MetaGenerator<N, M>,
    M: Clone,
    T: Clone + Eq + Hash,
    B: Clone + Eq + Hash,

impl<T, B, M> StrippedHash for Node<T, B, M>where
    T: Hash,
    B: Hash,

fn stripped_hash<H>(&self, h: &mut H)where
    H: Hasher,

impl<T, B, M> StrippedPartialEq<Node<T, B, M>> for Node<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,

fn stripped_eq(&self, other: &Node<T, B, M>) -> bool

impl<T, B, M> TryFrom<Object<T, B, M>> for Node<T, B, M>

type Error = Object<T, B, M>

The type returned in the event of a conversion error.

fn try_from(obj: Object<T, B, M>) -> Result<Node<T, B, M>, Object<T, B, M>>

Performs the conversion.

impl<T, B, M> TryFromJsonObject<T, B, M> for Node<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,

fn try_from_json_object_in(
    vocabulary: &mut impl VocabularyMut<Iri = T, BlankId = B>,
    object: Meta<Object<M>, M>
) -> Result<Meta<Node<T, B, M>, M>, Meta<InvalidExpandedJson<M>, M>>

impl<T, B, M> Eq for Node<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,
    M: Eq,

impl<T, B, M> StrippedEq for Node<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,