Struct LazySharedRing 

pub struct LazySharedRing { /* private fields */ }

Defer the file-backed MMF setup until first use.

When to reach for this: speculative channel construction where the consumer may or may not ever send/recv (per-connection channels that some connections never use, conditional code paths, option-types that hold a ring “just in case”). Construction is free; the file create + ftruncate + mmap + init cost is paid once on the first try_push or try_pop call.

When NOT to reach for this: in-process-only one-shots (use SharedRing::create_anon instead, which skips the file entirely), or hot paths that always send (the lazy branch costs one extra atomic load per op vs holding &SharedRing directly).

Hot-path tip: materialise once outside your loop and reuse the returned &SharedRing reference so the lazy branch lives outside the inner loop.

Implementations

impl LazySharedRing

pub fn new(path: impl Into<PathBuf>, capacity: usize) -> Self

Construct a lazy ring. No syscalls; just stores the path and capacity for the deferred create.

pub fn get(&self) -> Result<&SharedRing, RingError>

Materialise the inner ring, paying the setup cost on the first call and returning the cached reference thereafter.

pub fn is_initialised(&self) -> bool

Whether the underlying ring has been materialised yet.

pub fn try_push(&self, payload: &[u8]) -> Result<(), RingError>

Forwarded SharedRing::try_push; materialises on first call.

pub fn try_pop(&self, out: &mut [u8]) -> Result<usize, RingError>

Forwarded SharedRing::try_pop; materialises on first call.