Trait polkadot_node_subsystem_util::reexports::SubsystemContext

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

    fn try_recv<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<Self::Message, Self::Signal>>, ()>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: '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, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn spawn(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>
    ) -> Result<(), Self::Error>;
    fn spawn_blocking(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>
    ) -> Result<(), Self::Error>;
    fn sender(&mut self) -> &mut Self::Sender;

    fn send_message<'life0, 'async_trait, T>(
        &'life0 mut self,
        msg: T
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self::OutgoingMessages: From<T> + Send,
        T: Send + 'async_trait,
        Self: 'async_trait,
    { ... }
    fn send_messages<'life0, 'async_trait, T, I>(
        &'life0 mut self,
        msgs: I
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self::OutgoingMessages: From<T> + Send,
        I: IntoIterator<Item = T> + Send + 'async_trait,
        <I as IntoIterator>::IntoIter: Send,
        T: Send + 'async_trait,
        Self: '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: 'static + Debug + Send

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: 'static + Debug + Send

And the same for signals.

type OutgoingMessages: 'static + Debug + Send

The overarching messages enum for this particular subsystem.

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

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

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

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, Global>>where
    'life0: 'async_trait,
    Self: '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, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Receive a message.

fn spawn(
    &mut self,
    name: &'static str,
    s: Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>
) -> 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 + 'static, Global>>
) -> 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, Global>>where
    'life0: 'async_trait,
    Self::OutgoingMessages: From<T> + Send,
    T: Send + 'async_trait,
    Self: '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, Global>>where
    'life0: 'async_trait,
    Self::OutgoingMessages: From<T> + Send,
    I: IntoIterator<Item = T> + Send + 'async_trait,
    <I as IntoIterator>::IntoIter: Send,
    T: Send + 'async_trait,
    Self: '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.

Implementations on Foreign Types

impl SubsystemContext for OverseerSubsystemContext<ApprovalVotingMessage>where
    ApprovalVotingMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ApprovalVotingOutgoingMessages> + From<ApprovalVotingMessage>,
    ApprovalVotingOutgoingMessages: From<ApprovalDistributionMessage> + From<AvailabilityRecoveryMessage> + From<CandidateValidationMessage> + From<ChainApiMessage> + From<ChainSelectionMessage> + From<DisputeCoordinatorMessage> + From<RuntimeApiMessage>,

type Message = ApprovalVotingMessage

type Signal = OverseerSignal

type OutgoingMessages = ApprovalVotingOutgoingMessages

type Sender = OverseerSender<ApprovalVotingOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<ApprovalVotingMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ApprovalVotingMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<ApprovalVotingMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ApprovalVotingMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<ApprovalVotingMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<ChainSelectionMessage>where
    ChainSelectionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ChainSelectionOutgoingMessages> + From<ChainSelectionMessage>,
    ChainSelectionOutgoingMessages: From<ChainApiMessage>,

type Message = ChainSelectionMessage

type Signal = OverseerSignal

type OutgoingMessages = ChainSelectionOutgoingMessages

type Sender = OverseerSender<ChainSelectionOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<ChainSelectionMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ChainSelectionMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<ChainSelectionMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ChainSelectionMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<ChainSelectionMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<AvailabilityRecoveryMessage>where
    AvailabilityRecoveryMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<AvailabilityRecoveryOutgoingMessages> + From<AvailabilityRecoveryMessage>,
    AvailabilityRecoveryOutgoingMessages: From<NetworkBridgeTxMessage> + From<RuntimeApiMessage> + From<AvailabilityStoreMessage>,

type Message = AvailabilityRecoveryMessage

type Signal = OverseerSignal

type OutgoingMessages = AvailabilityRecoveryOutgoingMessages

type Sender = OverseerSender<AvailabilityRecoveryOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<AvailabilityRecoveryMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<AvailabilityRecoveryMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<AvailabilityRecoveryMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<AvailabilityRecoveryMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<AvailabilityRecoveryMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<DisputeDistributionMessage>where
    DisputeDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<DisputeDistributionOutgoingMessages> + From<DisputeDistributionMessage>,
    DisputeDistributionOutgoingMessages: From<RuntimeApiMessage> + From<DisputeCoordinatorMessage> + From<NetworkBridgeTxMessage>,

type Message = DisputeDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = DisputeDistributionOutgoingMessages

type Sender = OverseerSender<DisputeDistributionOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<DisputeDistributionMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<DisputeDistributionMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<DisputeDistributionMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<DisputeDistributionMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<DisputeDistributionMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<()>where
    (): 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<()>,

type Message = ()

type Signal = OverseerSignal

type OutgoingMessages = ()

type Sender = OverseerSender<()>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<()> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<()>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<()> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<()>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<()> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<CollatorProtocolMessage>where
    CollatorProtocolMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CollatorProtocolOutgoingMessages> + From<CollatorProtocolMessage>,
    CollatorProtocolOutgoingMessages: From<NetworkBridgeTxMessage> + From<RuntimeApiMessage> + From<CandidateBackingMessage>,

type Message = CollatorProtocolMessage

type Signal = OverseerSignal

type OutgoingMessages = CollatorProtocolOutgoingMessages

type Sender = OverseerSender<CollatorProtocolOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<CollatorProtocolMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CollatorProtocolMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<CollatorProtocolMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CollatorProtocolMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<CollatorProtocolMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<AvailabilityDistributionMessage>where
    AvailabilityDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<AvailabilityDistributionOutgoingMessages> + From<AvailabilityDistributionMessage>,
    AvailabilityDistributionOutgoingMessages: From<AvailabilityStoreMessage> + From<AvailabilityRecoveryMessage> + From<ChainApiMessage> + From<RuntimeApiMessage> + From<NetworkBridgeTxMessage>,

type Message = AvailabilityDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = AvailabilityDistributionOutgoingMessages

type Sender = OverseerSender<AvailabilityDistributionOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<AvailabilityDistributionMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<AvailabilityDistributionMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<AvailabilityDistributionMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<AvailabilityDistributionMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<AvailabilityDistributionMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<BitfieldDistributionMessage>where
    BitfieldDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<BitfieldDistributionOutgoingMessages> + From<BitfieldDistributionMessage>,
    BitfieldDistributionOutgoingMessages: From<RuntimeApiMessage> + From<NetworkBridgeTxMessage> + From<ProvisionerMessage>,

type Message = BitfieldDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = BitfieldDistributionOutgoingMessages

type Sender = OverseerSender<BitfieldDistributionOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<BitfieldDistributionMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<BitfieldDistributionMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<BitfieldDistributionMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<BitfieldDistributionMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<BitfieldDistributionMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<RuntimeApiMessage>where
    RuntimeApiMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<RuntimeApiOutgoingMessages> + From<RuntimeApiMessage>,

type Message = RuntimeApiMessage

type Signal = OverseerSignal

type OutgoingMessages = RuntimeApiOutgoingMessages

type Sender = OverseerSender<RuntimeApiOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<RuntimeApiMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<RuntimeApiMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<RuntimeApiMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<RuntimeApiMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<RuntimeApiMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<AvailabilityStoreMessage>where
    AvailabilityStoreMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<AvailabilityStoreOutgoingMessages> + From<AvailabilityStoreMessage>,
    AvailabilityStoreOutgoingMessages: From<ChainApiMessage> + From<RuntimeApiMessage>,

type Message = AvailabilityStoreMessage

type Signal = OverseerSignal

type OutgoingMessages = AvailabilityStoreOutgoingMessages

type Sender = OverseerSender<AvailabilityStoreOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<AvailabilityStoreMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<AvailabilityStoreMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<AvailabilityStoreMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<AvailabilityStoreMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<AvailabilityStoreMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<ChainApiMessage>where
    ChainApiMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ChainApiOutgoingMessages> + From<ChainApiMessage>,

type Message = ChainApiMessage

type Signal = OverseerSignal

type OutgoingMessages = ChainApiOutgoingMessages

type Sender = OverseerSender<ChainApiOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<ChainApiMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ChainApiMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<ChainApiMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ChainApiMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<ChainApiMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<PvfCheckerMessage>where
    PvfCheckerMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<PvfCheckerOutgoingMessages> + From<PvfCheckerMessage>,
    PvfCheckerOutgoingMessages: From<CandidateValidationMessage> + From<RuntimeApiMessage>,

type Message = PvfCheckerMessage

type Signal = OverseerSignal

type OutgoingMessages = PvfCheckerOutgoingMessages

type Sender = OverseerSender<PvfCheckerOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<PvfCheckerMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<PvfCheckerMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<PvfCheckerMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<PvfCheckerMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<PvfCheckerMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<StatementDistributionMessage>where
    StatementDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<StatementDistributionOutgoingMessages> + From<StatementDistributionMessage>,
    StatementDistributionOutgoingMessages: From<NetworkBridgeTxMessage> + From<CandidateBackingMessage> + From<RuntimeApiMessage>,

type Message = StatementDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = StatementDistributionOutgoingMessages

type Sender = OverseerSender<StatementDistributionOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<StatementDistributionMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<StatementDistributionMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<StatementDistributionMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<StatementDistributionMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<StatementDistributionMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<ApprovalDistributionMessage>where
    ApprovalDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ApprovalDistributionOutgoingMessages> + From<ApprovalDistributionMessage>,
    ApprovalDistributionOutgoingMessages: From<NetworkBridgeTxMessage> + From<ApprovalVotingMessage>,

type Message = ApprovalDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = ApprovalDistributionOutgoingMessages

type Sender = OverseerSender<ApprovalDistributionOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<ApprovalDistributionMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ApprovalDistributionMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<ApprovalDistributionMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ApprovalDistributionMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<ApprovalDistributionMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<CandidateBackingMessage>where
    CandidateBackingMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CandidateBackingOutgoingMessages> + From<CandidateBackingMessage>,
    CandidateBackingOutgoingMessages: From<CandidateValidationMessage> + From<CollatorProtocolMessage> + From<AvailabilityDistributionMessage> + From<AvailabilityStoreMessage> + From<StatementDistributionMessage> + From<ProvisionerMessage> + From<RuntimeApiMessage>,

type Message = CandidateBackingMessage

type Signal = OverseerSignal

type OutgoingMessages = CandidateBackingOutgoingMessages

type Sender = OverseerSender<CandidateBackingOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<CandidateBackingMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CandidateBackingMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<CandidateBackingMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CandidateBackingMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<CandidateBackingMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<NetworkBridgeRxMessage>where
    NetworkBridgeRxMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<NetworkBridgeRxOutgoingMessages> + From<NetworkBridgeRxMessage>,
    NetworkBridgeRxOutgoingMessages: From<BitfieldDistributionMessage> + From<StatementDistributionMessage> + From<ApprovalDistributionMessage> + From<GossipSupportMessage> + From<DisputeDistributionMessage> + From<CollationGenerationMessage> + From<CollatorProtocolMessage>,

type Message = NetworkBridgeRxMessage

type Signal = OverseerSignal

type OutgoingMessages = NetworkBridgeRxOutgoingMessages

type Sender = OverseerSender<NetworkBridgeRxOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<NetworkBridgeRxMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<NetworkBridgeRxMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<NetworkBridgeRxMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<NetworkBridgeRxMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<NetworkBridgeRxMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<CandidateValidationMessage>where
    CandidateValidationMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CandidateValidationOutgoingMessages> + From<CandidateValidationMessage>,
    CandidateValidationOutgoingMessages: From<RuntimeApiMessage>,

type Message = CandidateValidationMessage

type Signal = OverseerSignal

type OutgoingMessages = CandidateValidationOutgoingMessages

type Sender = OverseerSender<CandidateValidationOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<CandidateValidationMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CandidateValidationMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<CandidateValidationMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CandidateValidationMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<CandidateValidationMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<ProvisionerMessage>where
    ProvisionerMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ProvisionerOutgoingMessages> + From<ProvisionerMessage>,
    ProvisionerOutgoingMessages: From<RuntimeApiMessage> + From<CandidateBackingMessage> + From<ChainApiMessage> + From<DisputeCoordinatorMessage>,

type Message = ProvisionerMessage

type Signal = OverseerSignal

type OutgoingMessages = ProvisionerOutgoingMessages

type Sender = OverseerSender<ProvisionerOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<ProvisionerMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ProvisionerMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<ProvisionerMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<ProvisionerMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<ProvisionerMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<CollationGenerationMessage>where
    CollationGenerationMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CollationGenerationOutgoingMessages> + From<CollationGenerationMessage>,
    CollationGenerationOutgoingMessages: From<RuntimeApiMessage> + From<CollatorProtocolMessage>,

type Message = CollationGenerationMessage

type Signal = OverseerSignal

type OutgoingMessages = CollationGenerationOutgoingMessages

type Sender = OverseerSender<CollationGenerationOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<CollationGenerationMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CollationGenerationMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<CollationGenerationMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<CollationGenerationMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<CollationGenerationMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<GossipSupportMessage>where
    GossipSupportMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<GossipSupportOutgoingMessages> + From<GossipSupportMessage>,
    GossipSupportOutgoingMessages: From<NetworkBridgeTxMessage> + From<NetworkBridgeRxMessage> + From<RuntimeApiMessage> + From<ChainSelectionMessage>,

type Message = GossipSupportMessage

type Signal = OverseerSignal

type OutgoingMessages = GossipSupportOutgoingMessages

type Sender = OverseerSender<GossipSupportOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<GossipSupportMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<GossipSupportMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<GossipSupportMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<GossipSupportMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<GossipSupportMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<DisputeCoordinatorMessage>where
    DisputeCoordinatorMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<DisputeCoordinatorOutgoingMessages> + From<DisputeCoordinatorMessage>,
    DisputeCoordinatorOutgoingMessages: From<RuntimeApiMessage> + From<ChainApiMessage> + From<DisputeDistributionMessage> + From<CandidateValidationMessage> + From<ApprovalVotingMessage> + From<AvailabilityStoreMessage> + From<AvailabilityRecoveryMessage>,

type Message = DisputeCoordinatorMessage

type Signal = OverseerSignal

type OutgoingMessages = DisputeCoordinatorOutgoingMessages

type Sender = OverseerSender<DisputeCoordinatorOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<DisputeCoordinatorMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<DisputeCoordinatorMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<DisputeCoordinatorMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<DisputeCoordinatorMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<DisputeCoordinatorMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<BitfieldSigningMessage>where
    BitfieldSigningMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<BitfieldSigningOutgoingMessages> + From<BitfieldSigningMessage>,
    BitfieldSigningOutgoingMessages: From<AvailabilityStoreMessage> + From<RuntimeApiMessage> + From<BitfieldDistributionMessage>,

type Message = BitfieldSigningMessage

type Signal = OverseerSignal

type OutgoingMessages = BitfieldSigningOutgoingMessages

type Sender = OverseerSender<BitfieldSigningOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<BitfieldSigningMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<BitfieldSigningMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<BitfieldSigningMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<BitfieldSigningMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<BitfieldSigningMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<NetworkBridgeTxMessage>where
    NetworkBridgeTxMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<NetworkBridgeTxOutgoingMessages> + From<NetworkBridgeTxMessage>,

type Message = NetworkBridgeTxMessage

type Signal = OverseerSignal

type OutgoingMessages = NetworkBridgeTxOutgoingMessages

type Sender = OverseerSender<NetworkBridgeTxOutgoingMessages>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<NetworkBridgeTxMessage> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<NetworkBridgeTxMessage>: 'async_trait,

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<NetworkBridgeTxMessage> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    OverseerSubsystemContext<NetworkBridgeTxMessage>: 'async_trait,

fn sender(
    &mut self
) -> &mut <OverseerSubsystemContext<NetworkBridgeTxMessage> as SubsystemContext>::Sender

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

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

Implementors