Struct ZeroCopyOrderBookUpdate

#[repr(C)]
pub struct ZeroCopyOrderBookUpdate<const N: usize = 10> {
    pub symbol_id: u32,
    pub _padding1: u32,
    pub sequence: u64,
    pub timestamp_ns: u64,
    pub bid_count: u8,
    pub ask_count: u8,
    pub _padding2: [u8; 6],
    pub bids: [ZeroCopyPriceLevel; N],
    pub asks: [ZeroCopyPriceLevel; N],
}

Zero-copy order book update with const generic array sizing

Fixed-size structure for receiving binary order book updates from exchanges. Supports up to N levels per side where N is compile-time configurable.

NOTE: Cannot derive Pod/Zeroable due to const generic parameter N. Bytemuck doesn’t support generic arrays [T; N] for arbitrary N. We maintain manual unsafe implementations for this struct only.

Fields

symbol_id: u32

Symbol identifier (exchange-specific)

_padding1: u32

Padding for alignment

sequence: u64

Sequence number for detecting gaps

timestamp_ns: u64

Exchange timestamp in nanoseconds

bid_count: u8

Number of valid bid levels (0-N)

ask_count: u8

Number of valid ask levels (0-N)

_padding2: [u8; 6]

Padding for alignment

bids: [ZeroCopyPriceLevel; N]

Bid levels (only first bid_count are valid)

asks: [ZeroCopyPriceLevel; N]

Ask levels (only first ask_count are valid)

Implementations

impl<const N: usize> ZeroCopyOrderBookUpdate<N>

pub fn valid_bids(&self) -> &[ZeroCopyPriceLevel]

Get valid bid levels as a slice

pub fn valid_asks(&self) -> &[ZeroCopyPriceLevel]

Get valid ask levels as a slice

impl<const N: usize> ZeroCopyOrderBookUpdate<N>

pub const fn as_bytes(&self) -> &[u8]

Convert this structure to bytes

Safety

This uses unsafe to convert the struct to a byte slice. Safe because:

• The struct is #[repr(C)] with known layout
• All fields are Pod types (primitives and arrays of Pod)
• No padding issues due to explicit padding fields

NOTE: We can’t use bytemuck::bytes_of here because this struct can’t implement Pod due to the const generic parameter N.

pub const fn new_zeroed() -> Self

Create a new zeroed instance

Safety

This uses unsafe to create a zeroed instance. Safe because:

• All fields are primitives or arrays of primitives
• Zero is a valid bit pattern for all our fields
• No references or other types that could be invalid when zeroed

NOTE: We can’t use bytemuck::Zeroable::zeroed() here because this struct can’t implement Zeroable due to the const generic parameter N.

pub const fn size() -> usize

Get the size of this structure at compile time

pub const fn max_levels() -> usize

Get the maximum number of levels per side

pub const fn buffer_size_for_levels(levels: usize) -> usize

Calculate total buffer size needed for N levels

pub const fn has_valid_bid_count(&self) -> bool

Check if the update has valid bid count

pub const fn has_valid_ask_count(&self) -> bool

Check if the update has valid ask count

pub fn from_bytes(bytes: &[u8]) -> Option<&Self>

Create from bytes

Uses the generic parse_message_generic function which handles types that can’t implement Pod due to const generics.

Trait Implementations

impl<const N: usize> Clone for ZeroCopyOrderBookUpdate<N>

fn clone(&self) -> ZeroCopyOrderBookUpdate<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for ZeroCopyOrderBookUpdate<N>

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

Formats the value using the given formatter.

impl<const N: usize> Copy for ZeroCopyOrderBookUpdate<N>