Struct json_ld_core::ExpandedDocument

pub struct ExpandedDocument<T = IriIndex, B = BlankIdIndex, M = Location<T>>(/* private fields */);

Result of the document expansion algorithm.

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

Implementations

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

pub fn new() -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn objects(&self) -> &HashSet<StrippedIndexedObject<T, B, M>>

pub fn into_objects(self) -> HashSet<StrippedIndexedObject<T, B, M>>

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

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

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

pub fn identify_all_with<V: Vocabulary<Iri = T, BlankId = B>, G: Generator<V, M>>( &mut self, vocabulary: &mut V, generator: &mut G )

where M: Clone, 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: Generator<(), M>>(&mut self, generator: &mut G)

where M: Clone, 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: Vocabulary<Iri = T, BlankId = B>, G: Generator<V, M>>( &mut self, vocabulary: &mut V, generator: &mut G )

where M: Clone, 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: Generator<(), M>>( &mut self, generator: &mut G )

where M: Clone, 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: Vocabulary<Iri = T, BlankId = B>, G: Generator<V, M>>( &mut self, vocabulary: &mut V, generator: &mut G )

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

Relabels nodes.

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

where M: Clone, 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.

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

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

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

pub fn generate_node_map_with<V: Vocabulary<Iri = T, BlankId = B>, G: Generator<V, M>>( &self, vocabulary: &mut V, generator: G ) -> Result<NodeMap<T, B, M>, ConflictingIndexes<T, B, M>>

Trait Implementations

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

fn default() -> Self

Returns the “default value” for a type.

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

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

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: Clone + Eq + Hash, B: Clone + Eq + Hash, M: Clone> FlattenMeta<I, B, M> for ExpandedDocument<I, B, M>

fn flatten_meta<V, G: Generator<V, M>>( self, meta: M, vocabulary: &mut V, generator: G, ordered: bool ) -> FlattenResult<I, B, M>

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

fn flatten_unordered_meta<V, G: Generator<V, M>>( self, meta: M, vocabulary: &mut V, generator: G ) -> FlattenUnorderedResult<I, B, M>

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

impl<T, B, M> From<HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>>> for ExpandedDocument<T, B, M>

fn from(set: HashSet<StrippedIndexedObject<T, B, M>>) -> Self

Converts to this type from the input type.

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

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

Creates a value from an iterator.

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

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

Which kind of iterator are we turning this into?

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

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

type IntoIter = IntoIter<T, B, M>

Which kind of iterator are we turning this into?

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

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

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

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

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

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

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

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

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

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

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

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

fn rdf_quads_with<'n, 'g, V: Vocabulary<Iri = T, BlankId = B>, G: Generator<V, M>>( &self, vocabulary: &'n mut V, generator: &'g mut G, rdf_direction: Option<RdfDirection> ) -> Quads<'_, 'n, 'g, V, M, G>

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

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

Comparison between two expanded documents.

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

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

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

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