Struct RunAgent 

pub struct RunAgent<A>
where
    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> RunAgent<A>

where A: Agent,

pub fn new(agent: A) -> RunAgent<A>

where <A as Agent>::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<(), Error>

Trait Implementations

impl<A> InteractiveRuntime for RunAgent<A>

where A: Agent,

type Context = <A as Agent>::Context

Type of the composable block’s contenxt.

fn address( &self, ) -> <<RunAgent<A> as InteractiveRuntime>::Context as ReachableContext>::Address

impl<A> InteractiveTask<A> for RunAgent<A>

where A: Agent,

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

impl<A> IntoFuture for RunAgent<A>

where A: Agent,

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) -> <RunAgent<A> as IntoFuture>::IntoFuture

Creates a future from a value.

impl<A> MoltingRuntime for RunAgent<A>

where A: Agent<Context = MoltingSession<A>>,

fn do_molting(self: Box<RunAgent<A>>) -> Option<Box<dyn MoltingRuntime>>

impl<A> Runtime for RunAgent<A>

where A: Agent,

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

The get_interruptor method returns an instance of an interruptor.

fn interruption_level(&self) -> InterruptionLevel

The interruption_level method returns the default level at which the runtime should be interrupted.

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

where 'life0: 'async_trait, RunAgent<A>: 'async_trait,

The asynchronous routine method is the primary execution method of the Runtime.

impl<A> Task<A> for RunAgent<A>

where A: Agent,

fn spawn(self) -> TaskHandle<T>

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

where Self: Send + 'async_trait,