Struct Resolver 

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

Immutable read-only typed resolver behavior.

Construction copies a borrowed unique binding definition, so rejection cannot consume caller ownership. The public protocol contains only ResolverMessage::Resolve, making registry mutation authority unrepresentable for holders of a resolver recipient. Every lookup emits one factual Resolution, including absence. Binding order is retained for deterministic inspection but does not affect lookup meaning. Initialization is empty, the behavior creates no actors, never terminates by policy, and requires only typed delivery. Capability separation and missing-as-fact are Bombay policy; endpoint validity is interpreted by Bombay Address. No method has a semantic panic condition.

Implementations

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

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

pub fn from_bindings( bindings: &[(K, Recipient<D>)], ) -> Result<Self, ResolverConfigError<K>>

Copy one borrowed immutable binding definition.

Errors

Returns ResolverConfigError::DuplicateKey for the first duplicate; the borrowed source remains owned by the caller.

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

Borrow the complete immutable binding definition.

Trait Implementations

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

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

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

Stable public communication identity owned by this actor template.

type Event = User<A, <<Resolver<A, K, D, 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>

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

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

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

fn base(&self) -> &Self

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

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

type Addr = A

type Msg = ResolverMessage<K, Route>