Trait json_ld::Flatten

source ·
pub trait Flatten<I, B, M> {
    // Required methods
    fn flatten_with<V, G>(
        self,
        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_with<V, G>(
        self,
        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>;

    // Provided methods
    fn flatten<G>(
        self,
        generator: G,
        ordered: bool
    ) -> Result<Meta<Vec<Meta<Indexed<Node<I, B, M>, M>, M>, Global>, M>, ConflictingIndexes<I, B, M>>
       where G: MetaGenerator<(), M>,
             (): Vocabulary<Iri = I, BlankId = B>,
             Self: Sized { ... }
    fn flatten_unordered<G>(
        self,
        generator: G
    ) -> Result<Meta<HashSet<Stripped<Meta<Indexed<Node<I, B, M>, M>, M>>, RandomState>, M>, ConflictingIndexes<I, B, M>>
       where G: MetaGenerator<(), M>,
             (): Vocabulary<Iri = I, BlankId = B>,
             Self: Sized { ... }
}

Required Methods§

source

fn flatten_with<V, G>( self, 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>,

source

fn flatten_unordered_with<V, G>( self, 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>,

Provided Methods§

source

fn flatten<G>( self, generator: G, ordered: bool ) -> Result<Meta<Vec<Meta<Indexed<Node<I, B, M>, M>, M>, Global>, M>, ConflictingIndexes<I, B, M>>where G: MetaGenerator<(), M>, (): Vocabulary<Iri = I, BlankId = B>, Self: Sized,

source

fn flatten_unordered<G>( self, generator: G ) -> Result<Meta<HashSet<Stripped<Meta<Indexed<Node<I, B, M>, M>, M>>, RandomState>, M>, ConflictingIndexes<I, B, M>>where G: MetaGenerator<(), M>, (): Vocabulary<Iri = I, BlankId = B>, Self: Sized,

Implementations on Foreign Types§

source§

impl<T, I, B, M> Flatten<I, B, M> for Meta<T, M>where T: FlattenMeta<I, B, M>,

source§

fn flatten_with<V, G>( self, 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>,

source§

fn flatten_unordered_with<V, G>( self, 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>,

Implementors§