Struct polkadot_node_subsystem_util::nesting_sender::NestingSender

pub struct NestingSender<M, Mnested> { /* private fields */ }

A message sender that supports sending nested messages.

This sender wraps an mpsc::Sender and a conversion function for converting given messages of type Mnested to the message type actually supported by the mpsc (M).

Example:

    enum RootMessage {
        Child1Message(ChildMessage),
        Child2Message(OtherChildMessage),
        SomeOwnMessage,
    }

    enum ChildMessage {
        TaskFinished(u32),
    }

    enum OtherChildMessage {
        QueryResult(bool),
    }

    // We would then pass in a `NestingSender` to our child module of the following type:
    type ChildSender = NestingSender<RootMessage, ChildMessage>;

    // Types in the child module can (and should) be generic over the root type:
    struct ChildState<M> {
        tx: NestingSender<M, ChildMessage>,
    }


   // Create the root message sender:

   let (root_sender, receiver) = NestingSender::new_root(1);
   // Get a sender for the child module based on that root sender:
   let child_sender = NestingSender::new(root_sender.clone(), RootMessage::Child1Message);
   // pass `child_sender` to child module ...

ChildMessage could itself have a constructor with messages of a child of its own and can use NestingSender::new with its own sender and a conversion function to provide a further nested sender, suitable for the child module.

Implementations

impl<M> NestingSender<M, M>where M: 'static,

pub fn new_root(channel_size: usize) -> (Self, Receiver<M>)

Create a new “root” sender.

This is a sender that directly passes messages to the internal mpsc.

Params: The channel size of the created mpsc. Returns: The newly constructed NestingSender and the corresponding mpsc receiver.

impl<M, Mnested> NestingSender<M, Mnested>where M: 'static, Mnested: 'static,

pub fn new<Mparent>( parent: NestingSender<M, Mparent>, child_conversion: fn(_: Mnested) -> Mparent ) -> Selfwhere Mparent: 'static,

Create a new NestingSender which wraps a given “parent” sender.

By passing in a necessary conversion from Mnested to Mparent (the Mnested of the parent sender), we can construct a derived NestingSender<M, Mnested> from a NestingSender<M, Mparent>.

Resulting sender does the following conversion:

   Mnested -> Mparent -> M
   Inputs:
   	F(Mparent) -> M (via parent)
   	F(Mnested) -> Mparent (via child_conversion)
   Result: F(Mnested) -> M

pub async fn send_message(&mut self, m: Mnested) -> Result<(), SendError>

Send a message via the underlying mpsc.

Necessary conversion is accomplished.

Trait Implementations

impl<M, Mnested> Clone for NestingSender<M, Mnested>where M: 'static, Mnested: 'static,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.