Struct PostcardParser 

pub struct PostcardParser<'de> { /* private fields */ }

Postcard parser for Tier-0 and Tier-2 deserialization.

For Tier-0, the parser relies on hint_struct_fields to know how many fields to expect in structs. Sequences are length-prefixed in the wire format.

Implementations

impl<'de> PostcardParser<'de>

pub const fn new(input: &'de [u8]) -> Self

Create a new postcard parser from input bytes.

pub const fn with_limits(input: &'de [u8], max_collection_elements: u64) -> Self

Create a new postcard parser with custom safety limits.

pub fn parse_bool(&mut self) -> Result<bool, ParseError>

Parse a boolean value.

pub fn parse_u8(&mut self) -> Result<u8, ParseError>

Parse an unsigned 8-bit integer.

pub fn parse_u16(&mut self) -> Result<u16, ParseError>

Parse an unsigned 16-bit integer (varint).

pub fn parse_u32(&mut self) -> Result<u32, ParseError>

Parse an unsigned 32-bit integer (varint).

pub fn parse_u64(&mut self) -> Result<u64, ParseError>

Parse an unsigned 64-bit integer (varint).

pub fn parse_u128(&mut self) -> Result<u128, ParseError>

Parse an unsigned 128-bit integer (varint).

pub fn parse_i8(&mut self) -> Result<i8, ParseError>

Parse a signed 8-bit integer (single byte, two’s complement).

pub fn parse_i16(&mut self) -> Result<i16, ParseError>

Parse a signed 16-bit integer (zigzag varint).

pub fn parse_i32(&mut self) -> Result<i32, ParseError>

Parse a signed 32-bit integer (zigzag varint).

pub fn parse_i64(&mut self) -> Result<i64, ParseError>

Parse a signed 64-bit integer (zigzag varint).

pub fn parse_i128(&mut self) -> Result<i128, ParseError>

Parse a signed 128-bit integer (zigzag varint).

pub fn parse_f32(&mut self) -> Result<f32, ParseError>

Parse a 32-bit float (little-endian).

pub fn parse_f64(&mut self) -> Result<f64, ParseError>

Parse a 64-bit float (little-endian).

pub fn parse_string(&mut self) -> Result<&'de str, ParseError>

Parse a string (varint length + UTF-8 bytes).

pub fn parse_bytes(&mut self) -> Result<&'de [u8], ParseError>

Parse bytes (varint length + raw bytes).

pub fn begin_sequence(&mut self) -> Result<u64, ParseError>

Begin parsing a sequence, returning the element count.

Trait Implementations

impl<'de> FormatParser<'de> for PostcardParser<'de>

fn next_event(&mut self) -> Result<Option<ParseEvent<'de>>, ParseError>

Read the next parse event, or None if the input is exhausted.

fn peek_event(&mut self) -> Result<Option<ParseEvent<'de>>, ParseError>

Peek at the next event without consuming it, or None if at EOF.

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

Skip the current value (for unknown fields, etc.).

fn current_span(&self) -> Option<Span>

Returns the source span of the most recently consumed event.

fn format_namespace(&self) -> Option<&'static str>

Returns the format namespace for format-specific proxy resolution.

fn save(&mut self) -> SavePoint

Save the current parser position and start recording events.

fn restore(&mut self, _save_point: SavePoint)

Restore to a previous save point, replaying recorded events.

fn is_self_describing(&self) -> bool

Returns true if this format is self-describing.

fn hint_struct_fields(&mut self, num_fields: usize)

Hint to the parser that a struct with the given number of fields is expected.

fn hint_scalar_type(&mut self, hint: ScalarTypeHint)

Hint to the parser what scalar type is expected next.

fn hint_sequence(&mut self)

Hint to the parser that a sequence (array/Vec) is expected.

fn hint_byte_sequence(&mut self) -> bool

Hint to the parser that a byte sequence (Vec<u8>, &[u8], etc.) is expected.

fn hint_remaining_byte_sequence(&mut self) -> bool

Hint to the parser that all remaining input bytes should be consumed as a byte slice.

fn hint_array(&mut self, len: usize)

Hint to the parser that a fixed-size array is expected.

fn hint_option(&mut self)

Hint to the parser that an Option<T> is expected.

fn hint_enum(&mut self, variants: &[EnumVariantHint])

Hint to the parser that an enum is expected, providing variant information.

fn hint_map(&mut self)

Hint to the parser that a map is expected.

fn hint_dynamic_value(&mut self)

Hint to the parser that a dynamic value is expected.

fn hint_opaque_scalar( &mut self, type_identifier: &'static str, shape: &'static Shape, ) -> bool

Hint to the parser that an opaque scalar type is expected.

fn next_events( &mut self, buf: &mut VecDeque<ParseEvent<'de>>, limit: usize, ) -> Result<usize, ParseError>

Read multiple parse events into a deque, returning the number of events read.

fn capture_raw(&mut self) -> Result<Option<&'de str>, ParseError>

Capture the raw representation of the current value without parsing it.

fn input(&self) -> Option<&'de [u8]>

Returns the raw input bytes, if available.

fn raw_capture_shape(&self) -> Option<&'static Shape>

Returns the shape of the format’s raw capture type (e.g., RawJson::SHAPE).