Struct Manifest 

pub struct Manifest<'a> {
    pub type_name: &'a str,
    pub schema_version: u32,
    pub layout: LayoutSpec,
    pub fields: &'a [FieldSpec<'a>],
    pub variants: &'a [VariantSpec<'a>],
    pub evolution: EvolutionSpec<'a>,
}

The semantic manifest: the single source of truth drivers read.

Fields

type_name: &'a str

Fully spelled type name, e.g. "my_crate::User".

schema_version: u32

Monotonic schema version (1 for the first revision).

layout: LayoutSpec

In-memory layout of the type.

fields: &'a [FieldSpec<'a>]

Fields in declaration order (for a struct; empty for an enum).

variants: &'a [VariantSpec<'a>]

Variants in declaration order (for a fieldless enum; empty for a struct).

evolution: EvolutionSpec<'a>

How this version relates to its predecessor.

Implementations

impl Manifest<'_>

pub const fn packed_field_bytes(&self) -> usize

Sum of the sizes of all fields, ignoring inter-field padding.

pub const fn padding_bytes(&self) -> usize

Bytes of padding the compiler inserted between/after fields.

A return value of 0 means the layout is gap-free — the precondition a zerocopy driver checks before treating the type as plain bytes.

pub const fn is_gap_free(&self) -> bool

Whether the layout has no padding holes (gap-free).

pub const fn extends(&self, prev: &Manifest<'_>) -> bool

Whether self is a layout-compatible, append-only extension of prev: every field of prev is still present, at the same offset, size and type.

This is the compile-time precondition for evolving a zerocopy type while keeping old readers valid — new fields may only be appended, never inserted, reordered, resized or retyped. The type check matters: a field silently changed from u32 to f32 keeps the same offset and size but reinterprets the bytes, so it must not pass. Pair with assert_compatible!.

Trait Implementations

impl<'a> Clone for Manifest<'a>

fn clone(&self) -> Manifest<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Manifest<'a>

impl<'a> Debug for Manifest<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Manifest<'a>

impl<'a> PartialEq for Manifest<'a>

fn eq(&self, other: &Manifest<'a>) -> 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<'a> StructuralPartialEq for Manifest<'a>