Trait SubsystemContext 

pub trait SubsystemContext: Send + 'static {
    type Message: Debug + Send + 'static;
    type Signal: Debug + Send + 'static;
    type OutgoingMessages: Debug + Send + 'static;
    type Sender: Clone + Send + 'static + SubsystemSender<Self::OutgoingMessages>;
    type Error: Error + From<OrchestraError> + Sync + Send + 'static;

    // Required methods
    fn try_recv<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<Self::Message, Self::Signal>>, ()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn recv<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<Self::Message, Self::Signal>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn recv_signal<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<Self::Signal, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn spawn(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send>>,
    ) -> Result<(), Self::Error>;
    fn spawn_blocking(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send>>,
    ) -> Result<(), Self::Error>;
    fn sender(&mut self) -> &mut Self::Sender;

    // Provided methods
    fn send_message<'life0, 'async_trait, T>(
        &'life0 mut self,
        msg: T,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where Self::OutgoingMessages: From<T> + Send,
             T: Send + 'async_trait,
             Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn send_messages<'life0, 'async_trait, T, I>(
        &'life0 mut self,
        msgs: I,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where Self::OutgoingMessages: From<T> + Send,
             I: IntoIterator<Item = T> + Send + 'async_trait,
             I::IntoIter: Send,
             T: Send + 'async_trait,
             Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn send_unbounded_message<X>(&mut self, msg: X)
       where Self::OutgoingMessages: From<X> + Send,
             X: Send { ... }
}

A context type that is given to the Subsystem upon spawning. It can be used by Subsystem to communicate with other Subsystems or spawn jobs.

Required Associated Types

type Message: Debug + Send + 'static

The message type of this context. Subsystems launched with this context will expect to receive messages of this type. Commonly uses the wrapping enum commonly called AllMessages.

type Signal: Debug + Send + 'static

And the same for signals.

type OutgoingMessages: Debug + Send + 'static

The overarching messages enum for this particular subsystem.

type Sender: Clone + Send + 'static + SubsystemSender<Self::OutgoingMessages>

The sender type as provided by sender() and underlying.

type Error: Error + From<OrchestraError> + Sync + Send + 'static

The error type.

Required Methods

fn try_recv<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<Self::Message, Self::Signal>>, ()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Try to asynchronously receive a message.

Has to be used with caution, if you loop over this without using pending!() macro you will end up with a busy loop!

fn recv<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<Self::Message, Self::Signal>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receive a signal or a message.

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Self::Signal, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receive a signal.

This method allows the subsystem to process signals while being blocked on processing messages. See examples/backpressure.rs for an example.

fn spawn( &mut self, name: &'static str, s: Pin<Box<dyn Future<Output = ()> + Send>>, ) -> Result<(), Self::Error>

Spawn a child task on the executor.

fn spawn_blocking( &mut self, name: &'static str, s: Pin<Box<dyn Future<Output = ()> + Send>>, ) -> Result<(), Self::Error>

Spawn a blocking child task on the executor’s dedicated thread pool.

fn sender(&mut self) -> &mut Self::Sender

Obtain the sender.

Provided Methods

fn send_message<'life0, 'async_trait, T>( &'life0 mut self, msg: T, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self::OutgoingMessages: From<T> + Send, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Send a direct message to some other Subsystem, routed based on message type.

fn send_messages<'life0, 'async_trait, T, I>( &'life0 mut self, msgs: I, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self::OutgoingMessages: From<T> + Send, I: IntoIterator<Item = T> + Send + 'async_trait, I::IntoIter: Send, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Send multiple direct messages to other Subsystems, routed based on message type.

fn send_unbounded_message<X>(&mut self, msg: X)

where Self::OutgoingMessages: From<X> + Send, X: Send,

Send a message using the unbounded connection.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors