Struct Discard 

pub struct Discard<Inner>(/* private fields */);

Reads a value with the Inner schema purely to advance the reader, then throws it away and yields Default::default() instead.

Inner is a schema, its bytes are consumed exactly as Inner would consume them — including any validation Inner performs — so the surrounding stream stays in sync, but the decoded value is dropped and the field is filled with the Default of Inner’s SchemaRead::Dst.

It is meant for fields you don’t want to persist, such as a deprecated field kept only for wire compatibility. On read the encoded value is stepped over and reset to its Default; on write the value held in the instance is likewise ignored and Inner’s Default is serialized in its place. The two directions agree, so Discard works on types deriving both SchemaWrite and SchemaRead — with the caveat that the original value is not preserved across a round-trip: a discarded field always reads back, and re-serializes, as the default.

For a length-prefixed sequence, prefer DiscardSeq, which steps over every element without allocating a backing buffer.

#[derive(SchemaWrite, SchemaRead, Debug, PartialEq)]
struct Full {
    ignored: u32,
    kept: u16,
}

#[derive(SchemaWrite, SchemaRead, Debug, PartialEq)]
struct Partial {
    #[wincode(with = "Discard<u32>")]
    ignored: u32,
    kept: u16,
}

// On read, `ignored` is stepped over and reset to its default.
let bytes = wincode::serialize(&Full { ignored: 7, kept: 9 }).unwrap();
assert_eq!(
    wincode::deserialize::<Partial>(&bytes).unwrap(),
    Partial { ignored: 0, kept: 9 },
);

// On write, the held value of `ignored` is discarded and its default is
// serialized, so the output matches a `Full` whose `ignored` is `0`.
let out = wincode::serialize(&Partial { ignored: 7, kept: 9 }).unwrap();
assert_eq!(out, wincode::serialize(&Full { ignored: 0, kept: 9 }).unwrap());

Trait Implementations

impl<'de, C, Inner> SchemaRead<'de, C> for Discard<Inner>

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

const TYPE_META: TypeMeta

Metadata about the type’s serialization.

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

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

Read into dst from reader.

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

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

impl<C, Inner> SchemaWrite<C> for Discard<Inner>

where C: ConfigCore, Inner: SchemaWrite<C>, Inner::Src: Default,

const TYPE_META: TypeMeta

Metadata about the type’s serialization.

type Src = <Inner 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.