Struct RunAgent

pub struct RunAgent<T: Agent> {
    pub agent: Option<T>,
    pub context: T::Context,
    pub failures: Failures,
}

Fields

agent: Option<T>

context: T::Context

failures: Failures

Implementations

impl<T> RunAgent<AsyncFn<T>>

where T: Output,

pub fn new_async<F: AnyAsyncFut<T>>(fut: F) -> Self

impl<T: Output> RunAgent<SyncFn<T>>

pub fn new_sync<F: AnySyncFn<T>>(func: F) -> Self

impl<T: Agent> RunAgent<T>

pub fn new(agent: T) -> Self

where T::Context: Default,

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 Context>::Address

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

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

impl<T> Runtime for RunAgent<T>

where T: Agent,

fn get_interruptor(&mut self) -> 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 routine<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

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

fn spawn(self) -> TaskHandle<T>

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

where Self: Send + 'async_trait,