Struct Latch

Source

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

Expand description

A one-generation countdown latch.

The state sum is LatchState::Counting or LatchState::Released. Each arrival decrements exactly once. The transition reaching zero atomically changes state to Released and emits one LatchReleased delivery to every accepted participant in arrival order. Later arrivals receive an immediate release. Initialization is empty; zero count starts released. There are no rejection, retry, cancellation, or timer paths. The latch never terminates itself. Countdown and ordering are Bombay workflow policy, while typed delivery is interpreted by Address and Communication.

Latch

Struct Latch Copy item path

Implementations§

impl<A, Route> Latch<A, Route>where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>,

pub fn new(count: usize) -> Self

pub const fn state(&self) -> &LatchState<Route>

Trait Implementations§

impl<A, Route> Behavior for Latch<A, Route>where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>, Route::Sends: SendsFor<User<A, LatchMessage<Route>>>,

type Protocol = Latch<A, Route>

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

type Sends = <Route as DeliveryRoute>::Sends

type Ph = Never

type Error = Never

type Birth = NoBirths

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

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

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

impl<A, Route> BehaviorBase for Latch<A, Route>where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>,

type Base = Latch<A, Route>

fn base(&self) -> &Self

impl<A, Route> Protocol for Latch<A, Route>where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>,

type Addr = A

type Msg = LatchMessage<Route>

Auto Trait Implementations§

impl<A, Route> Freeze for Latch<A, Route>

impl<A, Route> RefUnwindSafe for Latch<A, Route>where Route: RefUnwindSafe,

impl<A, Route> Send for Latch<A, Route>where Route: Send,

impl<A, Route> Sync for Latch<A, Route>where Route: Sync,

impl<A, Route> Unpin for Latch<A, Route>where Route: Unpin,

impl<A, Route> UnsafeUnpin for Latch<A, Route>

impl<A, Route> UnwindSafe for Latch<A, Route>where Route: UnwindSafe,

Blanket Implementations§

impl<B> Activate for Bwhere B: Behavior,

fn initialize(self) -> Result<Initialized<Self>, Self::Error>

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<B> BeginShutdownPhases for Bwhere B: Behavior, <<B as Behavior>::Birth as BirthMode>::Child: ChildOccurrenceProduct<AvailableChildren>,

type Output = ChildShutdownPhases<B, <<<B as Behavior>::Birth as BirthMode>::Child as ChildOccurrenceProduct<AvailableChildren>>::Product, NoPhases>

fn begin_shutdown_phases(self) -> <B as BeginShutdownPhases>::Output

impl<Node> BirthNodeAppend<Never> for Nodewhere Node: NonEmptyBirthNode,

type Output = Node

fn append_prefix(self) -> <Node as BirthNodeAppend<Never>>::Output

fn append_tail(tail: Never) -> <Node as BirthNodeAppend<Never>>::Output

fn append_creations<A>( prefix: Creations<CreateChild<A, Self>>, tail: Creations<CreateChild<A, Tail>>, ) -> Creations<CreateChild<A, Self::Output>>where A: Address,

impl<Child, Tail> BirthNodeAppend<Tail> for Childwhere Child: Behavior, Tail: NonEmptyBirthNode,

type Output = ChildChoice<Child, Tail>

fn append_prefix(self) -> <Child as BirthNodeAppend<Tail>>::Output

fn append_tail(tail: Tail) -> <Child as BirthNodeAppend<Tail>>::Output

fn append_creations<A>( prefix: Creations<CreateChild<A, Self>>, tail: Creations<CreateChild<A, Tail>>, ) -> Creations<CreateChild<A, Self::Output>>where A: Address,

impl<B> BirthProtocols for Bwhere B: Behavior, <B as Behavior>::Birth: BirthModeProtocols,

type Protocols = BirthProtocol<<B as Behavior>::Protocol, <<B as Behavior>::Birth as BirthModeProtocols>::Protocols>

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<Node, Shape> ChildOccurrenceProduct<Shape> for Nodewhere Node: ChildOccurrenceProductAt<ChildHead, Shape>, Shape: ChildOccurrenceShape,

type Product = <Node as ChildOccurrenceProductAt<ChildHead, Shape>>::Product

impl<A, Child, Host> DispatchBirth<A, Host> for Childwhere A: Address, Child: CreateSelectedChild<A, ChildHead, Host>,

fn dispatch_birth( self, id: CreationId, route: <A as Address>::Nonce, kind: CreationKind, host: &mut Host, ) -> impl Future<Output = ItemSettlement<RoutedCreation<A, Child>, <Child as ChildCreationProduct<A, ChildHead>>::Result, CreationRejection, Never>> + Send

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct Latch

impl<A, Route> Latch<A, Route>
where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>,

impl<A, Route> Behavior for Latch<A, Route>
where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>, Route::Sends: SendsFor<User<A, LatchMessage<Route>>>,

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

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

impl<A, Route> BehaviorBase for Latch<A, Route>
where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>,

impl<A, Route> Protocol for Latch<A, Route>
where A: Address, Route: DeliveryRoute, Route::Protocol: Protocol<Addr = A, Msg = LatchReleased>,

impl<A, Route> RefUnwindSafe for Latch<A, Route>
where Route: RefUnwindSafe,

impl<A, Route> Send for Latch<A, Route>
where Route: Send,

impl<A, Route> Sync for Latch<A, Route>
where Route: Sync,

impl<A, Route> Unpin for Latch<A, Route>
where Route: Unpin,

impl<A, Route> UnwindSafe for Latch<A, Route>
where Route: UnwindSafe,

impl<B> Activate for B
where B: Behavior,

impl<T> Any for T
where T: 'static + ?Sized,

impl<B> BeginShutdownPhases for B
where B: Behavior, <<B as Behavior>::Birth as BirthMode>::Child: ChildOccurrenceProduct<AvailableChildren>,

impl<Node> BirthNodeAppend<Never> for Node
where Node: NonEmptyBirthNode,

fn append_creations<A>( prefix: Creations<CreateChild<A, Self>>, tail: Creations<CreateChild<A, Tail>>, ) -> Creations<CreateChild<A, Self::Output>>
where A: Address,

impl<Child, Tail> BirthNodeAppend<Tail> for Child
where Child: Behavior, Tail: NonEmptyBirthNode,

fn append_creations<A>( prefix: Creations<CreateChild<A, Self>>, tail: Creations<CreateChild<A, Tail>>, ) -> Creations<CreateChild<A, Self::Output>>
where A: Address,

impl<B> BirthProtocols for B
where B: Behavior, <B as Behavior>::Birth: BirthModeProtocols,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<Node, Shape> ChildOccurrenceProduct<Shape> for Node
where Node: ChildOccurrenceProductAt<ChildHead, Shape>, Shape: ChildOccurrenceShape,

impl<A, Child, Host> DispatchBirth<A, Host> for Child
where A: Address, Child: CreateSelectedChild<A, ChildHead, Host>,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,