Struct Delivery 

pub struct Delivery<B: Behavior> {
    pub to: Recipient<B>,
    pub message: B::Msg,
}

One pure communication addressed to a concrete behavior protocol.

Protocol identity is not inferred from the payload. Consequently, two behaviors accepting the same address and message types still have distinct delivery types.

use behavior::{Actions, Behavior, Delivery, MailAddr, Never, NoBirths, Recipient, User};

struct Queue;
struct Worker;
macro_rules! inert {
    ($actor:ty) => {
        impl Behavior for $actor {
            type Addr = MailAddr;
            type Msg = u8;
            type Event = User<MailAddr, u8>;
            type Sends = Vec<Never>;
            type Ph = Never;
            type Error = Never;
            type Birth = NoBirths;
            fn init(&mut self) -> behavior::BehaviorActed<Self> { Ok(Actions::cont()) }
            fn transition(&mut self, _: Self::Event) -> behavior::BehaviorActed<Self> {
                Ok(Actions::cont())
            }
        }
    };
}
inert!(Queue);
inert!(Worker);

let worker = Recipient::<Worker>::global(MailAddr(1));
let _: Delivery<Queue> = Delivery::new(worker, 7);

A destination also fixes its message and address namespaces:

use behavior::{Actions, Address, Behavior, Delivery, MailAddr, Never, NoBirths, Recipient, User};
#[derive(Clone, Copy, PartialEq, Eq)]
struct OtherAddr(u64);
impl Address for OtherAddr {
    type Nonce = u64;
    fn birth(self, nonce: u64) -> Self { Self(self.0 ^ nonce) }
}
struct Worker;
impl Behavior for Worker {
    type Addr = MailAddr;
    type Msg = u8;
    type Event = User<MailAddr, u8>;
    type Sends = Vec<Never>;
    type Ph = Never;
    type Error = Never;
    type Birth = NoBirths;
    fn init(&mut self) -> behavior::BehaviorActed<Self> { Ok(Actions::cont()) }
    fn transition(&mut self, _: Self::Event) -> behavior::BehaviorActed<Self> { Ok(Actions::cont()) }
}
let _ = Recipient::<Worker>::global(OtherAddr(1));

let worker = Recipient::<Worker>::global(MailAddr(1));
let _ = Delivery::<Worker>::new(worker, "wrong payload");

Fields

to: Recipient<B>

message: B::Msg

Implementations

impl<B: Behavior> Delivery<B>

pub fn new(to: Recipient<B>, message: B::Msg) -> Self

Trait Implementations

impl<B> Clone for Delivery<B>

where B: Behavior, B::Msg: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B> Eq for Delivery<B>

where B: Behavior, B::Msg: Eq,

impl<B> PartialEq for Delivery<B>

where B: Behavior, B::Msg: PartialEq,

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<C: Behavior> SendInput<Delivery<C>, Own> for ProxySends<C>

fn emit(&mut self, input: Delivery<C>)

impl<A, D, J, R, C> SendInput<Delivery<D>, Own> for PoolBehaviorSends<A, D, J, R, C>

where A: Address, A::Nonce: From<u64>, D: Behavior<Addr = A, Msg = PoolResponse<J, R, A>>, C: Behavior<Addr = A, Ph = Never>,

fn emit(&mut self, input: Delivery<D>)

impl<A, D, J, R, C> SendInput<Delivery<Proxy<C>>, Own> for PoolBehaviorSends<A, D, J, R, C>

where A: Address, A::Nonce: From<u64>, D: Behavior<Addr = A, Msg = PoolResponse<J, R, A>>, C: Behavior<Addr = A, Ph = Never>,

fn emit(&mut self, input: Delivery<Proxy<C>>)

impl<A, Sends, C> SendInput<Delivery<Proxy<C>>, Own> for SupervisorSends<A, Sends, C>

where A: Address, A::Nonce: From<u64>, C: Behavior<Addr = A, Ph = Never>,

fn emit(&mut self, input: Delivery<Proxy<C>>)