Struct syndicate::value::PackedReader

pub struct PackedReader<'de, 'src, N, Dec, S> where
    N: NestedValue,
    Dec: DomainDecode<<N as NestedValue>::Embedded>,
    S: BinarySource<'de>,  {
    pub source: &'src mut S,
    pub decode_embedded: Dec,
    // some fields omitted
}

Fields

source: &'src mut S

decode_embedded: Dec

Implementations

impl<'de, 'src, N, Dec, S> PackedReader<'de, 'src, N, Dec, S> where
    N: NestedValue,
    Dec: DomainDecode<<N as NestedValue>::Embedded>,
    S: BinarySource<'de>, 

pub fn new(
    source: &'src mut S,
    decode_embedded: Dec
) -> PackedReader<'de, 'src, N, Dec, S>

Trait Implementations

impl<'de, 'src, N, Dec, S> BinarySource<'de> for PackedReader<'de, 'src, N, Dec, S> where
    N: NestedValue,
    Dec: DomainDecode<<N as NestedValue>::Embedded>,
    S: BinarySource<'de>, 

type Mark = <S as BinarySource<'de>>::Mark

pub fn mark(
    &mut self
) -> Result<<PackedReader<'de, 'src, N, Dec, S> as BinarySource<'de>>::Mark, Error>

pub fn restore(
    &mut self,
    mark: &<PackedReader<'de, 'src, N, Dec, S> as BinarySource<'de>>::Mark
) -> Result<(), Error>

pub fn skip(&mut self) -> Result<(), Error>

pub fn peek(&mut self) -> Result<u8, Error>

pub fn readbytes(&mut self, count: usize) -> Result<Cow<'de, [u8]>, Error>

pub fn readbytes_into(&mut self, bs: &mut [u8]) -> Result<(), Error>

fn packed<N, Dec>(
    &mut self,
    decode_embedded: Dec
) -> PackedReader<'de, '_, N, Dec, Self> where
    N: NestedValue,
    Dec: DomainDecode<<N as NestedValue>::Embedded>, 

fn packed_iovalues(
    &mut self
) -> PackedReader<'de, '_, IOValue, IOValueDomainCodec, Self>

fn text<N, Dec>(
    &mut self,
    decode_embedded: Dec
) -> TextReader<'de, '_, <N as NestedValue>::Embedded, Dec, Self> where
    N: NestedValue,
    Dec: DomainParse<<N as NestedValue>::Embedded>, 

fn text_iovalues(
    &mut self
) -> TextReader<'de, '_, IOValue, ViaCodec<IOValueDomainCodec>, Self>

impl<'de, 'src, N, Dec, S> Reader<'de, N> for PackedReader<'de, 'src, N, Dec, S> where
    N: NestedValue,
    Dec: DomainDecode<<N as NestedValue>::Embedded>,
    S: BinarySource<'de>, 

pub fn next(&mut self, read_annotations: bool) -> Result<Option<N>, Error>

pub fn open_record(&mut self, arity: Option<usize>) -> Result<Type, Error>

pub fn open_sequence_or_set(&mut self) -> Result<Item, Error>

pub fn open_sequence(&mut self) -> Result<(), Error>

pub fn open_set(&mut self) -> Result<(), Error>

pub fn open_dictionary(&mut self) -> Result<(), Error>

pub fn boundary(&mut self, _b: &Type) -> Result<(), Error>

pub fn close_compound(
    &mut self,
    _b: &mut Type,
    _i: &Item
) -> Result<bool, Error>

pub fn open_embedded(&mut self) -> Result<(), Error>

pub fn close_embedded(&mut self) -> Result<(), Error>

type Mark = <S as BinarySource<'de>>::Mark

pub fn mark(
    &mut self
) -> Result<<PackedReader<'de, 'src, N, Dec, S> as Reader<'de, N>>::Mark, Error>

pub fn restore(
    &mut self,
    mark: &<PackedReader<'de, 'src, N, Dec, S> as Reader<'de, N>>::Mark
) -> Result<(), Error>

pub fn next_token(
    &mut self,
    read_embedded_annotations: bool
) -> Result<Token<N>, Error>

pub fn next_annotations_and_token(
    &mut self
) -> Result<(Vec<N, Global>, Token<N>), Error>

pub fn next_boolean(&mut self) -> Result<bool, Error>

pub fn next_signedinteger(&mut self) -> Result<SignedInteger, Error>

pub fn next_i8(&mut self) -> Result<i8, Error>

pub fn next_i16(&mut self) -> Result<i16, Error>

pub fn next_i32(&mut self) -> Result<i32, Error>

pub fn next_i64(&mut self) -> Result<i64, Error>

pub fn next_i128(&mut self) -> Result<i128, Error>

pub fn next_u8(&mut self) -> Result<u8, Error>

pub fn next_u16(&mut self) -> Result<u16, Error>

pub fn next_u32(&mut self) -> Result<u32, Error>

pub fn next_u64(&mut self) -> Result<u64, Error>

pub fn next_u128(&mut self) -> Result<u128, Error>

pub fn next_f32(&mut self) -> Result<f32, Error>

pub fn next_f64(&mut self) -> Result<f64, Error>

pub fn next_str(&mut self) -> Result<Cow<'de, str>, Error>

pub fn next_bytestring(&mut self) -> Result<Cow<'de, [u8]>, Error>

pub fn next_symbol(&mut self) -> Result<Cow<'de, str>, Error>

fn skip_value(&mut self) -> Result<(), Error>

fn demand_next(&mut self, read_annotations: bool) -> Result<N, Error>

fn next_float(&mut self) -> Result<Float, Error>

fn next_double(&mut self) -> Result<Double, Error>

fn next_char(&mut self) -> Result<char, Error>

fn open_option(&mut self) -> Result<Option<Type>, Error>

fn open_simple_record(
    &mut self,
    name: &str,
    arity: Option<usize>
) -> Result<Type, Error>

fn configured(self, read_annotations: bool) -> ConfiguredReader<'de, N, Self>

fn ensure_more_expected(&mut self, b: &mut Type, i: &Item) -> Result<(), Error>

fn ensure_complete(&mut self, b: Type, i: &Item) -> Result<(), Error>