Struct DefaultOnEmptyRead 

pub struct DefaultOnEmptyRead<T>(/* private fields */);

Deserializes using the wire schema T normally, but yields T::Dst::default() when the reader is exhausted (hits EOF) instead of erroring.

The purpose is backward compatibility when new fields are appended to the tail of a persisted struct: older, shorter encodings that predate those fields still decode, with the missing trailing fields filled from their Default value. Reading a full encoding is unaffected.

Writing is unchanged — the value is serialized exactly as T would, producing bytes that decode identically with or without this adapter. Only the read path differs, so this is purely a decode-time compatibility shim.

Apply it via the with attribute on the (necessarily trailing) fields it covers, naming the field’s own schema as T:

#[derive(SchemaWrite, SchemaRead, Debug, PartialEq)]
struct Record {
    id: u32,
    // Appended in a later version; older encodings omit it entirely.
    #[wincode(with = "DefaultOnEmptyRead<u64>")]
    added_later: u64,
}

// A full encoding round-trips as usual.
let record = Record { id: 7, added_later: 42 };
let bytes = wincode::serialize(&record).unwrap();
assert_eq!(record, wincode::deserialize(&bytes).unwrap());

// An older encoding that predates `added_later` decodes to its default.
let legacy = wincode::serialize(&7u32).unwrap();
let decoded: Record = wincode::deserialize(&legacy).unwrap();
assert_eq!(decoded, Record { id: 7, added_later: 0 });

Warning

The fallback is driven purely by running out of bytes, so it is only sound where “no more bytes” unambiguously means “this optional tail is absent”:

• Do not use it on sequence elements. When more items follow, a missing field does not produce EOF — the read simply continues into the bytes that encode the next item. Instead of defaulting the absent field, the decoder consumes the following item’s data, desynchronizing the rest of the sequence. The fallback only helps when the missing bytes are genuinely the end of input.
• Do not use it on a middle field followed by an always-present field. The fallback catches any size-limit error from T, including a partially-present value, so a genuinely truncated field is masked instead of reported and the fields after it are misaligned. It is only safe on a trailing run of fields where every field from the first DefaultOnEmptyRead onward is itself optional-on-EOF.

Prefer applying it to trailing fields of a top-level struct decoded with deserialize_exact, where reaching EOF exactly at a field boundary is well defined and the end-of-input check is straightforward and cheap.

Trait Implementations

impl<'de, C, T> SchemaRead<'de, C> for DefaultOnEmptyRead<T>

where C: ConfigCore, T: SchemaRead<'de, C>, T::Dst: Default,

type Dst = <T as SchemaRead<'de, C>>::Dst

fn read( reader: impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

Read into dst from reader.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

Metadata about the type’s serialization.

fn get(reader: impl Reader<'de>) -> ReadResult<Self::Dst>

Read Self::Dst from reader into a new Self::Dst.

impl<C, T> SchemaWrite<C> for DefaultOnEmptyRead<T>

where C: ConfigCore, T: SchemaWrite<C>,

const TYPE_META: TypeMeta

Metadata about the type’s serialization.

type Src = <T as SchemaWrite<C>>::Src

fn size_of(src: &Self::Src) -> WriteResult<usize>

Get the serialized size of Self::Src.

fn write(writer: impl Writer, src: &Self::Src) -> WriteResult<()>

Write Self::Src to writer.