Struct turbo_json_checker::JsonChecker

pub struct JsonChecker<R> { /* fields omitted */ }

The JsonChecker is a io::Read adapter, it can be used like a pipe, reading bytes, checkings those and output the same bytes.

If an error is encountered, a JSON syntax error or an io::Error it is returned by the io::Read::read method.

Safety

An error encountered while reading bytes will invalidate the checker.

Example: read from a slice

use std::io;
use turbo_json_checker::JsonChecker;

let text = r#"{"I am": "an object"}"#;
let bytes = text.as_bytes();

let mut checker = JsonChecker::new(bytes);
io::copy(&mut checker, &mut io::sink())?;
checker.finish()?;

Implementations

impl<R> JsonChecker<R>

pub fn new(reader: R) -> JsonChecker<R>

Construct a JsonChecker. To continue the process, write to the JsonCheckerlike a sink, and then callJsonChecker::finish` to obtain the final result.

pub fn with_max_depth(reader: R, max_depth: usize) -> JsonChecker<R>

Construct a JsonChecker and restrict the level of maximum nesting.

For more information read the JsonChecker::new documentation.

pub fn finish(self) -> Result<(JsonType, usize, usize), Error>

The JsonChecker::finish method must be called after all of the characters have been processed.

This function consumes the JsonChecker and returns Ok(JsonType) if the JSON text was accepted and the JSON type guessed.

pub fn into_inner(self) -> Result<(R, JsonType, usize, usize), Error>

The JsonChecker::into_inner does the same as the JsonChecker::finish method but returns the internal reader along with the JSON type guessed.

Trait Implementations

impl<R> Debug for JsonChecker<R>

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

Formats the value using the given formatter.

impl<R: Read> Read for JsonChecker<R>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it.