Struct EmergencyEvent 

pub struct EmergencyEvent { /* private fields */ }

An emergency event with acknowledgment tracking (CRDT)

Represents a single emergency incident with distributed ACK tracking. Each node in the mesh can acknowledge the emergency, and this state is replicated across all nodes using CRDT semantics.

CRDT Semantics

• Identity: Events are uniquely identified by (source_node, timestamp)
• Merge for same event: ACK maps merge with OR (once acked, stays acked)
• Merge for different events: Higher timestamp wins (newer emergency replaces older)
• Monotonic: ACK state only moves from false → true, never back

Wire Format

source_node: 4 bytes (LE)
timestamp:   8 bytes (LE)
num_acks:    4 bytes (LE)
acks[N]:
  node_id:   4 bytes (LE)
  acked:     1 byte (0 or 1)

Implementations

impl EmergencyEvent

pub fn new(source_node: u32, timestamp: u64, known_peers: &[u32]) -> Self

Create a new emergency event

Arguments

• source_node - Node ID that triggered the emergency
• timestamp - When the emergency was triggered
• known_peers - List of peer node IDs to track for ACKs

The source node is automatically marked as acknowledged.

pub fn source_node(&self) -> u32

Get the source node that triggered the emergency

pub fn timestamp(&self) -> u64

Get the timestamp when the emergency was triggered

pub fn has_acked(&self, node_id: u32) -> bool

Check if a specific node has acknowledged

pub fn ack(&mut self, node_id: u32) -> bool

Record an acknowledgment from a node

Returns true if this was a new ACK (state changed)

pub fn add_peer(&mut self, node_id: u32)

Add a peer to track (if not already present)

New peers start as not-acked. This is useful when discovering new peers after the emergency was created.

pub fn acked_nodes(&self) -> Vec<u32>

Get list of nodes that have acknowledged

pub fn pending_nodes(&self) -> Vec<u32>

Get list of nodes that have NOT acknowledged

pub fn all_nodes(&self) -> Vec<u32>

Get all tracked node IDs (both acked and pending)

pub fn all_acked(&self) -> bool

Check if all tracked nodes have acknowledged

pub fn peer_count(&self) -> usize

Get the total number of tracked nodes

pub fn ack_count(&self) -> usize

Get the number of nodes that have acknowledged

pub fn merge(&mut self, other: &EmergencyEvent) -> bool

Merge with another emergency event (CRDT semantics)

Returns

true if our state changed

Semantics

• Same event (source_node, timestamp): merge ACK maps with OR
• Different event: take the one with higher timestamp

pub fn encode(&self) -> Vec<u8>

Encode to bytes for transmission

Format: source_node(4) + timestamp(8) + num_acks(4) + acks[N](5 each)

pub fn decode(data: &[u8]) -> Option<Self>

Decode from bytes with validation

Security

Validates source_node, timestamp, and limits ACK entries to prevent DoS. Rejects garbage data that could indicate spoofing or corruption.

Trait Implementations

impl Clone for EmergencyEvent

fn clone(&self) -> EmergencyEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EmergencyEvent

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

Formats the value using the given formatter.

impl Default for EmergencyEvent

fn default() -> EmergencyEvent

Returns the “default value” for a type.

impl PartialEq for EmergencyEvent

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