Crate ring_buffer_macro 

A procedural macro for creating compile-time ring buffers (circular buffers).

Usage

Standard Mode (default)

use ring_buffer_macro::ring_buffer;

#[ring_buffer(5)]
struct IntBuffer(i32);

let mut buf = IntBuffer::new();
buf.enqueue(1).unwrap();
buf.enqueue(2).unwrap();
assert_eq!(buf.dequeue(), Some(1));

SPSC Mode (lock-free, thread-safe)

use ring_buffer_macro::ring_buffer;
use std::thread;

#[ring_buffer(capacity = 1024, mode = "spsc")]
struct SpscBuffer(i32);

let buffer = SpscBuffer::new();
let (producer, consumer) = buffer.split();

// Producer and consumer can be sent to different threads

MPSC Mode (multi-producer, single-consumer)

use ring_buffer_macro::ring_buffer;

#[ring_buffer(capacity = 1024, mode = "mpsc")]
struct MpscBuffer(i32);

let buffer = MpscBuffer::new();
let producer1 = buffer.producer();
let producer2 = buffer.producer(); // Can clone for more producers
let consumer = buffer.consumer();

Blocking Mode

#[ring_buffer(capacity = 1024, mode = "mpsc", blocking = true)]
struct BlockingQueue(Message);

// Use enqueue_blocking() and dequeue_blocking() for blocking operations

Generated Methods

Standard Mode

• new() - Create empty buffer
• enqueue(item: T) -> Result<(), T> - Add item (returns Err(item) if full)
• dequeue() -> Option<T> - Remove oldest item (requires T: Clone)
• is_full(), is_empty(), len(), capacity(), clear()

SPSC Mode

• new() - Create empty buffer
• split() - Get producer and consumer handles
• is_full(), is_empty(), len(), capacity()
• Producer: try_enqueue(item: T) -> Result<(), T>
• Consumer: try_dequeue() -> Option<T>

MPSC Mode

• new() - Create empty buffer
• producer() - Get clonable producer handle
• consumer() - Get consumer handle
• Producer: try_enqueue(item: T) -> Result<(), T>, enqueue_blocking(item: T) (if blocking)
• Consumer: try_dequeue() -> Option<T>, dequeue_blocking() -> T (if blocking)

Requirements

• Tuple struct with one element type, e.g., struct Buffer(i32);
• Standard mode: Element type T must implement Clone
• SPSC/MPSC modes: Element type T must implement Send

Attribute Macros

ring_buffer

Transforms a tuple struct into a fixed-size FIFO ring buffer.