Struct binjs::io::binjs_json::read::Decoder

pub struct Decoder<R> where
    R: Read,  { /* fields omitted */ }

Methods

impl<R> Decoder<R> where
    R: Read, 

pub fn new(source: R) -> Result<Decoder<R>, TokenReaderError>

Read JSON from source, parse it, and convert it to tokens.

pub fn next_type(&self) -> NextType

Returns which method to call to get the next item.

The consumer is supposed to call this and branch to each TokenReader::*_at method call.

pub fn get_path(&self) -> Path<InterfaceName, (usize, FieldName)>

Returns then path to the current context. Should be called before calling *_at functions.

Supposed to be fed to {TokenReader,TokenWriter}::*_at methods.

pub fn current_tagged_tuple_info(&self) -> (InterfaceName, Rc<Box<[FieldName]>>)

Returns the current tagged tuple context's interface name and field names.

Supposed to be fed to TokenWriter::exit_tagged_tuple_at.

This method should be called before TokenReader::exit_tagged_tuple_at for the corresponding tagged tuple.

Trait Implementations

impl<R> FileStructurePrinter for Decoder<R> where
    R: Read, 

fn enable_file_structure_print(&mut self)

Enables printing the binary representation and the structural interpretation.

fn disable_file_structure_print(&mut self)

Disables printing the binary representation and the structural interpretation.

fn is_file_structure_print_enabled(&mut self) -> bool

True if file structure print is enabled. With default implementation, nothing is printed.

fn prepare_file_structure_column(&mut self)

Prints the column separator ("# " characters), and padding before it if necessary.

fn newline_for_file_structure_print(&mut self)

Prints newline after printing the structural interpretation column. The implementation is supposed to print newline character(s) and also reset the current column position internally, in order to print the right number of spaces in prepare_file_structure_column.

impl<R> TokenReader for Decoder<R> where
    R: Read, 

fn string_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SharedString>, TokenReaderError>

Read a single UTF-8 string.

fn string_enum_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<SharedString, TokenReaderError>

Read a single UTF-8 value from a string enumeration.

fn identifier_name_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<IdentifierName>, TokenReaderError>

Read a single identifier name.

fn property_key_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<PropertyKey>, TokenReaderError>

Read a single property name.

fn float_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<f64>, TokenReaderError>

Read a single f64. Note that all user-level numbers are f64.

fn unsigned_long_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<u32, TokenReaderError>

Read a single u32.

fn bool_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<bool>, TokenReaderError>

Read a single bool.

fn offset_at(
    &mut self,
    __path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<u32, TokenReaderError>

Read a single number of bytes.

fn enter_list_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<u32, TokenReaderError>

Start reading a list.

fn exit_list_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<(), TokenReaderError>

Finish reading a list.

fn enter_tagged_tuple_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<(InterfaceName, Option<Rc<Box<[FieldName]>>>), TokenReaderError>

Start reading a tagged tuple. If the stream was encoded properly, the tag is attached to an ordered tuple of fields that may be extracted in order.

fn exit_tagged_tuple_at(
    &mut self,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<(), TokenReaderError>

Finish reading a tagged tuple.

fn poison(&mut self)

Poison the reader, ensuring that it will never be used for reading again.

fn enter_scoped_dictionary_at(
    &mut self,
    _name: &SharedString,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<(), TokenReaderError>

Signal that, from this point, reading is expected to use a specialized dictionary. Use of the specialized dictionary will stop at exit_scoped_dictionary_at.

fn exit_scoped_dictionary_at(
    &mut self,
    _name: &SharedString,
    _path: &Path<InterfaceName, (usize, FieldName)>
) -> Result<(), TokenReaderError>

Signal that, from this point, reading is expected to return to the previous specialized dictionary.