Struct Postbag 

pub struct Postbag;

Available on crate feature serde only.

Postbag codec with full forward and backward compatibility.

Postbag is a high-performance binary codec that provides efficient data encoding with configurable levels of forward and backward compatibility. This codec uses the Full configuration which provides maximum compatibility and schema evolution capabilities.

Key Features

• Full fidelity of Rust type system: Supports all serde-compatible types including structs, enums, tuples, arrays, maps, and all primitive types
• Efficient binary format: Uses variable-length encoding (varint) for integers, compact representations for common types, and minimal overhead
• Full forward/backward compatibility: Fields and enum variants can be reordered, added, or removed safely

Forward and Backward Compatibility

The Full configuration provides comprehensive schema evolution capabilities:

• Field reordering: Struct fields can be reordered without breaking compatibility
• Field addition: New fields can be added to structs at any position
• Field removal: Existing fields can be removed without affecting deserialization
• Enum variant evolution: Enum variants can be added, removed, or reordered
• Schema evolution: Safe evolution of data structures over time

Numerical Identifier Encoding

Fields named _0 through _59 are encoded with just a single byte instead of the full string identifier. Use #[serde(rename = "...")] to specify numerical IDs:

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct CompactData {
    #[serde(rename = "_3")]
    my_field: u32,
    #[serde(rename = "_15")]
    another_field: String,
    // Regular field names work normally
    normal_field: bool,
}

This serializes and deserializes with field identifiers for maximum compatibility.

Trait Implementations

impl Clone for Postbag

fn clone(&self) -> Postbag

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Codec for Postbag

fn serialize<Writer, Item>( writer: Writer, item: &Item, ) -> Result<(), SerializationError>

where Writer: Write, Item: Serialize,

Serializes the specified item into the data format.

fn deserialize<Reader, Item>( reader: Reader, ) -> Result<Item, DeserializationError>

where Reader: Read, Item: DeserializeOwned,

Deserializes the specified data into an item.

impl<'de> Deserialize<'de> for Postbag

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Postbag

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.