Trait Parse 

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

    // Provided methods
    fn parse_slice(content: &[u8]) -> Result<(Self, CodeMap), Error> { ... }
    fn parse_slice_with(
        content: &[u8],
        options: Options,
    ) -> Result<(Self, CodeMap), Error> { ... }
    fn parse_str(content: &str) -> Result<(Self, CodeMap), Error> { ... }
    fn parse_str_with(
        content: &str,
        options: Options,
    ) -> Result<(Self, CodeMap), Error> { ... }
    fn parse_infallible_utf8<C>(chars: C) -> Result<(Self, CodeMap), Error>
       where C: Iterator<Item = char> { ... }
    fn parse_utf8_infallible_with<C>(
        chars: C,
        options: Options,
    ) -> Result<(Self, CodeMap), Error>
       where C: Iterator<Item = char> { ... }
    fn parse_utf8<C, E>(chars: C) -> Result<(Self, CodeMap), Error<E>>
       where C: Iterator<Item = Result<char, E>> { ... }
    fn parse_utf8_with<C, E>(
        chars: C,
        options: Options,
    ) -> Result<(Self, CodeMap), Error<E>>
       where C: Iterator<Item = Result<char, E>> { ... }
    fn parse_infallible<C>(chars: C) -> Result<(Self, CodeMap), Error>
       where C: Iterator<Item = DecodedChar> { ... }
    fn parse_infallible_with<C>(
        chars: C,
        options: Options,
    ) -> Result<(Self, CodeMap), Error>
       where C: Iterator<Item = DecodedChar> { ... }
    fn parse<C, E>(chars: C) -> Result<(Self, CodeMap), Error<E>>
       where C: Iterator<Item = Result<DecodedChar, E>> { ... }
    fn parse_with<C, E>(
        chars: C,
        options: Options,
    ) -> Result<(Self, CodeMap), Error<E>>
       where C: Iterator<Item = Result<DecodedChar, E>> { ... }
}

JSON parsing methods.

Every method returns the parsed value together with the CodeMap describing where each of its fragments came from.

Example

use jstrict::{Parse, Value};

let (value, code_map) = Value::parse_str("[1, 2]")?;
assert_eq!(code_map.len(), 3); // the array and its two items.

Required Methods

fn parse_in<C, E>( parser: &mut Parser<C, E>, context: Context, ) -> Result<(Self, usize), Error<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

Parses a value in the middle of an ongoing parse, using parser and the surrounding Context.

Returns the value along with the index of its code map fragment. This is the single method implementors must provide; everything else is a wrapper around it.

Provided Methods

fn parse_slice(content: &[u8]) -> Result<(Self, CodeMap), Error>

Parses a value from a UTF-8 byte slice.

fn parse_slice_with( content: &[u8], options: Options, ) -> Result<(Self, CodeMap), Error>

Parses a value from a UTF-8 byte slice, with the given options.

fn parse_str(content: &str) -> Result<(Self, CodeMap), Error>

Parses a value from a string.

fn parse_str_with( content: &str, options: Options, ) -> Result<(Self, CodeMap), Error>

Parses a value from a string, with the given options.

fn parse_infallible_utf8<C>(chars: C) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = char>,

Parses a value from an infallible iterator of UTF-8 characters.

fn parse_utf8_infallible_with<C>( chars: C, options: Options, ) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = char>,

Parses a value from an infallible iterator of UTF-8 characters, with the given options.

fn parse_utf8<C, E>(chars: C) -> Result<(Self, CodeMap), Error<E>>

where C: Iterator<Item = Result<char, E>>,

Parses a value from a fallible iterator of UTF-8 characters.

Stream errors of type E are wrapped in Error::Stream.

fn parse_utf8_with<C, E>( chars: C, options: Options, ) -> Result<(Self, CodeMap), Error<E>>

where C: Iterator<Item = Result<char, E>>,

Parses a value from a fallible iterator of UTF-8 characters, with the given options.

fn parse_infallible<C>(chars: C) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = DecodedChar>,

Parses a value from an infallible iterator of decoded characters.

Unlike the utf8 variants, DecodedChar carries the byte length of each character in the source encoding, so spans stay accurate when the input is not UTF-8.

fn parse_infallible_with<C>( chars: C, options: Options, ) -> Result<(Self, CodeMap), Error>

where C: Iterator<Item = DecodedChar>,

Parses a value from an infallible iterator of decoded characters, with the given options.

fn parse<C, E>(chars: C) -> Result<(Self, CodeMap), Error<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

Parses a value from a fallible iterator of decoded characters.

fn parse_with<C, E>( chars: C, options: Options, ) -> Result<(Self, CodeMap), Error<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

Parses a value from a fallible iterator of decoded characters, with the given options.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Parse for ()

fn parse_in<C, E>( parser: &mut Parser<C, E>, _context: Context, ) -> Result<((), usize), Error<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

impl Parse for bool

fn parse_in<C, E>( parser: &mut Parser<C, E>, _context: Context, ) -> Result<(bool, usize), Error<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

impl<A> Parse for SmallString<A>

where A: Array<Item = u8>,

fn parse_in<C, E>( parser: &mut Parser<C, E>, _context: Context, ) -> Result<(SmallString<A>, usize), Error<E>>

where C: Iterator<Item = Result<DecodedChar, E>>,

Implementors

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

impl Parse for Value