Struct json_ld::expanded::ExpandedDocument

pub struct ExpandedDocument<T = IriBuf, B = BlankIdBuf>(/* private fields */);

Result of the document expansion algorithm.

It is just an alias for a set of (indexed) objects.

Implementations

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

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

pub fn into_objects(self) -> IndexSet<Indexed<Object<T, B>>>

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

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

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

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,

Give an identifier (@id) to every nodes using the given generator to generate fresh identifiers for anonymous nodes.

pub fn identify_all<G>(&mut self, generator: &mut G)

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

Give an identifier (@id) to every nodes using the given generator to generate fresh identifiers for anonymous nodes.

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

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

Give an identifier (@id) to every nodes and canonicalize every literals using the given generator to generate fresh identifiers for anonymous nodes.

pub fn relabel_and_canonicalize<G>(&mut self, generator: &mut G)

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

Give an identifier (@id) to every nodes and canonicalize every literals using the given generator to generate fresh identifiers for anonymous nodes.

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

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

Relabels nodes.

pub fn relabel<G>(&mut self, generator: &mut G)

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

Relabels nodes.

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

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

Puts this document literals into canonical form using the given buffer.

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

pub fn canonicalize(&mut self)

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

Puts this document literals into canonical form.

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, B> ExpandedDocument<T, B>

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

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

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

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

pub fn generate_node_map_with<V, G>( &self, vocabulary: &mut V, generator: G ) -> Result<NodeMap<T, B>, ConflictingIndexes<T, B>>

where V: Vocabulary<Iri = T, BlankId = B>, G: Generator<V>,

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 as Interpretation>::Resource>>, context: Context<'_, T> ) -> Result<ExpandedDocument<I, B>, SerializationError>

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

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

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

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, B> Clone for ExpandedDocument<T, B>

where T: Clone, B: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, B> Compact<I, B> for ExpandedDocument<I, B>

async fn compact_full<'a, N, L>( &'a self, vocabulary: &'a mut N, context: ProcessedRef<'a, 'a, I, B>, loader: &'a mut L, options: Options ) -> Result<Value, Error<<L as Loader<I>>::Error>>

where N: VocabularyMut<Iri = I, BlankId = B>, I: Clone + Hash + Eq, B: Clone + Hash + Eq, L: Loader<I>,

Compacts the input document with full options.

impl<T, B> Debug for ExpandedDocument<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 ExpandedDocument<T, B>

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

Returns the “default value” for a type.

impl<T, B> Extend<Indexed<Object<T, B>>> for ExpandedDocument<T, B>

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

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Indexed<Object<T, B>>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬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, B> Flatten<I, B> for ExpandedDocument<I, B>

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

fn flatten_with<V, G>( self, vocabulary: &mut V, generator: G, ordered: bool ) -> Result<Vec<Indexed<Node<I, B>>>, ConflictingIndexes<I, B>>

where G: Generator<V>, V: Vocabulary<Iri = I, BlankId = B>,

fn flatten_unordered_with<V, G>( self, vocabulary: &mut V, generator: G ) -> Result<HashSet<Indexed<Node<I, B>>>, ConflictingIndexes<I, B>>

where G: Generator<V>, V: Vocabulary<Iri = I, BlankId = B>,

impl<T, B> From<IndexSet<Indexed<Object<T, B>>>> for ExpandedDocument<T, B>

fn from(set: IndexSet<Indexed<Object<T, B>>>) -> ExpandedDocument<T, B>

Converts to this type from the input type.

impl<T, B> From<Indexed<Node<T, B>>> for ExpandedDocument<T, B>

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

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

Converts to this type from the input type.

impl<T, B> FromIterator<Indexed<Object<T, B>>> for ExpandedDocument<T, B>

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

fn from_iter<I>(iter: I) -> ExpandedDocument<T, B>

where I: IntoIterator<Item = Indexed<Object<T, B>>>,

Creates a value from an iterator.

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) -> <&'a ExpandedDocument<T, B> as IntoIterator>::IntoIter

Creates an iterator from a value.

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) -> <ExpandedDocument<T, B> as IntoIterator>::IntoIter

Creates an iterator from a value.

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

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

impl<T, B, V, I> LinkedData<I, V> for ExpandedDocument<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<V, I> LinkedDataDeserialize<V, I> for ExpandedDocument<<V as IriVocabulary>::Iri, <V as BlankIdVocabulary>::BlankId>

where I: ReverseTermInterpretation<Iri = <V as IriVocabulary>::Iri, BlankId = <V as BlankIdVocabulary>::BlankId, Literal = <V as LiteralVocabulary>::Literal>, V: Vocabulary, <I as Interpretation>::Resource: Ord + Hash, <V as IriVocabulary>::Iri: Clone + Eq + Hash, <V as BlankIdVocabulary>::BlankId: Clone + Eq + Hash,

fn deserialize_dataset_in( vocabulary: &V, interpretation: &I, dataset: &(impl TraversableDataset<Resource = <I as Interpretation>::Resource> + PatternMatchingDataset), context: Context<'_, I> ) -> Result<ExpandedDocument<<V as IriVocabulary>::Iri, <V as BlankIdVocabulary>::BlankId>, FromLinkedDataError>

fn deserialize_dataset( vocabulary: &V, interpretation: &I, dataset: &(impl TraversableDataset<Resource = <I as Interpretation>::Resource> + PatternMatchingDataset) ) -> Result<Self, FromLinkedDataError>

impl<T, B, V, I> LinkedDataGraph<I, V> for ExpandedDocument<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> PartialEq for ExpandedDocument<T, B>

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

fn eq(&self, other: &ExpandedDocument<T, B>) -> bool

Comparison between two expanded documents.

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 ExpandedDocument<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 ExpandedDocument<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 ExpandedDocument<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> RdfQuads<T, B> for ExpandedDocument<T, B>

fn rdf_quads_full<'n, 'g, V, G>( &self, vocabulary: &'n mut V, generator: &'g mut G, rdf_direction: Option<RdfDirection>, produce_generalized_rdf: bool ) -> Quads<'_, 'n, 'g, V, G>

where V: Vocabulary<Iri = T, BlankId = B>, G: Generator<V>,

fn rdf_quads_with<'n, 'g, V, G>( &self, vocabulary: &'n mut V, generator: &'g mut G, rdf_direction: Option<RdfDirection> ) -> Quads<'_, 'n, 'g, V, G>

where V: Vocabulary<Iri = T, BlankId = B>, G: Generator<V>,

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

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

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

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

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