Struct Document

pub struct Document<M> {
    pub statements: Vec<(Statement<M>, M)>,
}

A Turtle document.

Fields

statements: Vec<(Statement<M>, M)>

Implementations

impl<M> Document<M>

pub fn new() -> Document<M>

pub fn insert(&mut self, statement: (Statement<M>, M))

impl<M: Clone> Document<M>

pub fn build_meta_triples( &self, base_iri: Option<IriBuf>, generator: impl Generator<()>, ) -> Result<Vec<MetaTriple<M, ()>>, BuildError<M>>

pub fn build_meta_triples_with<V: RdfVocabulary + IriVocabularyMut + BlankIdVocabularyMut>( &self, base_iri: Option<V::Iri>, vocabulary: &mut V, generator: impl Generator<V>, ) -> Result<Vec<MetaTriple<M, V>>, BuildError<M>>

where V::Iri: Clone, V::BlankId: Clone,

pub fn build_lexical_triples( &self, base_iri: Option<IriBuf>, generator: impl Generator<()>, ) -> Result<Vec<LexicalTriple>, BuildError<M>>

Trait Implementations

impl<M: Clone, V: RdfVocabulary + IriVocabularyMut + BlankIdVocabularyMut, G: Generator<V>> Build<M, V, G> for Document<M>

where V::Iri: Clone, V::BlankId: Clone,

fn build( &self, context: &mut Context<'_, '_, M, V, G>, triples: &mut Vec<MetaTriple<M, V>>, ) -> Result<(), BuildError<M>>

impl<M: Clone> Clone for Document<M>

fn clone(&self) -> Document<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Document<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M> Default for Document<M>

fn default() -> Self

Returns the “default value” for a type.

impl<M> Parse<M> for Document<M>

fn parse_from<L, F>( parser: &mut Parser<L, F>, (token, span): (Token, Span), ) -> Result<(Self, M), ParseError<L::Error, M>>

where L: Tokens, F: FnMut(Span) -> M,

fn parse_empty<L>(meta: M) -> Result<(Self, M), ParseError<L::Error, M>>

where L: Tokens,

fn parse_with<L, F>( parser: &mut Parser<L, F>, ) -> Result<(Self, M), ParseError<L::Error, M>>

where L: Tokens, F: FnMut(Span) -> M,

fn parse<C, F, E>( chars: C, metadata_builder: F, ) -> Result<(Self, M), ParseError<Error<E>, M>>

where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

fn parse_infallible<C, F>( chars: C, metadata_builder: F, ) -> Result<(Self, M), ParseError<Error, M>>

where C: Iterator<Item = DecodedChar>, F: FnMut(Span) -> M,

fn parse_utf8<C, F, E>( chars: C, metadata_builder: F, ) -> Result<(Self, M), ParseError<Error<E>, M>>

where C: Iterator<Item = Result<char, E>>, F: FnMut(Span) -> M,

fn parse_utf8_infallible<C, F>( chars: C, metadata_builder: F, ) -> Result<(Self, M), ParseError<Error, M>>

where C: Iterator<Item = char>, F: FnMut(Span) -> M,

fn parse_utf16<C, F, E>( chars: C, metadata_builder: F, ) -> Result<(Self, M), ParseError<Error<E>, M>>

where C: Iterator<Item = Result<char, E>>, F: FnMut(Span) -> M,

fn parse_utf16_infallible<C, F>( chars: C, metadata_builder: F, ) -> Result<(Self, M), ParseError<Error, M>>

where C: Iterator<Item = char>, F: FnMut(Span) -> M,

fn parse_str<F>( string: &str, metadata_builder: F, ) -> Result<(Self, M), ParseError<Error, M>>

where F: FnMut(Span) -> M,