Enum TypeMeta 

pub enum TypeMeta {
    Static {
        size: usize,
        zero_copy: bool,
    },
    Dynamic,
}

Indicates what kind of assumptions can be made when encoding or decoding a type.

Readers and writers may use this to optimize their behavior.

Variants

Static

The type has a statically known serialized size.

Specifying this variant can have significant performance benefits, as it can allow writers to prefetch larger chunks of memory such that subsequent read/write operations in those chunks can be performed at once without intermediate bounds checks.

Specifying this variant incorrectly will almost certainly result in a panic at runtime.

Take care not to specify this on variable length types, like Vec or String, as their serialized size will vary based on their length.

Fields

size: usize

The static serialized size of the type.

zero_copy: bool

Whether the type is eligible for zero-copy encoding/decoding.

This indicates that the type has no invalid bit patterns, no layout requirements, no endianness checks, etc. This is a very strong claim that should be used judiciously.

Specifying this incorrectly may trigger UB.

Dynamic

The type has a dynamic size, and no optimizations can be made.

Implementations

impl TypeMeta

pub const fn keep_zero_copy(self, keep_zero_copy: bool) -> Self

Returns this TypeMeta instance with zero_copy masked by keep_zero_copy.

For TypeMeta::Static, this preserves size and computes: zero_copy = zero_copy && keep_zero_copy.

For TypeMeta::Dynamic, this is a no-op.

This method never upgrades a type to zero-copy.

• keep_zero_copy(true) leaves the flag unchanged.
• keep_zero_copy(false) clears the flag.

pub const fn join_types<const N: usize>(types: [Self; N]) -> Self

Combines multiple constituent TypeMeta values into one aggregate.

Intended for composite types whose constituents are serialized sequentially.

Semantics:

• If any input is Dynamic, returns Dynamic.
• Otherwise returns Static with:
  • size = sum of all constituent sizes
  • zero_copy = logical AND of all constituent zero_copy flags

Notes:

• This function does not validate layout/padding; it only combines metadata.
• For N = 0, the result is TypeMeta::Static { size: 0, zero_copy: true }.
• The caller must ensure the summed size is meaningful for the target type.

use wincode::TypeMeta;

let types = [
    TypeMeta::Static { size: 1, zero_copy: true },
    TypeMeta::Static { size: 2, zero_copy: true },
    TypeMeta::Dynamic,
    TypeMeta::Static { size: 3, zero_copy: true },
];
assert_eq!(TypeMeta::join_types(types), TypeMeta::Dynamic);

use wincode::TypeMeta;

let types = [
    TypeMeta::Static { size: 1, zero_copy: true },
    TypeMeta::Static { size: 2, zero_copy: true },
    TypeMeta::Static { size: 3, zero_copy: true },
];
assert_eq!(TypeMeta::join_types(types), TypeMeta::Static { size: 6, zero_copy: true });

use wincode::TypeMeta;

let types = [
    TypeMeta::Static { size: 1, zero_copy: true },
    TypeMeta::Static { size: 2, zero_copy: false },
    TypeMeta::Static { size: 3, zero_copy: true },
];
assert_eq!(TypeMeta::join_types(types), TypeMeta::Static { size: 6, zero_copy: false });

Trait Implementations

impl Clone for TypeMeta

fn clone(&self) -> TypeMeta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeMeta

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

Formats the value using the given formatter.

impl PartialEq for TypeMeta

fn eq(&self, other: &TypeMeta) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for TypeMeta

impl Eq for TypeMeta

impl StructuralPartialEq for TypeMeta