Struct WithChannels 

pub struct WithChannels<I: Channels<S>, S: Service> {
    pub inner: I,
    pub tx: <I as Channels<S>>::Tx,
    pub rx: <I as Channels<S>>::Rx,
    pub span: Span,
}

A wrapper for a message with channels to send and receive it. This expands the protocol message to a full message that includes the active and unserializable channels.

The channel kind for rx and tx is defined by implementing the Channels trait, either manually or using a macro.

When the spans feature is enabled, this also includes a tracing span to carry the tracing context during message passing.

Fields

inner: I

The inner message.

tx: <I as Channels<S>>::Tx

The return channel to send the response to. Can be set to crate::channel::none::NoSender if not needed.

rx: <I as Channels<S>>::Rx

The request channel to receive the request from. Can be set to NoReceiver if not needed.

span: Span

Available on crate feature spans only.

The current span where the full message was created.

Implementations

impl<I: Channels<S>, S: Service> WithChannels<I, S>

pub fn parent_span_opt(&self) -> Option<&Span>

Available on crate feature spans only.

Get the parent span

Trait Implementations

impl<I: Channels<S> + Debug, S: Service> Debug for WithChannels<I, S>

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

Formats the value using the given formatter.

impl<I: Channels<S>, S: Service> Deref for WithChannels<I, S>

Deref so you can access the inner fields directly.

If the inner message has fields named tx, rx or span, you need to use the inner field to access them.

type Target = I

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<I, S> From<(I,)> for WithChannels<I, S>

where I: Channels<S, Rx = NoReceiver, Tx = NoSender>, S: Service,

Tuple conversion from inner message to a WithChannels struct without channels

fn from(inner: (I,)) -> Self

Converts to this type from the input type.

impl<I, S, Tx> From<(I, Tx)> for WithChannels<I, S>

where I: Channels<S, Rx = NoReceiver>, S: Service, <I as Channels<S>>::Tx: From<Tx>,

Tuple conversion from inner message and tx channel to a WithChannels struct

For the very common case where you just need a tx channel to send the response to.

fn from(inner: (I, Tx)) -> Self

Converts to this type from the input type.

impl<I, S: Service, Tx, Rx> From<(I, Tx, Rx)> for WithChannels<I, S>

where I: Channels<S>, <I as Channels<S>>::Tx: From<Tx>, <I as Channels<S>>::Rx: From<Rx>,

Tuple conversion from inner message and tx/rx channels to a WithChannels struct

For the case where you want both tx and rx channels.

fn from(inner: (I, Tx, Rx)) -> Self

Converts to this type from the input type.