Struct polkadot_node_subsystem::OverseerSubsystemContext

pub struct OverseerSubsystemContext<M>where
    M: 'static + AssociateOutgoing + Send,{ /* private fields */ }

Expand description

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

Trait Implementations§

impl<M> Debug for OverseerSubsystemContext<M>where
M: 'static + Debug + AssociateOutgoing + Send,

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

Formats the value using the given formatter. Read more

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

type Message = ()

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ()

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<()>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = ApprovalDistributionMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ApprovalDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ApprovalDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ApprovalVotingOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ApprovalVotingOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = AvailabilityDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<AvailabilityDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = AvailabilityRecoveryOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<AvailabilityRecoveryOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = AvailabilityStoreMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = AvailabilityStoreOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<AvailabilityStoreOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = BitfieldDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<BitfieldDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = BitfieldSigningOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<BitfieldSigningOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CandidateBackingOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CandidateBackingOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = CandidateValidationMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CandidateValidationOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CandidateValidationOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = ChainApiMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ChainApiOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ChainApiOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = ChainSelectionMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ChainSelectionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ChainSelectionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = CollationGenerationMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CollationGenerationOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CollationGenerationOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CollatorProtocolOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CollatorProtocolOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = DisputeCoordinatorOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<DisputeCoordinatorOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = DisputeDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<DisputeDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = GossipSupportOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<GossipSupportOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = NetworkBridgeRxOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<NetworkBridgeRxOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = NetworkBridgeTxMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = NetworkBridgeTxOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<NetworkBridgeTxOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ProvisionerOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ProvisionerOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = PvfCheckerMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = PvfCheckerOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<PvfCheckerOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

type Message = RuntimeApiMessage

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = RuntimeApiOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<RuntimeApiOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

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

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. Read more

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = StatementDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<StatementDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message. Read more

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,

Receive a message.

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

Obtain the sender.

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

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<(), SubsystemError>

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

Auto Trait Implementations§

impl<M> !RefUnwindSafe for OverseerSubsystemContext<M>

impl<M> Send for OverseerSubsystemContext<M>

impl<M> Sync for OverseerSubsystemContext<M>where
M: Sync,
<M as AssociateOutgoing>::OutgoingMessages: Sync,

impl<M> Unpin for OverseerSubsystemContext<M>where
M: Unpin,
<M as AssociateOutgoing>::OutgoingMessages: Unpin,

impl<M> !UnwindSafe for OverseerSubsystemContext<M>

Blanket Implementations§

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> ApprovalDistributionContextTrait for Twhere
    T: SubsystemContext<Message = ApprovalDistributionMessage, Signal = OverseerSignal, OutgoingMessages = ApprovalDistributionOutgoingMessages, Error = SubsystemError>,
    ApprovalDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ApprovalDistributionOutgoingMessages> + From<ApprovalDistributionMessage> + From<()>,
    ApprovalDistributionOutgoingMessages: From<NetworkBridgeTxMessage> + From<ApprovalVotingMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + ApprovalDistributionSenderTrait + SubsystemSender<ApprovalDistributionOutgoingMessages> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<ApprovalVotingMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> ApprovalVotingContextTrait for Twhere
    T: SubsystemContext<Message = ApprovalVotingMessage, Signal = OverseerSignal, OutgoingMessages = ApprovalVotingOutgoingMessages, Error = SubsystemError>,
    ApprovalVotingMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ApprovalVotingOutgoingMessages> + From<ApprovalVotingMessage> + From<()>,
    ApprovalVotingOutgoingMessages: From<ApprovalDistributionMessage> + From<AvailabilityRecoveryMessage> + From<CandidateValidationMessage> + From<ChainApiMessage> + From<ChainSelectionMessage> + From<DisputeCoordinatorMessage> + From<RuntimeApiMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + ApprovalVotingSenderTrait + SubsystemSender<ApprovalVotingOutgoingMessages> + SubsystemSender<ApprovalDistributionMessage> + SubsystemSender<AvailabilityRecoveryMessage> + SubsystemSender<CandidateValidationMessage> + SubsystemSender<ChainApiMessage> + SubsystemSender<ChainSelectionMessage> + SubsystemSender<DisputeCoordinatorMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> AvailabilityDistributionContextTrait for Twhere
    T: SubsystemContext<Message = AvailabilityDistributionMessage, Signal = OverseerSignal, OutgoingMessages = AvailabilityDistributionOutgoingMessages, Error = SubsystemError>,
    AvailabilityDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<AvailabilityDistributionOutgoingMessages> + From<AvailabilityDistributionMessage> + From<()>,
    AvailabilityDistributionOutgoingMessages: From<AvailabilityStoreMessage> + From<AvailabilityRecoveryMessage> + From<ChainApiMessage> + From<RuntimeApiMessage> + From<NetworkBridgeTxMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + AvailabilityDistributionSenderTrait + SubsystemSender<AvailabilityDistributionOutgoingMessages> + SubsystemSender<AvailabilityStoreMessage> + SubsystemSender<AvailabilityRecoveryMessage> + SubsystemSender<ChainApiMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> AvailabilityRecoveryContextTrait for Twhere
    T: SubsystemContext<Message = AvailabilityRecoveryMessage, Signal = OverseerSignal, OutgoingMessages = AvailabilityRecoveryOutgoingMessages, Error = SubsystemError>,
    AvailabilityRecoveryMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<AvailabilityRecoveryOutgoingMessages> + From<AvailabilityRecoveryMessage> + From<()>,
    AvailabilityRecoveryOutgoingMessages: From<NetworkBridgeTxMessage> + From<RuntimeApiMessage> + From<AvailabilityStoreMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + AvailabilityRecoverySenderTrait + SubsystemSender<AvailabilityRecoveryOutgoingMessages> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<AvailabilityStoreMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> AvailabilityStoreContextTrait for Twhere
    T: SubsystemContext<Message = AvailabilityStoreMessage, Signal = OverseerSignal, OutgoingMessages = AvailabilityStoreOutgoingMessages, Error = SubsystemError>,
    AvailabilityStoreMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<AvailabilityStoreOutgoingMessages> + From<AvailabilityStoreMessage> + From<()>,
    AvailabilityStoreOutgoingMessages: From<ChainApiMessage> + From<RuntimeApiMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + AvailabilityStoreSenderTrait + SubsystemSender<AvailabilityStoreOutgoingMessages> + SubsystemSender<ChainApiMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> BitfieldDistributionContextTrait for Twhere
    T: SubsystemContext<Message = BitfieldDistributionMessage, Signal = OverseerSignal, OutgoingMessages = BitfieldDistributionOutgoingMessages, Error = SubsystemError>,
    BitfieldDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<BitfieldDistributionOutgoingMessages> + From<BitfieldDistributionMessage> + From<()>,
    BitfieldDistributionOutgoingMessages: From<RuntimeApiMessage> + From<NetworkBridgeTxMessage> + From<ProvisionerMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + BitfieldDistributionSenderTrait + SubsystemSender<BitfieldDistributionOutgoingMessages> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<ProvisionerMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> BitfieldSigningContextTrait for Twhere
    T: SubsystemContext<Message = BitfieldSigningMessage, Signal = OverseerSignal, OutgoingMessages = BitfieldSigningOutgoingMessages, Error = SubsystemError>,
    BitfieldSigningMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<BitfieldSigningOutgoingMessages> + From<BitfieldSigningMessage> + From<()>,
    BitfieldSigningOutgoingMessages: From<AvailabilityStoreMessage> + From<RuntimeApiMessage> + From<BitfieldDistributionMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + BitfieldSigningSenderTrait + SubsystemSender<BitfieldSigningOutgoingMessages> + SubsystemSender<AvailabilityStoreMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<BitfieldDistributionMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CandidateBackingContextTrait for Twhere
    T: SubsystemContext<Message = CandidateBackingMessage, Signal = OverseerSignal, OutgoingMessages = CandidateBackingOutgoingMessages, Error = SubsystemError>,
    CandidateBackingMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CandidateBackingOutgoingMessages> + From<CandidateBackingMessage> + From<()>,
    CandidateBackingOutgoingMessages: From<CandidateValidationMessage> + From<CollatorProtocolMessage> + From<AvailabilityDistributionMessage> + From<AvailabilityStoreMessage> + From<StatementDistributionMessage> + From<ProvisionerMessage> + From<RuntimeApiMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + CandidateBackingSenderTrait + SubsystemSender<CandidateBackingOutgoingMessages> + SubsystemSender<CandidateValidationMessage> + SubsystemSender<CollatorProtocolMessage> + SubsystemSender<AvailabilityDistributionMessage> + SubsystemSender<AvailabilityStoreMessage> + SubsystemSender<StatementDistributionMessage> + SubsystemSender<ProvisionerMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> CandidateValidationContextTrait for Twhere
    T: SubsystemContext<Message = CandidateValidationMessage, Signal = OverseerSignal, OutgoingMessages = CandidateValidationOutgoingMessages, Error = SubsystemError>,
    CandidateValidationMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CandidateValidationOutgoingMessages> + From<CandidateValidationMessage> + From<()>,
    CandidateValidationOutgoingMessages: From<RuntimeApiMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + CandidateValidationSenderTrait + SubsystemSender<CandidateValidationOutgoingMessages> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> ChainApiContextTrait for Twhere
    T: SubsystemContext<Message = ChainApiMessage, Signal = OverseerSignal, OutgoingMessages = ChainApiOutgoingMessages, Error = SubsystemError>,
    ChainApiMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ChainApiOutgoingMessages> + From<ChainApiMessage> + From<()>,
    ChainApiOutgoingMessages: From<()>,
    <T as SubsystemContext>::Sender: 'static + ChainApiSenderTrait + SubsystemSender<ChainApiOutgoingMessages> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> ChainSelectionContextTrait for Twhere
    T: SubsystemContext<Message = ChainSelectionMessage, Signal = OverseerSignal, OutgoingMessages = ChainSelectionOutgoingMessages, Error = SubsystemError>,
    ChainSelectionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ChainSelectionOutgoingMessages> + From<ChainSelectionMessage> + From<()>,
    ChainSelectionOutgoingMessages: From<ChainApiMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + ChainSelectionSenderTrait + SubsystemSender<ChainSelectionOutgoingMessages> + SubsystemSender<ChainApiMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,

Convert from a value of T into an equivalent instance of Option<Self>. Read more

fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,

Consume self to return Some equivalent value of Option<T>. Read more

impl<T> CollationGenerationContextTrait for Twhere
    T: SubsystemContext<Message = CollationGenerationMessage, Signal = OverseerSignal, OutgoingMessages = CollationGenerationOutgoingMessages, Error = SubsystemError>,
    CollationGenerationMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CollationGenerationOutgoingMessages> + From<CollationGenerationMessage> + From<()>,
    CollationGenerationOutgoingMessages: From<RuntimeApiMessage> + From<CollatorProtocolMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + CollationGenerationSenderTrait + SubsystemSender<CollationGenerationOutgoingMessages> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<CollatorProtocolMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> CollatorProtocolContextTrait for Twhere
    T: SubsystemContext<Message = CollatorProtocolMessage, Signal = OverseerSignal, OutgoingMessages = CollatorProtocolOutgoingMessages, Error = SubsystemError>,
    CollatorProtocolMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<CollatorProtocolOutgoingMessages> + From<CollatorProtocolMessage> + From<()>,
    CollatorProtocolOutgoingMessages: From<NetworkBridgeTxMessage> + From<RuntimeApiMessage> + From<CandidateBackingMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + CollatorProtocolSenderTrait + SubsystemSender<CollatorProtocolOutgoingMessages> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<CandidateBackingMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> Conv for T

fn conv<T>(self) -> Twhere
Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> DisputeCoordinatorContextTrait for Twhere
    T: SubsystemContext<Message = DisputeCoordinatorMessage, Signal = OverseerSignal, OutgoingMessages = DisputeCoordinatorOutgoingMessages, Error = SubsystemError>,
    DisputeCoordinatorMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<DisputeCoordinatorOutgoingMessages> + From<DisputeCoordinatorMessage> + From<()>,
    DisputeCoordinatorOutgoingMessages: From<RuntimeApiMessage> + From<ChainApiMessage> + From<DisputeDistributionMessage> + From<CandidateValidationMessage> + From<ApprovalVotingMessage> + From<AvailabilityStoreMessage> + From<AvailabilityRecoveryMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + DisputeCoordinatorSenderTrait + SubsystemSender<DisputeCoordinatorOutgoingMessages> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<ChainApiMessage> + SubsystemSender<DisputeDistributionMessage> + SubsystemSender<CandidateValidationMessage> + SubsystemSender<ApprovalVotingMessage> + SubsystemSender<AvailabilityStoreMessage> + SubsystemSender<AvailabilityRecoveryMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> DisputeDistributionContextTrait for Twhere
    T: SubsystemContext<Message = DisputeDistributionMessage, Signal = OverseerSignal, OutgoingMessages = DisputeDistributionOutgoingMessages, Error = SubsystemError>,
    DisputeDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<DisputeDistributionOutgoingMessages> + From<DisputeDistributionMessage> + From<()>,
    DisputeDistributionOutgoingMessages: From<RuntimeApiMessage> + From<DisputeCoordinatorMessage> + From<NetworkBridgeTxMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + DisputeDistributionSenderTrait + SubsystemSender<DisputeDistributionOutgoingMessages> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<DisputeCoordinatorMessage> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> Downcast for Twhere
T: Any,

fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

impl<T> DowncastSync for Twhere
T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync + 'static>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait. Read more

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,

Causes self to use its Binary implementation when Debug-formatted. Read more

fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,

Causes self to use its Display implementation when Debug-formatted. Read more

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted. Read more

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted. Read more

fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,

Causes self to use its Octal implementation when Debug-formatted. Read more

fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted. Read more

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted. Read more

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted. Read more

fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> GossipSupportContextTrait for Twhere
    T: SubsystemContext<Message = GossipSupportMessage, Signal = OverseerSignal, OutgoingMessages = GossipSupportOutgoingMessages, Error = SubsystemError>,
    GossipSupportMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<GossipSupportOutgoingMessages> + From<GossipSupportMessage> + From<()>,
    GossipSupportOutgoingMessages: From<NetworkBridgeTxMessage> + From<NetworkBridgeRxMessage> + From<RuntimeApiMessage> + From<ChainSelectionMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + GossipSupportSenderTrait + SubsystemSender<GossipSupportOutgoingMessages> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<NetworkBridgeRxMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<ChainSelectionMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IsType<T> for T

fn from_ref(t: &T) -> &T

Cast reference.

fn into_ref(&self) -> &T

Cast reference.

fn from_mut(t: &mut T) -> &mut T

Cast mutable reference.

fn into_mut(&mut self) -> &mut T

Cast mutable reference.

impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

impl<T> NetworkBridgeRxContextTrait for Twhere
    T: SubsystemContext<Message = NetworkBridgeRxMessage, Signal = OverseerSignal, OutgoingMessages = NetworkBridgeRxOutgoingMessages, Error = SubsystemError>,
    NetworkBridgeRxMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<NetworkBridgeRxOutgoingMessages> + From<NetworkBridgeRxMessage> + From<()>,
    NetworkBridgeRxOutgoingMessages: From<BitfieldDistributionMessage> + From<StatementDistributionMessage> + From<ApprovalDistributionMessage> + From<GossipSupportMessage> + From<DisputeDistributionMessage> + From<CollationGenerationMessage> + From<CollatorProtocolMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + NetworkBridgeRxSenderTrait + SubsystemSender<NetworkBridgeRxOutgoingMessages> + SubsystemSender<BitfieldDistributionMessage> + SubsystemSender<StatementDistributionMessage> + SubsystemSender<ApprovalDistributionMessage> + SubsystemSender<GossipSupportMessage> + SubsystemSender<DisputeDistributionMessage> + SubsystemSender<CollationGenerationMessage> + SubsystemSender<CollatorProtocolMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> NetworkBridgeTxContextTrait for Twhere
    T: SubsystemContext<Message = NetworkBridgeTxMessage, Signal = OverseerSignal, OutgoingMessages = NetworkBridgeTxOutgoingMessages, Error = SubsystemError>,
    NetworkBridgeTxMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<NetworkBridgeTxOutgoingMessages> + From<NetworkBridgeTxMessage> + From<()>,
    NetworkBridgeTxOutgoingMessages: From<()>,
    <T as SubsystemContext>::Sender: 'static + NetworkBridgeTxSenderTrait + SubsystemSender<NetworkBridgeTxOutgoingMessages> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> Pipe for Twhere
T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,

Pipes by value. This is generally the method you want to use. Read more

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,

Borrows self and passes that borrow into the pipe function. Read more

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
    Self: Borrow<B>,
    B: 'a + ?Sized,
    R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more

fn pipe_borrow_mut<'a, B, R>(
    &'a mut self,
    func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
    Self: BorrowMut<B>,
    B: 'a + ?Sized,
    R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
    Self: AsRef<U>,
    U: 'a + ?Sized,
    R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
    Self: AsMut<U>,
    U: 'a + ?Sized,
    R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere
    Self: Deref<Target = T>,
    T: 'a + ?Sized,
    R: 'a,

Borrows self, then passes self.deref() into the pipe function.

fn pipe_deref_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> Rwhere
    Self: DerefMut<Target = T> + Deref,
    T: 'a + ?Sized,
    R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> ProvisionerContextTrait for Twhere
    T: SubsystemContext<Message = ProvisionerMessage, Signal = OverseerSignal, OutgoingMessages = ProvisionerOutgoingMessages, Error = SubsystemError>,
    ProvisionerMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<ProvisionerOutgoingMessages> + From<ProvisionerMessage> + From<()>,
    ProvisionerOutgoingMessages: From<RuntimeApiMessage> + From<CandidateBackingMessage> + From<ChainApiMessage> + From<DisputeCoordinatorMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + ProvisionerSenderTrait + SubsystemSender<ProvisionerOutgoingMessages> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<CandidateBackingMessage> + SubsystemSender<ChainApiMessage> + SubsystemSender<DisputeCoordinatorMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> PvfCheckerContextTrait for Twhere
    T: SubsystemContext<Message = PvfCheckerMessage, Signal = OverseerSignal, OutgoingMessages = PvfCheckerOutgoingMessages, Error = SubsystemError>,
    PvfCheckerMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<PvfCheckerOutgoingMessages> + From<PvfCheckerMessage> + From<()>,
    PvfCheckerOutgoingMessages: From<CandidateValidationMessage> + From<RuntimeApiMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + PvfCheckerSenderTrait + SubsystemSender<PvfCheckerOutgoingMessages> + SubsystemSender<CandidateValidationMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> RuntimeApiContextTrait for Twhere
    T: SubsystemContext<Message = RuntimeApiMessage, Signal = OverseerSignal, OutgoingMessages = RuntimeApiOutgoingMessages, Error = SubsystemError>,
    RuntimeApiMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<RuntimeApiOutgoingMessages> + From<RuntimeApiMessage> + From<()>,
    RuntimeApiOutgoingMessages: From<()>,
    <T as SubsystemContext>::Sender: 'static + RuntimeApiSenderTrait + SubsystemSender<RuntimeApiOutgoingMessages> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> SaturatedConversion for T

fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,

Convert from a value of T into an equivalent instance of Self. Read more

fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,

Consume self to return an equivalent value of T. Read more

impl<T> StatementDistributionContextTrait for Twhere
    T: SubsystemContext<Message = StatementDistributionMessage, Signal = OverseerSignal, OutgoingMessages = StatementDistributionOutgoingMessages, Error = SubsystemError>,
    StatementDistributionMessage: 'static + AssociateOutgoing + Debug + Send,
    AllMessages: From<StatementDistributionOutgoingMessages> + From<StatementDistributionMessage> + From<()>,
    StatementDistributionOutgoingMessages: From<NetworkBridgeTxMessage> + From<CandidateBackingMessage> + From<RuntimeApiMessage> + From<()>,
    <T as SubsystemContext>::Sender: 'static + StatementDistributionSenderTrait + SubsystemSender<StatementDistributionOutgoingMessages> + SubsystemSender<NetworkBridgeTxMessage> + SubsystemSender<CandidateBackingMessage> + SubsystemSender<RuntimeApiMessage> + SubsystemSender<()> + Send,

type Sender = <T as SubsystemContext>::Sender

Sender.

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,

Immutable access to the Deref::Target of a value. Read more

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

Mutable access to the Deref::Target of a value. Read more

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

impl<T> TryConv for T

fn try_conv<T>(self) -> Result<T, Self::Error>where
Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,

fn unchecked_into(self) -> T

The counterpart to unchecked_from.

impl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,

fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of T.

impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

impl<T> Erased for T

impl<T> MaybeDebug for Twhere
T: Debug,

impl<T> MaybeDebug for Twhere
T: Debug,

impl<T> MaybeSend for Twhere
T: Send,