Struct HiveDocument 

pub struct HiveDocument {
    pub version: u32,
    pub node_id: NodeId,
    pub counter: GCounter,
    pub peripheral: Option<Peripheral>,
    pub emergency: Option<EmergencyEvent>,
}

A HIVE document for mesh synchronization

Contains header information, a CRDT G-Counter for tracking mesh activity, optional peripheral data for events, and optional emergency event with ACK tracking.

Fields

version: u32

Document version (incremented on each change)

node_id: NodeId

Source node ID that created/last modified this document

counter: GCounter

CRDT G-Counter tracking activity across the mesh

peripheral: Option<Peripheral>

Optional peripheral data (sensor info, events)

emergency: Option<EmergencyEvent>

Optional active emergency event with distributed ACK tracking

Implementations

impl HiveDocument

pub fn new(node_id: NodeId) -> Self

Create a new document for the given node

pub fn with_peripheral(self, peripheral: Peripheral) -> Self

Create with an initial peripheral

pub fn with_emergency(self, emergency: EmergencyEvent) -> Self

Create with an initial emergency event

pub fn increment_version(&mut self)

Increment the document version

pub fn increment_counter(&mut self)

Increment the counter for this node

pub fn set_event(&mut self, event_type: EventType, timestamp: u64)

Set an event on the peripheral

pub fn clear_event(&mut self)

Clear the event from the peripheral

pub fn set_emergency( &mut self, source_node: u32, timestamp: u64, known_peers: &[u32], )

Set an emergency event

Creates a new emergency event with the given source node, timestamp, and list of known peers to track for ACKs.

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

Record an ACK for the current emergency

Returns true if the ACK was new (state changed)

pub fn clear_emergency(&mut self)

Clear the emergency event

pub fn get_emergency(&self) -> Option<&EmergencyEvent>

Get the current emergency event (if any)

pub fn has_emergency(&self) -> bool

Check if there’s an active emergency

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

Merge with another document using CRDT semantics

Returns true if our state changed (useful for triggering re-broadcast)

pub fn current_event(&self) -> Option<EventType>

Get the current event type (if any)

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

Encode to bytes for BLE transmission

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

Decode from bytes received over BLE

pub fn total_count(&self) -> u64

Get the total counter value

pub fn encoded_size(&self) -> usize

Get the encoded size of this document

Use this to check if the document fits within BLE MTU constraints.

pub fn exceeds_target_size(&self) -> bool

Check if the document exceeds the target size for single-packet transmission

Returns true if the document is larger than TARGET_DOCUMENT_SIZE.

pub fn exceeds_max_size(&self) -> bool

Check if the document exceeds the maximum size

Returns true if the document is larger than MAX_DOCUMENT_SIZE.

Trait Implementations

impl Clone for HiveDocument

fn clone(&self) -> HiveDocument

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HiveDocument

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

Formats the value using the given formatter.

impl Default for HiveDocument

fn default() -> Self

Returns the “default value” for a type.