Struct ExpandedDocument 

pub struct ExpandedDocument<T = IriBuf, B = BlankIdBuf> { /* private fields */ }

Result of the document expansion algorithm: a set of (indexed) objects.

Objects are kept in insertion order, and deduplicated through an index of discriminant buckets (shallow per-object keys) rather than by hashing each object in full.

Implementations

impl<T, B> ExpandedDocument<T, B>

pub fn new() -> Self

Creates a new ExpandedDocument.

pub fn with_capacity(capacity: usize) -> Self

Creates a new ExpandedDocument with room for capacity objects.

Worth reaching for whenever the object count is known up front: growing the set re-hashes every object already in it, and hashing an object walks its whole subtree.

pub fn len(&self) -> usize

Returns the number of top-level objects in the document.

pub fn is_empty(&self) -> bool

Checks whether the document has no top-level objects.

pub fn objects(&self) -> &[IndexedObject<T, B>]

Returns the top-level objects of the document, in insertion order.

pub fn into_objects(self) -> Vec<IndexedObject<T, B>>

Consumes the document, returning its top-level objects in insertion order.

pub fn iter(&self) -> Iter<'_, IndexedObject<T, B>>

Returns an iterator over the top-level objects of the document, in insertion order.

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

Returns an iterator that visits every fragment of the document: each top-level object and, recursively, everything it contains.

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

Counts the fragments of the document matching the given predicate.

pub fn identify_all_with<V: VocabularyMut<Iri = T, BlankId = B>, G: LocalGenerator>( &mut self, vocabulary: &mut V, generator: &mut G, ) -> Result<(), GeneratedIdError>

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

Gives an identifier (@id) to every node, using the given generator to create fresh identifiers for anonymous nodes.

Errors

Returns an error when the generator runs out of identifiers.

pub fn identify_all<G: LocalGenerator>( &mut self, generator: &mut G, ) -> Result<(), GeneratedIdError>

where T: Eq + Hash, B: Eq + Hash, (): Vocabulary<Iri = T, BlankId = B>,

Gives an identifier (@id) to every node, using the given generator to create fresh identifiers for anonymous nodes.

Errors

Returns an error when the generator runs out of identifiers.

pub fn relabel_and_canonicalize_with<V: VocabularyMut<Iri = T, BlankId = B>, G: LocalGenerator>( &mut self, vocabulary: &mut V, generator: &mut G, ) -> Result<(), GeneratedIdError>

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

Relabels every node identifier with a fresh one from the given generator and puts every literal into canonical form.

Errors

Returns an error when the generator runs out of identifiers.

pub fn relabel_and_canonicalize<G: LocalGenerator>( &mut self, generator: &mut G, ) -> Result<(), GeneratedIdError>

where T: Clone + Eq + Hash, B: Clone + Eq + Hash, (): Vocabulary<Iri = T, BlankId = B>,

Relabels every node identifier with a fresh one from the given generator and puts every literal into canonical form.

Errors

Returns an error when the generator runs out of identifiers.

pub fn relabel_with<V: VocabularyMut<Iri = T, BlankId = B>, G: LocalGenerator>( &mut self, vocabulary: &mut V, generator: &mut G, ) -> Result<(), GeneratedIdError>

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

Relabels every node identifier with a fresh one from the given generator.

Errors

Returns an error when the generator runs out of identifiers.

pub fn relabel<G: LocalGenerator>( &mut self, generator: &mut G, ) -> Result<(), GeneratedIdError>

where T: Clone + Eq + Hash, B: Clone + Eq + Hash, (): Vocabulary<Iri = T, BlankId = B>,

Relabels every node identifier with a fresh one from the given generator.

Errors

Returns an error when the generator runs out of identifiers.

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

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

Puts every literal of the document into canonical form, using the given buffer to render numbers.

pub fn canonicalize(&mut self)

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

Puts every literal of the document into canonical form.

pub fn map_ids<U, C>( self, map_iri: impl FnMut(T) -> U, map_id: impl FnMut(Id<T, B>) -> Id<U, C>, ) -> ExpandedDocument<U, C>

where U: Eq + Hash, C: Eq + Hash,

Rewrites every IRI and identifier of the document (recursively) with the given functions.

pub fn blank_ids(&self) -> HashSet<&B>

where B: Eq + Hash,

Returns the set of all blank identifiers in the given document.

pub fn main_node(&self) -> Option<&Node<T, B>>

Returns the main node object of the document, if any.

The main node is the unique top level (root) node object. If multiple node objects are on the root, None is returned.

pub fn into_main_node(self) -> Option<Node<T, B>>

Consumes the document and returns its main node object, if any.

The main node is the unique top level (root) node object. If multiple node objects are on the root, None is returned.

impl<T: Hash + Eq, B: Hash + Eq> ExpandedDocument<T, B>

pub fn insert(&mut self, object: IndexedObject<T, B>) -> bool

Inserts an object, unless an equal one is already present.

Returns true if the object was added.

pub fn contains(&self, object: &IndexedObject<T, B>) -> bool

Checks whether an equal object is present.

impl<T: Eq + Hash, B: Eq + Hash> ExpandedDocument<T, B>

pub fn try_from_json_slice_in( vocabulary: &mut impl VocabularyMut<Iri = T, BlankId = B>, bytes: &[u8], ) -> Result<Self, ExpandedJsonTextError>

Reads a document already in expanded form from its JSON text, without running the Expansion algorithm: the bytes are parsed with jstrict’s non-recursive parser and read with TryFromJson. The parsed tree is consumed by the reading, so no JSON tree outlives the call.

Errors

ExpandedJsonTextError::Syntax when bytes is not JSON, and ExpandedJsonTextError::Invalid for a JSON text that is not expanded JSON-LD.

impl<T, B> ExpandedDocument<T, B>

pub fn into_serde_json_with<N>(self, vocabulary: &N) -> Value

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

Available on crate feature serde-json only.

Converts the expanded document into a serde_json::Value using the given vocabulary.

impl<T, B> ExpandedDocument<T, B>

where (): Vocabulary<Iri = T, BlankId = B>,

pub fn into_serde_json(self) -> Value

Available on crate feature serde-json only.

Converts the expanded document into a serde_json::Value using the default no-vocabulary.

impl<T, B> ExpandedDocument<T, B>

pub fn into_sonic_rs_with<N>(self, vocabulary: &N) -> Value

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

Available on crate feature sonic-rs only.

Converts the expanded document into a sonic_rs::Value using the given vocabulary.

impl<T, B> ExpandedDocument<T, B>

where (): Vocabulary<Iri = T, BlankId = B>,

pub fn into_sonic_rs(self) -> Value

Available on crate feature sonic-rs only.

Converts the expanded document into a sonic_rs::Value using the default no-vocabulary.

impl<T: Clone + Eq + Hash, B: Clone + Eq + Hash> ExpandedDocument<T, B>

pub fn generate_node_map_with<V: VocabularyMut<Iri = T, BlankId = B>, G: LocalGenerator>( &self, vocabulary: &mut V, generator: G, ) -> Result<NodeMap<T, B>, NodeMapError<T, B>>

Builds the node map of this document using the given vocabulary and blank node generator.

Errors

Returns an error when the generator runs out of identifiers, or when two nodes disagree on an @index.

impl<I, B> ExpandedDocument<I, B>

pub fn from_interpreted_quads_in<'a, V, T>( vocabulary: &V, interpretation: &T, quads: impl IntoIterator<Item = Quad<&'a T::Resource, &'a T::Resource, &'a T::Resource, &'a T::Resource>>, context: Context<'_, T>, ) -> Result<Self, SerializationError>

where V: Vocabulary<Iri = I, BlankId = B>, T: ReverseTermInterpretation<Iri = I, BlankId = B, Literal = V::Literal> + ReverseInterpretation, T::Resource: 'a + Ord + Hash, I: Clone + Eq + Hash, B: Clone + Eq + Hash,

Builds a document from interpreted RDF quads, using the given vocabulary and interpretation.

Errors

Returns an error when the dataset cannot be expressed as JSON-LD, for instance a literal whose datatype has no IRI in the vocabulary.

pub fn from_interpreted_quads<'a, V, T>( vocabulary: &V, interpretation: &T, quads: impl IntoIterator<Item = Quad<&'a T::Resource, &'a T::Resource, &'a T::Resource, &'a T::Resource>>, ) -> Result<Self, SerializationError>

where V: Vocabulary<Iri = I, BlankId = B>, T: ReverseTermInterpretation<Iri = I, BlankId = B, Literal = V::Literal> + ReverseInterpretation, T::Resource: 'a + Ord + Hash, I: Clone + Eq + Hash, B: Clone + Eq + Hash,

Builds a document from interpreted RDF quads.

Errors

Returns an error when the dataset cannot be expressed as JSON-LD.

Trait Implementations

impl<I, B> Borrow<ExpandedDocument<I, B>> for Document<I, B>

fn borrow(&self) -> &ExpandedDocument<I, B>

Immutably borrows from an owned value.

impl<T: Clone, B: Clone> Clone for ExpandedDocument<T, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, B: Debug> Debug for ExpandedDocument<T, B>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<T: Eq + Hash, B: Eq + Hash> Eq for ExpandedDocument<T, B>

impl<T: Hash + Eq, B: Hash + Eq> Extend<Indexed<Object<T, B>>> for ExpandedDocument<T, B>

fn extend<I: IntoIterator<Item = IndexedObject<T, B>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<I: Clone + Eq + Hash, B: Clone + Eq + Hash> Flatten<I, B> for ExpandedDocument<I, B>

fn flatten_with<V, G: LocalGenerator>( self, vocabulary: &mut V, generator: G, ordered: bool, ) -> FlattenResult<I, B>

where V: Vocabulary<Iri = I, BlankId = B> + VocabularyMut,

Flattens this document using the given vocabulary and blank node generator.

fn flatten_unordered_with<V, G: LocalGenerator>( self, vocabulary: &mut V, generator: G, ) -> FlattenUnorderedResult<I, B>

where V: Vocabulary<Iri = I, BlankId = B> + VocabularyMut,

Flattens this document into an unordered set, using the given vocabulary and generator.

fn flatten<G: LocalGenerator>( self, generator: G, ordered: bool, ) -> FlattenResult<I, B>

where (): Vocabulary<Iri = I, BlankId = B>, Self: Sized,

Flattens this document, sorting the result when ordered is set.

fn flatten_unordered<G: LocalGenerator>( self, generator: G, ) -> FlattenUnorderedResult<I, B>

where (): Vocabulary<Iri = I, BlankId = B>, Self: Sized,

Flattens this document into an unordered set.

impl<T: Hash + Eq, B: Hash + Eq> From<IndexSet<Indexed<Object<T, B>>, GxBuildHasher>> for ExpandedDocument<T, B>

fn from(set: IndexSet<IndexedObject<T, B>>) -> Self

Converts to this type from the input type.

impl<T: Eq + Hash, B: Eq + Hash> From<Indexed<Node<T, B>>> for ExpandedDocument<T, B>

fn from(value: Indexed<Node<T, B>>) -> Self

Converts to this type from the input type.

impl<T: Hash + Eq, B: Hash + Eq> From<Vec<Indexed<Object<T, B>>>> for ExpandedDocument<T, B>

fn from(items: Vec<IndexedObject<T, B>>) -> Self

Converts to this type from the input type.

impl<T: Hash + Eq, B: Hash + Eq> FromIterator<Indexed<Object<T, B>>> for ExpandedDocument<T, B>

fn from_iter<I: IntoIterator<Item = IndexedObject<T, B>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, B> IntoIterator for ExpandedDocument<T, B>

type IntoIter = IntoIter<T, B>

Which kind of iterator are we turning this into?

type Item = Indexed<Object<T, B>>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, B> IntoIterator for &'a ExpandedDocument<T, B>

type IntoIter = Iter<'a, Indexed<Object<T, B>>>

Which kind of iterator are we turning this into?

type Item = &'a Indexed<Object<T, B>>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, B, N: Vocabulary<Iri = T, BlankId = B>> IntoJsonWithContext<N> for ExpandedDocument<T, B>

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

Writes the document as expanded JSON-LD: an array of the document’s objects, in insertion order. Recurses once per nesting level on sufficient native stack.

impl<T, B> LdQuads<T, B> for ExpandedDocument<T, B>

fn quads(&self) -> Quads<'_, T, B>

Returns an iterator over the quads of the document.

impl<T, B, I: Interpretation> LinkedData<I> for ExpandedDocument<T, B>

where T: LinkedDataResource<I> + LinkedDataSubject<I>, B: LinkedDataResource<I> + LinkedDataSubject<I>,

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

where S: Visitor<I>,

Visit the RDF dataset represented by this type.

impl<T, B, I: Interpretation> LinkedDataGraph<I> for ExpandedDocument<T, B>

where T: LinkedDataResource<I> + LinkedDataSubject<I>, B: LinkedDataResource<I> + LinkedDataSubject<I>,

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

where S: GraphVisitor<I>,

Visits the subjects of the graph represented by this value.

impl<T: Eq + Hash, B: Eq + Hash> PartialEq for ExpandedDocument<T, B>

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

Comparison between two expanded documents.

Order-independent, as it was when this was backed by a set: both sides are deduplicated, so equal lengths plus containment one way is enough.

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

Inequality operator !=.

impl<T, B, N: Vocabulary<Iri = T, BlankId = B>> PrecomputeSizeWithContext<N> for ExpandedDocument<T, B>

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

Computes the printed size of this value against context.

impl<T, B, N: Vocabulary<Iri = T, BlankId = B>> PrintWithContext<N> for ExpandedDocument<T, B>

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

Writes the value to f, resolving it against context.

impl<T, B, N: Vocabulary<Iri = T, BlankId = B>> PrintWithSizeAndContext<N> for ExpandedDocument<T, B>

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

Writes the value to f against context, taking its layout from sizes[*index].

impl<T, B> RdfQuads<T, B> for ExpandedDocument<T, B>

fn rdf_quads_full<'a, V: Vocabulary<Iri = T, BlankId = B>, G: LocalGenerator>( &'a self, vocabulary: &'a mut V, generator: &'a mut G, rdf_direction: Option<RdfDirection>, produce_generalized_rdf: bool, ) -> Quads<'a, V, G>

Returns the RDF quads of this document, taking every parameter explicitly.

fn rdf_quads_with<'a, V: Vocabulary<Iri = T, BlankId = B>, G: LocalGenerator>( &'a self, vocabulary: &'a mut V, generator: &'a mut G, rdf_direction: Option<RdfDirection>, ) -> Quads<'a, V, G>

Returns the RDF quads of this document, using the given vocabulary.

fn rdf_quads<'a, G: LocalGenerator>( &'a self, generator: &'a mut G, rdf_direction: Option<RdfDirection>, ) -> Quads<'a, (), G>

where (): Vocabulary<Iri = T, BlankId = B>,

Returns the RDF quads of this document.

impl<T: Eq + Hash, B: Eq + Hash> TryFromJson<T, B> for ExpandedDocument<T, B>

fn try_from_json_in( vocabulary: &mut impl VocabularyMut<Iri = T, BlankId = B>, value: Value, ) -> Result<Self, InvalidExpandedJson>

Builds this fragment from a JSON value, interning terms in the given vocabulary.