Enum turtle_syntax::Directive

pub enum Directive<M> {
    Prefix(Meta<String, M>, Meta<IriRefBuf, M>),
    Base(Meta<IriRefBuf, M>),
    SparqlPrefix(Meta<String, M>, Meta<IriRefBuf, M>),
    SparqlBase(Meta<IriRefBuf, M>),
}

A directive.

Variants

Prefix(Meta<String, M>, Meta<IriRefBuf, M>)

@prefix directive.

Base(Meta<IriRefBuf, M>)

@base directive.

SparqlPrefix(Meta<String, M>, Meta<IriRefBuf, M>)

SPARQL PREFIX directive.

SparqlBase(Meta<IriRefBuf, M>)

SPARQL BASE directive.

Trait Implementations

impl<M: Clone> Clone for Directive<M>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Directive<M>

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

Formats the value using the given formatter.

impl<M> Parse<M> for Directive<M>

fn parse_from<L, F>( parser: &mut Parser<L, F>, Meta: Meta<Token, Span> ) -> Result<Meta<Self, M>, MetaError<L::Error, M>>where L: Tokens, F: FnMut(Span) -> M,

fn parse_with<L, F>( parser: &mut Parser<L, F> ) -> Result<Meta<Self, M>, MetaError<L::Error, M>>where L: Tokens, F: FnMut(Span) -> M,

fn parse_empty<L>(meta: M) -> Result<Meta<Self, M>, MetaError<L::Error, M>>where L: Tokens,

fn parse<C, F, E>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<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<Meta<Self, M>, MetaError<Error, M>>where C: Iterator<Item = DecodedChar>, F: FnMut(Span) -> M,

fn parse_utf8<C, F, E>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<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<Meta<Self, M>, MetaError<Error, M>>where C: Iterator<Item = char>, F: FnMut(Span) -> M,

fn parse_utf16<C, F, E>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<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<Meta<Self, M>, MetaError<Error, M>>where C: Iterator<Item = char>, F: FnMut(Span) -> M,

fn parse_str<F>( string: &str, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error, M>>where F: FnMut(Span) -> M,