Struct SendLayer 

pub struct SendLayer<Owned, Inner> {
    pub owned: Owned,
    pub inner: Inner,
}

Send effects introduced by one wrapper around inner send effects.

owned contains effects introduced by the current behavior layer and inner contains effects of the wrapped interaction. The structural SendsFor implementation is the composition law:

Event'   = OwnedEvent + InnerEvent
Effects' = OwnedEffects × InnerEffects

Owned return to the emitters target Event'; inner return to the emitters target InnerEvent and are therefore lifted through the same Inner injection. Established actor, child, and ancestor destinations are unaffected because they are not return to the emitters.

Fields

owned: Owned

inner: Inner

Implementations

impl<Owned, Inner> SendLayer<Owned, Inner>

pub const fn new(owned: Owned, inner: Inner) -> Self

Trait Implementations

impl<Owned, Inner> ClassifySettlement for SendLayer<Owned, Inner>

where Owned: ClassifySettlement, Inner: ClassifySettlement,

fn settlement_status(&self) -> SettlementStatus

Inspect every member without consuming or rewriting the settlement.

impl<Owned: Clone, Inner: Clone> Clone for SendLayer<Owned, Inner>

fn clone(&self) -> SendLayer<Owned, Inner>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Owned: Debug, Inner: Debug> Debug for SendLayer<Owned, Inner>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Interpreter, RootEvent, Path, Owned, Inner> InterpretSends<Interpreter, RootEvent, Path> for SendLayer<Owned, Inner>

where Interpreter: Send, Owned: InterpretSends<Interpreter, RootEvent, Path> + Send, Inner: InterpretSends<Interpreter, RootEvent, Inside<Path>> + Send, Owned::InterpretationCustody: Send, Inner::InterpretationCustody: Send,

fn interpret( progress: &mut Option<InterpretationProgress<Self, Self::InterpretationCustody, Self::Settlements>>, interpreter: &mut Interpreter, ) -> impl Future<Output = ()> + Send

impl<Owned, Inner> LogicalDeliveryProtocols for SendLayer<Owned, Inner>

where Owned: LogicalDeliveryProtocols, Inner: LogicalDeliveryProtocols,

type Protocols = <<Inner as LogicalDeliveryProtocols>::Protocols as BirthProtocolProduct>::Append<<Owned as LogicalDeliveryProtocols>::Protocols>

Ordered, duplicate-preserving logical protocol occurrences.

impl<Owned: PartialEq, Inner: PartialEq> PartialEq for SendLayer<Owned, Inner>

fn eq(&self, other: &SendLayer<Owned, Inner>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Owned: SendEffects, Inner: SendEffects> SendEffects for SendLayer<Owned, Inner>

fn empty() -> Self

fn append(&mut self, other: Self)

fn combine(self, other: Self) -> Self

fn send<Input, Path>(&mut self, input: Input)

where Self: SendInput<Input, Path>,

Append one request to its statically selected semantic lane.

fn sending<Input, Path>(input: Input) -> Self

where Self: SendInput<Input, Path>,

Build a send product containing one request in its selected lane.

impl<Input, Path, Owned, Inner> SendInput<Input, Path> for SendLayer<Owned, Inner>

where Owned: SendInput<Input, Path>,

fn emit(&mut self, input: Input)

impl<Owned, Inner> SendSettlements for SendLayer<Owned, Inner>

where Owned: SendSettlements, Inner: SendSettlements,

type Settlements = SendLayer<<Owned as SendSettlements>::Settlements, <Inner as SendSettlements>::Settlements>

type SourceCustody = (Option<SourceProgress<<Inner as SendSettlements>::Settlements, <Inner as SendSettlements>::SourceCustody>>, Option<SourceProgress<<Owned as SendSettlements>::Settlements, <Owned as SendSettlements>::SourceCustody>>)

type InterpretationCustody = SendLayer<Option<InterpretationProgress<Owned, <Owned as SendSettlements>::InterpretationCustody, <Owned as SendSettlements>::Settlements>>, Option<InterpretationProgress<Inner, <Inner as SendSettlements>::InterpretationCustody, <Inner as SendSettlements>::Settlements>>>

fn prepare_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::InterpretationCustody, Self::Settlements>>, )

fn finish_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::InterpretationCustody, Self::Settlements>>, )

fn unattempted( progress: &mut Option<InterpretationProgress<Self, Self::InterpretationCustody, Self::Settlements>>, )

impl<Host, RootEvent, Owned, Inner> SourceSettlementCustody<Host, RootEvent> for SendLayer<Owned, Inner>

where Host: Send, Owned: SourceSettlementCustody<Host, RootEvent> + Send, Inner: SourceSettlementCustody<Host, RootEvent> + Send,

type Custody = <(Inner, Owned) as SourceSettlementCustody<Host, RootEvent>>::Custody

fn prepare_source(progress: &mut Option<SourceProgress<Self, Self::Custody>>)

fn offer_next_to_source( custody: &mut Self::Custody, host: &mut Host, ) -> impl Future<Output = ()> + Send

fn finish_source(progress: &mut Option<SourceProgress<Self, Self::Custody>>)

impl<Owned: Copy, Inner: Copy> Copy for SendLayer<Owned, Inner>

impl<Owned: Eq, Inner: Eq> Eq for SendLayer<Owned, Inner>

impl<Event, OwnedEffects, InnerEffects> SendsFor<Event> for SendLayer<OwnedEffects, InnerEffects>

where Event: ComposedEvent, OwnedEffects: SendsFor<Event>, InnerEffects: SendsFor<Event::Inner>,

impl<Owned, Inner> StructuralPartialEq for SendLayer<Owned, Inner>