Struct Pod 

pub struct Pod<T: Copy + 'static>(/* private fields */);

Indicates that the type is represented by raw bytes and does not have any invalid bit patterns.

By opting into Pod, you are telling wincode that it can serialize and deserialize a type with a single memcpy – it wont pay attention to things like struct layout, endianness, or anything else that would require validity or bit pattern checks. This is a very strong claim to make, so be sure that your type adheres to those requirements.

Composable with sequence containers or compound types (structs, tuples) for an optimized read/write implementation.

This can be useful outside of sequences as well, for example on newtype structs containing byte arrays with #[repr(transparent)].

---

💡 Note: as of wincode 0.2.0, Pod is no longer needed for types that wincode can determine are “Pod-safe”.

This includes:

• u8
• [u8; N]
• structs comprised of the above, and;
  • annotated with #[derive(SchemaWrite)] or #[derive(SchemaRead)], and;
  • annotated with #[repr(transparent)] or #[repr(C)].

Similarly, using built-in std collections like Vec<T> or Box<[T]> where T is one of the above will also be automatically optimized.

You’ll really only need to reach for Pod when dealing with foreign types for which you cannot derive SchemaWrite or SchemaRead. Or you’re in a controlled scenario where you explicitly want to avoid endianness or layout checks.

Safety

• The type must allow any bit pattern (e.g., no bools, no chars, etc.)
• If used on a compound type like a struct, all fields must be also be Pod, its layout must be guaranteed (via #[repr(transparent)] or #[repr(C)]), and the struct must not have any padding.
• Must not contain references or pointers (includes types like Vec or Box).
  • Note, you may use Pod inside types like Vec or Box, e.g., Vec<Pod<T>> or Box<[Pod<T>]>, but specifying Pod on the outer type is invalid.

Examples

A repr-transparent newtype struct containing a byte array where you cannot derive SchemaWrite or SchemaRead:

#[derive(Serialize, Deserialize, Clone, Copy)]
#[repr(transparent)]
struct Address([u8; 32]);

#[derive(Serialize, Deserialize, SchemaWrite, SchemaRead)]
struct MyStruct {
    #[wincode(with = "Pod<_>")]
    address: Address
}

let my_struct = MyStruct {
    address: Address(array::from_fn(|i| i as u8)),
};
let wincode_bytes = wincode::serialize(&my_struct).unwrap();
let bincode_bytes = bincode::serialize(&my_struct).unwrap();
assert_eq!(wincode_bytes, bincode_bytes);

Trait Implementations

impl<'de, T> SchemaRead<'de> for Pod<T>

where T: Copy + 'static,

const TYPE_META: TypeMeta

type Dst = T

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

Read into dst from reader.

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

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

impl<T> SchemaWrite for Pod<T>

where T: Copy + 'static,

const TYPE_META: TypeMeta

type Src = T

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

Get the serialized size of Self::Src.

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

Write Self::Src to writer.

impl<T> ZeroCopy for Pod<T>

where T: Copy + 'static,

fn from_bytes<'de>(bytes: &'de [u8]) -> ReadResult<&'de Self>

where Self: SchemaRead<'de, Dst = Self> + Sized,

Get a reference to a type from the given bytes.

fn from_bytes_mut<'de>(bytes: &'de mut [u8]) -> ReadResult<&'de mut Self>

where Self: SchemaRead<'de, Dst = Self> + Sized,

Get a mutable reference to a type from the given bytes.