Struct Registry 

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

Insertion-ordered typed recipient registry.

State is a sequence of unique key/recipient bindings. Inputs are RegistryMessage values and lookup outputs are one typed behavior::Delivery. Initialization is empty. Duplicate bind, absent unbind, and stale unbind are explicit errors and leave state unchanged. Lookups never fail: absence is a factual RegistryResult::Missing. The actor does not terminate by policy. Ordering and conflict behavior are deliberate Bombay policy; endpoint generation and delivery are interpreted by Bombay Address and Communication.

Implementations

impl<A, K, D, Route> Registry<A, K, D, Route>

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

pub const fn new() -> Self

Construct an empty registry definition.

pub fn bindings(&self) -> &[(K, Recipient<D>)]

Current bindings in establishment order.

Trait Implementations

impl<A, K, D, Route> Behavior for Registry<A, K, D, Route>

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

type Protocol = Registry<A, K, D, Route>

Stable public communication identity owned by this actor template.

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

type Sends = <Route as DeliveryRoute>::Sends

type Ph = Never

type Error = RegistryError<K, D>

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, D, Route> BehaviorBase for Registry<A, K, D, Route>

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

type Base = Registry<A, K, D, Route>

fn base(&self) -> &Self::Base

impl<A, K, D, Route> Default for Registry<A, K, D, Route>

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

fn default() -> Self

Returns the “default value” for a type.

impl<A, K, D, Route> Protocol for Registry<A, K, D, Route>

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

type Addr = A

type Msg = RegistryMessage<K, D, Route>