Struct RunAgent

pub struct RunAgent<A: Agent> {
    pub agent: Option<A>,
    pub context: Context<A>,
    pub level: InterruptionLevel,
}

Fields

agent: Option<A>

context: Context<A>

level: InterruptionLevel

Implementations

impl<A: Agent> RunAgent<A>

pub fn new(agent: A) -> Self

where A::Context: Default,

pub async fn operate(self)

pub fn report(&mut self, interrupted: bool)

pub async fn perform_and_report(&mut self)

pub async fn perform(&mut self)

pub async fn perform_abortable_task(&mut self) -> Result<()>

Trait Implementations

impl<A: Agent> InteractiveRuntime for RunAgent<A>

type Context = <A as Agent>::Context

Type of the composable block’s contenxt.

fn address(&self) -> <Self::Context as ReachableContext>::Address

impl<A: Agent> InteractiveTask<A> for RunAgent<A>

fn spawn_connected(self) -> <Self::Context as ReachableContext>::Address

impl<A: Agent> IntoFuture for RunAgent<A>

type Output = ()

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = ()> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<A> Runtime for RunAgent<A>

where A: Agent,

fn get_interruptor(&mut self) -> Box<dyn Interruptor>

Used by a lifetime tracker of the supervisor to stop it. It’s the separate type that wraps address made by a runtime.

fn interruption_level(&self) -> InterruptionLevel

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

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

impl<A: Agent> Task<A> for RunAgent<A>

fn spawn(self) -> TaskHandle<T>

fn run<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: Send + 'async_trait,