Trait json_ld_syntax::Parse

pub trait Parse<M>: Sized {
    // Required method
    fn parse_spanned<C, F, E>(
        parser: &mut Parser<C, F, E>,
        context: Context
    ) -> Result<Meta<Self, Span>, Meta<Error<M, E>, M>>
       where C: Iterator<Item = Result<DecodedChar, E>>,
             F: FnMut(Span) -> M;

    // Provided methods
    fn parse_str<F>(
        content: &str,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>
       where F: FnMut(Span) -> M { ... }
    fn parse_str_with<F>(
        content: &str,
        options: Options,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>
       where F: FnMut(Span) -> M { ... }
    fn parse_infallible_utf8<C, F>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>
       where C: Iterator<Item = char>,
             F: FnMut(Span) -> M { ... }
    fn parse_utf8_infallible_with<C, F>(
        chars: C,
        options: Options,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>
       where C: Iterator<Item = char>,
             F: FnMut(Span) -> M { ... }
    fn parse_utf8<C, F, E>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>
       where C: Iterator<Item = Result<char, E>>,
             F: FnMut(Span) -> M { ... }
    fn parse_utf8_with<C, F, E>(
        chars: C,
        options: Options,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>
       where C: Iterator<Item = Result<char, E>>,
             F: FnMut(Span) -> M { ... }
    fn parse_infallible<C, F>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>
       where C: Iterator<Item = DecodedChar>,
             F: FnMut(Span) -> M { ... }
    fn parse_infallible_with<C, F>(
        chars: C,
        options: Options,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>
       where C: Iterator<Item = DecodedChar>,
             F: FnMut(Span) -> M { ... }
    fn parse<C, F, E>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>
       where C: Iterator<Item = Result<DecodedChar, E>>,
             F: FnMut(Span) -> M { ... }
    fn parse_with<C, F, E>(
        chars: C,
        options: Options,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>
       where C: Iterator<Item = Result<DecodedChar, E>>,
             F: FnMut(Span) -> M { ... }
    fn parse_in<C, F, E>(
        parser: &mut Parser<C, F, E>,
        context: Context
    ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>
       where C: Iterator<Item = Result<DecodedChar, E>>,
             F: FnMut(Span) -> M { ... }
}

Required Methods

fn parse_spanned<C, F, E>( parser: &mut Parser<C, F, E>, context: Context ) -> Result<Meta<Self, Span>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

Provided Methods

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

fn parse_str_with<F>( content: &str, options: Options, metadata_builder: F ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>where F: FnMut(Span) -> M,

fn parse_infallible_utf8<C, F>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>where C: Iterator<Item = char>, F: FnMut(Span) -> M,

fn parse_utf8_infallible_with<C, F>( chars: C, options: Options, metadata_builder: F ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>where C: Iterator<Item = char>, F: FnMut(Span) -> M,

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

fn parse_utf8_with<C, F, E>( chars: C, options: Options, metadata_builder: F ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<char, E>>, F: FnMut(Span) -> M,

fn parse_infallible<C, F>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>where C: Iterator<Item = DecodedChar>, F: FnMut(Span) -> M,

fn parse_infallible_with<C, F>( chars: C, options: Options, metadata_builder: F ) -> Result<Meta<Self, M>, Meta<Error<M, Infallible>, M>>where C: Iterator<Item = DecodedChar>, F: FnMut(Span) -> M,

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

fn parse_with<C, F, E>( chars: C, options: Options, metadata_builder: F ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

fn parse_in<C, F, E>( parser: &mut Parser<C, F, E>, context: Context ) -> Result<Meta<Self, M>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

Implementations on Foreign Types

impl<M> Parse<M> for ()

fn parse_spanned<C, F, E>( parser: &mut Parser<C, F, E>, _context: Context ) -> Result<Meta<(), Span>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

impl<M> Parse<M> for NumberBuf<SmallVec<[u8; 16]>>

fn parse_spanned<C, F, E>( parser: &mut Parser<C, F, E>, context: Context ) -> Result<Meta<NumberBuf<SmallVec<[u8; 16]>>, Span>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

impl<M, A> Parse<M> for SmallString<A>where A: Array<Item = u8>,

fn parse_spanned<C, F, E>( parser: &mut Parser<C, F, E>, _context: Context ) -> Result<Meta<SmallString<A>, Span>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

impl<M> Parse<M> for bool

fn parse_spanned<C, F, E>( parser: &mut Parser<C, F, E>, _context: Context ) -> Result<Meta<bool, Span>, Meta<Error<M, E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

Implementors

impl<M> Parse<M> for Value<M>