Struct json_ld::expanded::ExpandedDocument

pub struct ExpandedDocument<T = Index, B = Index, M = Location<T, Span>>(_);

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

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

pub fn iter(&self) -> Iter<'_, Stripped<Meta<Indexed<Object<T, B, M>, M>, 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, 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,

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

Relabels nodes.

pub fn relabel<G>(&mut self, generator: &mut G)where
    G: MetaGenerator<(), M>,
    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, RandomState>where
    B: Eq + Hash,

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

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

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

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

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

Trait Implementations

impl<I, B, M> CompactMeta<I, B, M> for ExpandedDocument<I, B, M>

fn compact_full_meta<N, C, L, 'a>(
    &'a self,
    meta: &'a M,
    vocabulary: &'a mut N,
    context: ProcessedRef<'a, 'a, I, B, C, M>,
    loader: &'a mut L,
    options: Options
) -> Pin<Box<dyn Future<Output = Result<Meta<Value<M>, M>, Meta<Error<<L as ContextLoader<I, M>>::ContextError>, M>>> + Send + 'a, Global>>where
    L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
    N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
    I: Clone + Hash + Eq + Send + Sync,
    B: Clone + Hash + Eq + Send + Sync,
    M: Clone + Send + Sync,
    C: Clone + ProcessMeta<I, B, M> + AnyValue<M>,
    <L as ContextLoader<I, M>>::Context: Into<C>,

Compacts the input document with full options.

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

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

Returns the “default value” for a type.

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

fn extend<I>(&mut self, iter: I)where
    I: IntoIterator<Item = Meta<Indexed<Object<T, B, M>, M>, M>>,

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

fn flatten_meta<V, G>(
    self,
    meta: M,
    vocabulary: &mut V,
    generator: G,
    ordered: bool
) -> Result<Meta<Vec<Meta<Indexed<Node<I, B, M>, M>, M>, Global>, M>, ConflictingIndexes<I, B, M>>where
    G: MetaGenerator<V, M>,
    V: Vocabulary<Iri = I, BlankId = B>,

fn flatten_unordered_meta<V, G>(
    self,
    meta: M,
    vocabulary: &mut V,
    generator: G
) -> Result<Meta<HashSet<Stripped<Meta<Indexed<Node<I, B, M>, M>, M>>, RandomState>, M>, ConflictingIndexes<I, B, M>>where
    G: MetaGenerator<V, M>,
    V: Vocabulary<Iri = I, BlankId = B>,

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

fn from(
    set: HashSet<Stripped<Meta<Indexed<Object<T, B, M>, M>, M>>, RandomState>
) -> ExpandedDocument<T, B, M>

Converts to this type from the input type.

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

fn from_iter<I>(iter: I) -> ExpandedDocument<T, B, M>where
    I: IntoIterator<Item = Meta<Indexed<Object<T, B, M>, M>, M>>,

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) -> <&'a ExpandedDocument<T, B, M> as IntoIterator>::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) -> <ExpandedDocument<T, B, M> as IntoIterator>::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, B, M> PartialEq<ExpandedDocument<T, B, M>> for ExpandedDocument<T, B, M>where
    T: Eq + Hash,
    B: Eq + Hash,

fn eq(&self, other: &ExpandedDocument<T, B, M>) -> 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> PrecomputeSizeWithContext<N> for ExpandedDocument<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> PrintWithContext<N> for ExpandedDocument<T, B, M>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, M, N> PrintWithSizeAndContext<N> for ExpandedDocument<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> RdfQuads<T, B, M> for ExpandedDocument<T, B, M>

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

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

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

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

Comparison between two expanded documents.

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

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

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

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