Struct Configuration 

pub struct Configuration<E = LittleEndian, I = Varint, L = NoLimit, B = SkipBitPacking, O = LsbFirst, F = FingerprintDisabled, FO = BincodeFormat> { /* private fields */ }

The Configuration struct is used to build bincode configurations. The Config trait is implemented by this struct when a valid configuration has been constructed.

The following methods are mutually exclusive and will overwrite each other. The last call to one of these methods determines the behavior of the configuration:

• [with_little_endian] and [with_big_endian]
• [with_fixed_int_encoding] and [with_variable_int_encoding]
• [with_bit_packing] and [with_no_bit_packing]

Implementations

impl<E, I, L, B, O, F, FO> Configuration<E, I, L, B, O, F, FO>

pub const fn with_big_endian( self, ) -> Configuration<BigEndian, I, L, B, MsbFirst, F, FO>

Makes bincode encode all integer types in big endian.

pub const fn with_little_endian( self, ) -> Configuration<LittleEndian, I, L, B, LsbFirst, F, FO>

Makes bincode encode all integer types in little endian.

pub const fn with_variable_int_encoding( self, ) -> Configuration<E, Varint, L, B, O, F, FO>

Makes bincode encode all integer types with a variable integer encoding.

Encoding an unsigned integer v (of any type excepting u8) works as follows:

1. If u < 251, encode it as a single byte with that value.
2. If 251 <= u < 2**16, encode it as a literal byte 251, followed by a u16 with value u.
3. If 2**16 <= u < 2**32, encode it as a literal byte 252, followed by a u32 with value u.
4. If 2**32 <= u < 2**64, encode it as a literal byte 253, followed by a u64 with value u.
5. If 2**64 <= u < 2**128, encode it as a literal byte 254, followed by a u128 with value u.

Then, for signed integers, we first convert to unsigned using the zigzag algorithm, and then encode them as we do for unsigned integers generally. The reason we use this algorithm is that it encodes those values which are close to zero in less bytes; the obvious algorithm, where we encode the cast values, gives a very large encoding for all negative values.

The zigzag algorithm is defined as follows:

fn zigzag(v: Signed) -> Unsigned {
    match v {
        | 0 => 0,
        // To avoid the edge case of Signed::min_value()
        // !n is equal to `-n - 1`, so this is:
        // !n * 2 + 1 = 2(-n - 1) + 1 = -2n - 2 + 1 = -2n - 1
        | v if v < 0 => !(v as Unsigned) * 2 - 1,
        | v if v > 0 => (v as Unsigned) * 2,
    }
}

And works such that:

assert_eq!(zigzag(0), 0);
assert_eq!(zigzag(-1), 1);
assert_eq!(zigzag(1), 2);
assert_eq!(zigzag(-2), 3);
assert_eq!(zigzag(2), 4);
// etc
assert_eq!(zigzag(i64::min_value()), u64::max_value());

Note that u256 and the like are unsupported by this format; if and when they are added to the language, they may be supported via the extension point given by the 255 byte.

pub const fn with_fixed_int_encoding( self, ) -> Configuration<E, Fixint, L, B, O, F, FO>

Fixed-size integer encoding.

• Fixed size integers are encoded directly
• Enum discriminants are encoded as u32
• Lengths and usize are encoded as u64

pub const fn with_limit<const N: usize>( self, ) -> Configuration<E, I, Limit<N>, B, O, F, FO>

Sets the byte limit to limit.

pub const fn with_no_limit(self) -> Configuration<E, I, NoLimit, B, O, F, FO>

Clear the byte limit.

pub const fn with_bit_packing( self, ) -> Configuration<E, I, L, AllowBitPacking, O, F, FO>

Enables bit-packing for types that support it.

pub const fn with_no_bit_packing( self, ) -> Configuration<E, I, L, SkipBitPacking, O, F, FO>

Disables bit-packing.

pub const fn with_fingerprint( self, ) -> Configuration<E, I, L, B, O, FingerprintEnabled<0>, FO>

Enables fingerprinting with the default deterministic seed (0).

The fingerprint is a 64-bit hash that covers:

• The type name
• For structs: field names, types, and their order
• For enums: variant names, field names, types, and their order
• Configuration settings such as endianness and integer encoding

pub const fn with_fingerprint_and_seed<const SEED: u64>( self, ) -> Configuration<E, I, L, B, O, FingerprintEnabled<SEED>, FO>

Enables fingerprinting with a custom seed.

This is similar to with_fingerprint, but allows specifying a custom seed to further differentiate fingerprints.

pub const fn with_legacy_fingerprint<const EXPECTED: u64>( self, ) -> Configuration<E, I, L, B, O, FingerprintLegacy<EXPECTED>, FO>

Enables legacy fingerprinting with an expected hash.

In this mode, bincode will not calculate the fingerprint automatically. Instead, it will use the provided EXPECTED hash for verification.

pub const fn with_cbor_format( self, ) -> Configuration<E, I, L, B, O, F, CborFormat>

Sets the format to CBOR with default options.

pub const fn with_deterministic_cbor( self, ) -> Configuration<E, I, L, B, O, F, CborDeterministicFormat>

Sets the format to CBOR with deterministic encoding (Core mode).

pub const fn with_deterministic_bincode( self, ) -> Configuration<E, I, L, B, O, F, BincodeDeterministicFormat>

Sets the format to Bincode with deterministic encoding.

pub const fn with_cbor_options<const DET: u8, const PREF: bool, const NAN: bool, const NZ: bool, const INDEF: bool, const TAGS: bool>( self, ) -> Configuration<E, I, L, B, O, F, CborConfig<DET, PREF, NAN, NZ, INDEF, TAGS>>

Sets the format to CBOR with custom options.

Trait Implementations

impl<E: Clone, I: Clone, L: Clone, B: Clone, O: Clone, F: Clone, FO: Clone> Clone for Configuration<E, I, L, B, O, F, FO>

fn clone(&self) -> Configuration<E, I, L, B, O, F, FO>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Copy, I: Copy, L: Copy, B: Copy, O: Copy, F: Copy, FO: Copy> Copy for Configuration<E, I, L, B, O, F, FO>

impl<E: Debug, I: Debug, L: Debug, B: Debug, O: Debug, F: Debug, FO: Debug> Debug for Configuration<E, I, L, B, O, F, FO>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E, I, L, B, O, F, FO> Default for Configuration<E, I, L, B, O, F, FO>

fn default() -> Self

Returns the “default value” for a type.