Struct Barrier 

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

Fixed-membership cyclic barrier behavior.

Each generation accepts every configured key exactly once. The final arrival commits the successor generation before emitting one BarrierReleased delivery to every arrival recipient in arrival order. Stale, future, duplicate, unknown, and exhausted arrivals are distinct typed errors and preserve state. At u64::MAX, the final release commits BarrierState::Exhausted instead of inferring wraparound. Initialization is empty and the behavior never terminates itself. Membership, generation, and release ordering are Bombay workflow policy; delivery is interpreted by Address and Communication. Construction rejects empty or duplicate membership. No method has a semantic panic condition.

Implementations

impl<A, K, Route> Barrier<A, K, Route>

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

pub fn new(membership: BarrierMembership<K>) -> Self

Bind validated membership to generation zero of a barrier actor.

pub fn members(&self) -> &[K]

Fixed participant keys in definition order.

pub const fn state(&self) -> &BarrierState<K, Route>

Borrow the complete current generation state.

Trait Implementations

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

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

type Protocol = Barrier<A, K, Route>

Stable public communication identity owned by this actor template.

type Event = User<A, <<Barrier<A, K, Route> as Behavior>::Protocol as Protocol>::Msg>

type Sends = <Route as DeliveryRoute>::Sends

type Ph = Never

type Error = BarrierError<K, Route>

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 Barrier<A, K, Route>

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

type Base = Barrier<A, K, Route>

fn base(&self) -> &Self

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

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

type Addr = A

type Msg = BarrierMessage<K, Route>