Trait ShapeDeserializer 

pub trait ShapeDeserializer {
    // Required methods
    fn read_struct(
        &mut self,
        schema: &Schema,
        state: &mut dyn FnMut(&Schema, &mut dyn ShapeDeserializer) -> Result<(), SerdeError>,
    ) -> Result<(), SerdeError>;
    fn read_list(
        &mut self,
        schema: &Schema,
        state: &mut dyn FnMut(&mut dyn ShapeDeserializer) -> Result<(), SerdeError>,
    ) -> Result<(), SerdeError>;
    fn read_map(
        &mut self,
        schema: &Schema,
        state: &mut dyn FnMut(String, &mut dyn ShapeDeserializer) -> Result<(), SerdeError>,
    ) -> Result<(), SerdeError>;
    fn read_boolean(&mut self, schema: &Schema) -> Result<bool, SerdeError>;
    fn read_byte(&mut self, schema: &Schema) -> Result<i8, SerdeError>;
    fn read_short(&mut self, schema: &Schema) -> Result<i16, SerdeError>;
    fn read_integer(&mut self, schema: &Schema) -> Result<i32, SerdeError>;
    fn read_long(&mut self, schema: &Schema) -> Result<i64, SerdeError>;
    fn read_float(&mut self, schema: &Schema) -> Result<f32, SerdeError>;
    fn read_double(&mut self, schema: &Schema) -> Result<f64, SerdeError>;
    fn read_big_integer(
        &mut self,
        schema: &Schema,
    ) -> Result<BigInteger, SerdeError>;
    fn read_big_decimal(
        &mut self,
        schema: &Schema,
    ) -> Result<BigDecimal, SerdeError>;
    fn read_string(&mut self, schema: &Schema) -> Result<String, SerdeError>;
    fn read_blob(&mut self, schema: &Schema) -> Result<Blob, SerdeError>;
    fn read_timestamp(
        &mut self,
        schema: &Schema,
    ) -> Result<DateTime, SerdeError>;
    fn read_document(&mut self, schema: &Schema) -> Result<Document, SerdeError>;
    fn is_null(&self) -> bool;
    fn container_size(&self) -> Option<usize>;

    // Provided methods
    fn read_null(&mut self) -> Result<(), SerdeError> { ... }
    fn read_string_list(
        &mut self,
        schema: &Schema,
    ) -> Result<Vec<String>, SerdeError> { ... }
    fn read_blob_list(
        &mut self,
        schema: &Schema,
    ) -> Result<Vec<Blob>, SerdeError> { ... }
    fn read_integer_list(
        &mut self,
        schema: &Schema,
    ) -> Result<Vec<i32>, SerdeError> { ... }
    fn read_long_list(
        &mut self,
        schema: &Schema,
    ) -> Result<Vec<i64>, SerdeError> { ... }
    fn read_string_string_map(
        &mut self,
        schema: &Schema,
    ) -> Result<HashMap<String, String>, SerdeError> { ... }
}

Required Methods

fn read_struct( &mut self, schema: &Schema, state: &mut dyn FnMut(&Schema, &mut dyn ShapeDeserializer) -> Result<(), SerdeError>, ) -> Result<(), SerdeError>

Reads a structure from the deserializer.

The consumer is called for each member with the member schema and a &mut dyn ShapeDeserializer to read the member value. Using dyn allows composite deserializers (e.g., HTTP binding + body) to transparently delegate without the consumer knowing the concrete type.

fn read_list( &mut self, schema: &Schema, state: &mut dyn FnMut(&mut dyn ShapeDeserializer) -> Result<(), SerdeError>, ) -> Result<(), SerdeError>

Reads a list from the deserializer.

The consumer is called for each element with a &mut dyn ShapeDeserializer.

fn read_map( &mut self, schema: &Schema, state: &mut dyn FnMut(String, &mut dyn ShapeDeserializer) -> Result<(), SerdeError>, ) -> Result<(), SerdeError>

Reads a map from the deserializer.

The consumer is called for each entry with the key and a &mut dyn ShapeDeserializer.

fn read_boolean(&mut self, schema: &Schema) -> Result<bool, SerdeError>

Reads a boolean value.

fn read_byte(&mut self, schema: &Schema) -> Result<i8, SerdeError>

Reads a byte (i8) value.

fn read_short(&mut self, schema: &Schema) -> Result<i16, SerdeError>

Reads a short (i16) value.

fn read_integer(&mut self, schema: &Schema) -> Result<i32, SerdeError>

Reads an integer (i32) value.

fn read_long(&mut self, schema: &Schema) -> Result<i64, SerdeError>

Reads a long (i64) value.

fn read_float(&mut self, schema: &Schema) -> Result<f32, SerdeError>

Reads a float (f32) value.

fn read_double(&mut self, schema: &Schema) -> Result<f64, SerdeError>

Reads a double (f64) value.

fn read_big_integer( &mut self, schema: &Schema, ) -> Result<BigInteger, SerdeError>

Reads a big integer value.

fn read_big_decimal( &mut self, schema: &Schema, ) -> Result<BigDecimal, SerdeError>

Reads a big decimal value.

fn read_string(&mut self, schema: &Schema) -> Result<String, SerdeError>

Reads a string value.

fn read_blob(&mut self, schema: &Schema) -> Result<Blob, SerdeError>

Reads a blob (byte array) value.

fn read_timestamp(&mut self, schema: &Schema) -> Result<DateTime, SerdeError>

Reads a timestamp value.

fn read_document(&mut self, schema: &Schema) -> Result<Document, SerdeError>

Reads a document value.

fn is_null(&self) -> bool

Checks if the current value is null.

This is used for sparse collections where null values are significant.

fn container_size(&self) -> Option<usize>

Returns the size of the current container if known.

This is an optimization hint that allows pre-allocating collections with the correct capacity. Returns None if the size is unknown or not applicable.

Implementations SHOULD cap the returned value at a reasonable maximum (e.g., 10,000) to prevent denial-of-service from untrusted payloads that claim excessively large container sizes (e.g., a CBOR header declaring billions of elements). Use capped_container_size to apply a standard cap.

Provided Methods

fn read_null(&mut self) -> Result<(), SerdeError>

Consumes a null value, advancing past it.

This should be called after is_null() returns true to advance the deserializer past the null token.

fn read_string_list( &mut self, schema: &Schema, ) -> Result<Vec<String>, SerdeError>

Reads a list of strings.

fn read_blob_list(&mut self, schema: &Schema) -> Result<Vec<Blob>, SerdeError>

Reads a list of blobs.

fn read_integer_list(&mut self, schema: &Schema) -> Result<Vec<i32>, SerdeError>

Reads a list of integers.

fn read_long_list(&mut self, schema: &Schema) -> Result<Vec<i64>, SerdeError>

Reads a list of longs.

fn read_string_string_map( &mut self, schema: &Schema, ) -> Result<HashMap<String, String>, SerdeError>

Reads a map with string values.

Implementors

impl<'a> ShapeDeserializer for HttpStringDeserializer<'a>