Struct json_ld::Node

pub struct Node<T = IriBuf, B = BlankIdBuf> {
    pub id: Option<Id<T, B>>,
    pub types: Option<Vec<Id<T, B>>>,
    pub graph: Option<IndexSet<Indexed<Object<T, B>>>>,
    pub included: Option<IndexSet<Indexed<Node<T, B>>>>,
    pub properties: Properties<T, B>,
    pub reverse_properties: Option<ReverseProperties<T, B>>,
}

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).

Fields

id: Option<Id<T, B>>

Identifier.

This is the @id field.

types: Option<Vec<Id<T, B>>>

Types.

This is the @type field.

graph: Option<IndexSet<Indexed<Object<T, B>>>>

Associated graph.

This is the @graph field.

included: Option<IndexSet<Indexed<Node<T, B>>>>

Included nodes.

This is the @included field.

properties: Properties<T, B>

Properties.

Any non-keyword field.

reverse_properties: Option<ReverseProperties<T, B>>

Reverse properties.

This is the @reverse field.

Implementations

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

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

Creates a new empty node.

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

Creates a new empty node with the given id.

pub fn new_graph( id: Id<T, B>, graph: IndexSet<Indexed<Object<T, B>>> ) -> Node<T, B>

Creates a new graph node.

pub fn reverse_properties_mut_or_default( &mut self ) -> &mut ReverseProperties<T, B>

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

If no @reverse entry is present, one is created.

pub fn included_mut_or_default(&mut self) -> &mut IndexSet<Indexed<Node<T, B>>>

Returns a mutable reference to the included nodes.

If no @included entry is present, one is created.

pub fn identify_all_with<V, G>(&mut self, vocabulary: &mut V, generator: &mut G)

where V: Vocabulary<Iri = T, BlankId = B>, G: Generator<V>, 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: Generator, 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) -> &[Id<T, B>]

Get the list of the node’s types.

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

Returns a mutable reference to the node’s types.

pub fn types_mut_or_default(&mut self) -> &mut Vec<Id<T, B>>

pub fn types_mut_or_insert( &mut self, value: Vec<Id<T, B>> ) -> &mut Vec<Id<T, B>>

pub fn types_mut_or_insert_with( &mut self, f: impl FnOnce() -> Vec<Id<T, B>> ) -> &mut Vec<Id<T, B>>

pub fn has_type<U>(&self, ty: &U) -> bool

where 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<&IndexSet<Indexed<Object<T, B>>>>

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

pub fn graph_mut(&mut self) -> Option<&mut IndexSet<Indexed<Object<T, B>>>>

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

pub fn graph_entry(&self) -> Option<&IndexSet<Indexed<Object<T, B>>>>

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

pub fn graph_entry_mut( &mut self ) -> Option<&mut IndexSet<Indexed<Object<T, B>>>>

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

pub fn set_graph_entry( &mut self, graph: Option<IndexSet<Indexed<Object<T, B>>>> )

Set the graph.

pub fn included_entry(&self) -> Option<&IndexSet<Indexed<Node<T, B>>>>

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 IndexSet<Indexed<Node<T, B>>>>

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<&IndexSet<Indexed<Node<T, B>>>>

Returns a reference to the set of @included nodes.

pub fn included_mut(&mut self) -> Option<&mut IndexSet<Indexed<Node<T, B>>>>

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

pub fn set_included(&mut self, included: Option<IndexSet<Indexed<Node<T, B>>>>)

Set the set of nodes included by the node.

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

Returns a reference to the properties of the node.

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

Returns a mutable reference to the properties of the node.

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

Returns a reference to the properties of the node.

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

Returns a reference to the reverse properties of the node.

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

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

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

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<IndexSet<Indexed<Object<T, B>>>, Node<T, B>>

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>

pub fn count(&self, f: impl FnMut(&FragmentRef<'_, T, B>) -> bool) -> usize

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

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

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>

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<&Indexed<Object<T, B>>>

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: Id<T, B>, value: Indexed<Object<T, B>>)

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

pub fn insert_all<Objects>(&mut self, prop: Id<T, B>, values: Objects)

where Objects: Iterator<Item = Indexed<Object<T, B>>>,

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, props: ReverseProperties<T, B> ) -> &mut ReverseProperties<T, B>

pub fn reverse_properties_or_default(&mut self) -> &mut ReverseProperties<T, B>

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

pub fn equivalent(&self, other: &Node<T, B>) -> 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> Any<T, B> for Node<T, B>

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

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

fn language<'a>(&'a self) -> Option<&'a LenientLangTag>

where T: 'a, B: 'a,

fn is_value(&self) -> bool

fn is_node(&self) -> bool

fn is_graph(&self) -> bool

fn is_list(&self) -> bool

impl<T, B> Clone for Node<T, B>

where T: Clone, B: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, B> Debug for Node<T, B>

where T: Debug, B: Debug,

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

Formats the value using the given formatter.

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

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

Returns the “default value” for a type.

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

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

Converts to this type from the input type.

impl<T, B> Hash for Node<T, B>

where T: Hash, B: 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, N> IntoJsonWithContext<N> for Node<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn into_json_with(self, vocabulary: &N) -> Value

impl<T, B, V, I> LinkedData<I, V> for Node<T, B>

where V: Vocabulary<Iri = T> + IriVocabularyMut, I: Interpretation, T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>,

fn visit<S>( &self, visitor: S ) -> Result<<S as Visitor<I, V>>::Ok, <S as Visitor<I, V>>::Error>

where S: Visitor<I, V>,

Visit the RDF dataset represented by this type.

impl<T, B, V, I> LinkedDataGraph<I, V> for Node<T, B>

where V: Vocabulary<Iri = T> + IriVocabularyMut, I: Interpretation, T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>,

fn visit_graph<S>( &self, visitor: S ) -> Result<<S as GraphVisitor<I, V>>::Ok, <S as GraphVisitor<I, V>>::Error>

where S: GraphVisitor<I, V>,

impl<T, B, V, I> LinkedDataPredicateObjects<I, V> for Node<T, B>

where V: Vocabulary<Iri = T> + IriVocabularyMut, I: Interpretation, T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>,

fn visit_objects<S>( &self, visitor: S ) -> Result<<S as PredicateObjectsVisitor<I, V>>::Ok, <S as PredicateObjectsVisitor<I, V>>::Error>

where S: PredicateObjectsVisitor<I, V>,

impl<T, B, V, I> LinkedDataResource<I, V> for Node<T, B>

where V: Vocabulary, I: Interpretation, T: LinkedDataResource<I, V>, B: LinkedDataResource<I, V>,

fn interpretation( &self, vocabulary: &mut V, interpretation: &mut I ) -> ResourceInterpretation<'_, I, V>

fn reference_interpretation( &self, vocabulary: &mut V, interpretation: &mut I ) -> ResourceInterpretation<'_, I, V>

impl<T, B, V, I> LinkedDataSubject<I, V> for Node<T, B>

where V: Vocabulary<Iri = T> + IriVocabularyMut, I: Interpretation, T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>,

fn visit_subject<S>( &self, visitor: S ) -> Result<<S as SubjectVisitor<I, V>>::Ok, <S as SubjectVisitor<I, V>>::Error>

where S: SubjectVisitor<I, V>,

impl<T, B> MappedEq for Node<T, B>

where T: Eq + Hash, B: Eq + Hash,

type BlankId = B

fn mapped_eq<'a, 'b, F>(&'a self, other: &Node<T, B>, f: F) -> bool

where F: Clone + Fn(&'a B) -> &'b B, B: 'a + 'b,

Structural equality with mapped blank identifiers.

impl<T, B> PartialEq for Node<T, B>

where T: Eq + Hash, B: Eq + Hash,

fn eq(&self, other: &Node<T, B>) -> 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, N> PrecomputeSizeWithContext<N> for Node<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

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

impl<T, B, N> PrintWithContext<N> for Node<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn contextual_fmt_with( &self, vocabulary: &N, f: &mut Formatter<'_>, options: &Options, indent: usize ) -> Result<(), Error>

impl<T, B, N> PrintWithSizeAndContext<N> for Node<T, B>

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> Relabel<T, B> for Node<T, B>

fn relabel_with<N, G>( &mut self, vocabulary: &mut N, generator: &mut G, relabeling: &mut HashMap<B, Id<T, B>> )

where N: Vocabulary<Iri = T, BlankId = B>, G: Generator<N>, T: Clone + Eq + Hash, B: Clone + Eq + Hash,

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

type Error = Object<T, B>

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T, B> TryFromJsonObject<T, B> for Node<T, B>

where T: Eq + Hash, B: Eq + Hash,

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

impl<T, B> Eq for Node<T, B>

where T: Eq + Hash, B: Eq + Hash,