Struct json_ld_core::ExpandedDocument

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

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<N, G: Generator<T, B, M, N>>(
    &mut self,
    vocabulary: &mut N,
    generator: &mut G
)where
    M: Clone,
    T: Eq + Hash,
    B: Eq + Hash,

pub fn identify_all<G: Generator<T, B, M, ()>>(&mut self, generator: &mut G)where
    M: Clone,
    T: Eq + Hash,
    B: Eq + Hash,

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<N, G: Generator<T, B, M, N>>(
    &self,
    vocabulary: &mut N,
    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<N, G: Generator<I, B, M, N>>(
    self,
    meta: M,
    vocabulary: &mut N,
    generator: G,
    ordered: bool
) -> FlattenResult<I, B, M>where
    N: Vocabulary<Iri = I, BlankId = B>,

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

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

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

Comparison between two expanded documents.

const 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_with<'n, 'g, N, G: Generator<T, B, M, N>>(
    &self,
    vocabulary: &'n mut N,
    generator: &'g mut G,
    rdf_direction: Option<RdfDirection>
) -> Quads<'_, 'n, 'g, T, B, N, M, G>

fn rdf_quads<'g, G: Generator<T, B, M, ()>>(
    &self,
    generator: &'g mut G,
    rdf_direction: Option<RdfDirection>
) -> Quads<'_, 'static, 'g, T, B, (), M, G>

impl<T: Eq + Hash, B: Eq + Hash, M> StrippedPartialEq<ExpandedDocument<T, B, M>> 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>