Struct Presence 

pub struct Presence<A: Address, K, Route: DeliveryRoute<Protocol: Protocol<Addr = A, Msg = PresenceReply<K>>>> { /* private fields */ }

Versioned, generation-safe membership-presence behavior.

The first announcement commits generation zero before requesting expiry. Greater evidence versions refresh with a checked fresh generation; identical evidence is idempotent and does not reschedule. Lower or contradictory evidence is rejected atomically. A timer-key collision with another live participant is rejection, never replacement. Matching elapsed evidence commits an explicit tombstone and reports expiry. Generations advance per timer key across every retained participant tombstone, so reuse by a later participant cannot reinterpret delayed evidence from an earlier owner; stale and unknown timer evidence is inert. Initialization is empty, no actors are created, and the host never terminates by policy. Versioning, first-observation ordering, timer mapping, and tombstone retention are Bombay policy. Scheduling belongs to Timers; release/cancellation is not part of this announcement protocol. No transition has a semantic panic condition.

Implementations

impl<A, K, Route> Presence<A, K, Route>

where A: Address, K: Clone + Eq, Route: DeliveryRoute<Protocol: Protocol<Addr = A, Msg = PresenceReply<K>>> + Clone,

pub const fn new(timer_id: fn(&K) -> TimerId) -> Self

Construct an empty presence table with a pure actor-local timer mapping.

pub fn report(&self) -> PresenceReport<K>

Snapshot complete present and tombstoned state.

Trait Implementations

impl<A, K, Route> Behavior for Presence<A, K, Route>

where A: Address, K: Clone + Eq, Route: DeliveryRoute<Protocol: Protocol<Addr = A, Msg = PresenceReply<K>>> + Clone, Route::Sends: SendsFor<TimedEvent<User<A, PresenceMessage<K, Route>>>>,

type Protocol = Presence<A, K, Route>

Stable public communication identity owned by this actor template.

type Event = EventLayer<TimerElapsed, User<A, <<Presence<A, K, Route> as Behavior>::Protocol as Protocol>::Msg>>

type Sends = PresenceSends<<Route as DeliveryRoute>::Sends, InterpreterRequests<ScheduleAfter>>

type Ph = Never

type Error = Never

type Birth = NoBirths

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> BehaviorActed<Self>

Fold exactly one event into explicit actions and the next behavior.

fn init( &mut self, _turn: InitializationTurn, ) -> Result<Actions<<Self::Protocol as Protocol>::Addr, Self::Ph, Self::Sends, Self::Birth>, Self::Error>

where Self: Sized,

Produce initialization actions before the first event is accepted.

fn layer<L>(self, layer: L) -> <L as BehaviorLayer<Self>>::Output

where Self: Sized, L: BehaviorLayer<Self>,

Apply one statically dispatched construction layer.

impl<A, K, Route> BehaviorBase for Presence<A, K, Route>

where A: Address, Route: DeliveryRoute<Protocol: Protocol<Addr = A, Msg = PresenceReply<K>>>,

type Base = Presence<A, K, Route>

fn base(&self) -> &Self

impl<A, K, Route> Protocol for Presence<A, K, Route>

where A: Address, Route: DeliveryRoute<Protocol: Protocol<Addr = A, Msg = PresenceReply<K>>>,

type Addr = A

type Msg = PresenceMessage<K, Route>