Struct UseIntLen 

pub struct UseIntLen<T, const PREALLOCATION_SIZE_LIMIT: usize = PREALLOCATION_SIZE_LIMIT_USE_CONFIG>(/* private fields */);

Use the configuration’s integer encoding for sequence length encoding.

For example, if the configuration’s integer encoding is FixInt, then UseIntLen<u64> will use the fixed-width u64 encoding. If the configuration’s integer encoding is VarInt, then UseIntLen<u64> will use the variable-width u64 encoding.

This is bincode’s default behavior.

Allows overriding the preallocation size limit per individual use.

Examples

Override the preallocation size limit to 8 bytes.

type Max8Bytes = UseIntLen<u32, 8>;

#[derive(SchemaWrite, SchemaRead)]
struct OverrideLen {
    #[wincode(with = "containers::Vec<u8, Max8Bytes>")]
    bytes: Vec<u8>,
}

let data_ok = OverrideLen { bytes: vec![0; 8] };
let serialized = wincode::serialize(&data_ok).unwrap();
assert!(wincode::deserialize::<OverrideLen>(&serialized).is_ok());

let data_err = OverrideLen { bytes: vec![0; 9] };
assert!(wincode::serialize(&data_err).is_err());
let serialized = wincode::serialize(&vec![0; 9]).unwrap();
assert!(wincode::deserialize::<OverrideLen>(&serialized).is_err());

Trait Implementations

impl<const PREALLOCATION_SIZE_LIMIT: usize, T, C: ConfigCore> SeqLen<C> for UseIntLen<T, PREALLOCATION_SIZE_LIMIT>

where T: SchemaWrite<C> + for<'de> SchemaRead<'de, C>, T::Src: TryFrom<usize>, usize: for<'de> TryFrom<<T as SchemaRead<'de, C>>::Dst>,

const PREALLOCATION_SIZE_LIMIT_OVERRIDE: PreallocationLimitOverride

SeqLen level override of configured preallocation size limit, in bytes.

fn read<'de>(reader: impl Reader<'de>) -> ReadResult<usize>

Read the length of a sequence, without doing any preallocation size checks.

fn write(writer: impl Writer, len: usize) -> WriteResult<()>

Write the length of a sequence to the writer.

fn write_bytes_needed(len: usize) -> WriteResult<usize>

Calculate the number of bytes needed to write the given length.

fn prealloc_check<T>(len: usize) -> Result<(), PreallocationError>

fn read_prealloc_check<'de, T>(reader: impl Reader<'de>) -> ReadResult<usize>

Read the length of a sequence from the reader, where T is the type of the sequence elements. This can be used to enforce size constraints for preallocations.

fn write_bytes_needed_prealloc_check<T>(len: usize) -> WriteResult<usize>

Calculate the number of bytes needed to write the given length.