Struct EventChannel 

pub struct EventChannel<T> {
    pub events: Vec<T>,
    pub base_sequence: u64,
    pub previous_update_sequence: u64,
}

A sequence-numbered event channel for inter-system communication.

Events live in one flat Vec and every event gets a monotonically increasing sequence number, the same cursor scheme the structural log uses. Two consumption styles are supported:

• Frame-scoped: read() sees every buffered event, and update() once per frame expires events after they have been visible for two frames, matching the old double-buffer lifetime.
• Cursor-based, exactly-once: each consumer records sequence() after reading events_since(cursor). Multiple consumers each see every event exactly once, and a consumer that skips a frame catches up instead of double-processing or missing events.

Examples

use freecs::EventChannel;

#[derive(Debug, Clone)]
struct DamageEvent { amount: i32 }

let mut channel = EventChannel::new();

channel.send(DamageEvent { amount: 10 });
assert_eq!(channel.len(), 1);

let mut cursor = 0;
let seen = channel.events_since(cursor);
assert_eq!(seen.len(), 1);
cursor = channel.sequence();

assert!(channel.events_since(cursor).is_empty(), "cursor consumers see each event once");

channel.update();
assert_eq!(channel.len(), 1, "event persists after first update");

channel.update();
assert_eq!(channel.len(), 0, "event expired after second update");

Fields

events: Vec<T>

base_sequence: u64

previous_update_sequence: u64

Implementations

impl<T> EventChannel<T>

pub fn new() -> Self

pub fn send(&mut self, event: T)

Sends an event. It stays readable until it expires two update() calls later or a cursor consumer trims past it.

pub fn sequence(&self) -> u64

The sequence number of the most recently sent event. Record this as your cursor after consuming events_since.

pub fn events_since(&self, cursor: u64) -> &[T]

All buffered events sent after cursor, oldest first. A cursor older than the buffer yields everything still buffered.

pub fn consume(&self, cursor: &mut u64) -> &[T]

The exactly-once read: yields every event sent after cursor and advances the cursor past them, so calling this every frame delivers each event to this consumer exactly once. Each consumer owns one u64 cursor; the buffer itself is untouched, so other consumers and the two-frame expiry are unaffected. This is the spelling to reach for by default; read() re-reads the whole buffer every call.

pub fn read(&self) -> impl Iterator<Item = &T>

Returns an iterator over every buffered event, oldest first.

pub fn read_frame(&self) -> &[T]

The events settled at the last update: the previous frame’s complete set, frozen and broadcast to every reader without a cursor. Events sent since that update (this frame’s sends) are excluded, so the slice does not change as more events arrive during the frame. A reader that calls this once per frame therefore sees each frame’s events exactly once, one frame after they were sent, regardless of where in the frame it reads and of interleaving with senders. This is the broadcast, single-frame counterpart to the cursor-based consume: use it when every reader must observe the same frozen set for a frame, as a deferred event pipeline does.

pub fn peek(&self) -> Option<&T>

Returns a reference to the oldest buffered event, if any.

pub fn trim(&mut self, up_to_sequence: u64)

Drops all events up to and including up_to_sequence. Call with the minimum cursor across consumers to reclaim memory early.

pub fn update(&mut self)

Expires events that have now been visible for two frames. Call once per frame; step() on a generated world does this for every channel.

pub fn clear(&mut self)

Immediately drops every buffered event, advancing past them.

pub fn len(&self) -> usize

Returns the number of buffered events.

pub fn is_empty(&self) -> bool

Returns true if no events are buffered.

Trait Implementations

impl<T: Clone> Clone for EventChannel<T>

fn clone(&self) -> EventChannel<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Default for EventChannel<T>

fn default() -> Self

Returns the “default value” for a type.