Struct MessageAdapterWithRoute 

pub struct MessageAdapterWithRoute<Input, Route>
where
    Route: DeliveryRoute,
{ /* private fields */ }

A pure actor that maps one input protocol into one destination protocol.

For every accepted Input, the adapter invokes its function pointer exactly once. If that invocation returns normally, the transition emits exactly one effect selected by DeliveryRoute and continues with the same behavior. A logical recipient produces Delivery and an established recipient produces EstablishedDelivery. Initialization emits no effects; the adapter cannot create actors, enter another phase, stop itself, or return a controlled error. In particular, it cannot address a creator-local child: its behavior::NoBirths algebra supplies no local binding for an interpreter to resolve.

This is a derived Bombay protocol composition, not an additional actor-model primitive. Delivery is interpreted as an ordinary actor communication, so the destination observes the adapter actor as the sender. The adapter has no channel, runtime handle, task, I/O, or hidden effect.

The mapper is deliberately a function pointer rather than a closure or erased callable. Consequently, the complete adapter type remains nameable in birth products, child products, supervisors, and topology evidence. If the mapper panics, unwinding follows the same runtime policy as a panic from any other Behavior fold; no successful Actions value is returned.

A creator-local child route is not a valid standalone adapter destination:

struct Destination;
impl behavior::Protocol for Destination {
    type Addr = behavior::MailAddr;
    type Msg = u16;
}
fn adapt(value: u8) -> u16 { u16::from(value) }
let destination = behavior::Recipient::<Destination>::global(behavior::MailAddr(1));
let _ = behavior_actors::MessageAdapterWithRoute::new(destination, adapt);

struct Destination;
impl behavior::Protocol for Destination {
    type Addr = behavior::MailAddr;
    type Msg = u16;
}
fn adapt(value: u8) -> u16 { u16::from(value) }
let mut sequence = behavior::CreationSequence::new();
let creation = sequence.issue().expect("fixture creation ID");
let child = behavior::ChildDelivery::<Destination, behavior::ChildHead>::after(creation, 1);
let _ = behavior_actors::MessageAdapterWithRoute::new(child, adapt);

Implementations

impl<Input, Route> MessageAdapterWithRoute<Input, Route>

where Route: DeliveryRoute,

pub const fn new( destination: Route, adapt: fn(Input) -> <Route::Protocol as Protocol>::Msg, ) -> Self

Construct an adapter for one concrete destination protocol.

pub const fn destination(&self) -> &Route

Return the destination routing intent.

Trait Implementations

impl<Input, Route> Behavior for MessageAdapterWithRoute<Input, Route>

where Route: DeliveryRoute + Clone, Route::Sends: SendsFor<User<<Route::Protocol as Protocol>::Addr, Input>>,

type Protocol = MessageAdapterWithRoute<Input, Route>

Stable public communication identity owned by this actor template.

type Event = User<<<Route as DeliveryRoute>::Protocol as Protocol>::Addr, Input>

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<Input, Route> BehaviorBase for MessageAdapterWithRoute<Input, Route>

where Route: DeliveryRoute,

type Base = MessageAdapterWithRoute<Input, Route>

fn base(&self) -> &Self

impl<Input, Route> Protocol for MessageAdapterWithRoute<Input, Route>

where Route: DeliveryRoute,

type Addr = <<Route as DeliveryRoute>::Protocol as Protocol>::Addr

type Msg = Input