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) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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<Owned: Eq, Inner: Eq> Eq for SendLayer<Owned, Inner>

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,

fn interpret( self, interpreter: &mut Interpreter, ) -> impl Future<Output = Interpretation<Self::Settlements>> + Send

Interpret every value in this product in its declared stable order.

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: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

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>

Complete settlement product corresponding to Self.

fn unattempted(self) -> Self::Settlements

Preserve every item without granting interpretation authority.

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

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

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,

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

Offer only the next source input in declared order.

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