Struct AgentSession

pub struct AgentSession<A: Agent> {
    pub controller: Controller,
    pub next_state: Option<Next<A>>,
    pub joint: AddressJoint<A>,
    pub address: Address<A>,
}

Fields

controller: Controller

next_state: Option<Next<A>>

joint: AddressJoint<A>

address: Address<A>

Implementations

impl<A: Agent> AgentSession<A>

pub fn joint(&mut self) -> &mut AddressJoint<A>

pub fn do_next(&mut self, next_state: Next<A>)

Methods from Deref<Target = Address<A>>

pub fn send(&self, msg: impl MessageFor<A>) -> Result<()>

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

Important! join must use a reference to allow using it under DerefMut trait

pub fn sender<M>(&self) -> Recipient<M>

where M: MessageFor<A>,

pub fn event<E>(&self, event: E) -> Result<()>

where A: OnEvent<E>, E: TheEvent,

pub fn event_tagged<E, T>(&self, event: E, tag: T) -> Result<()>

where A: OnEvent<E, T>, E: TheEvent, T: Tag,

pub fn recipient<E>(&self) -> Recipient<E>

where A: OnEvent<E>, E: TheEvent,

pub fn recipient_tagged<E, T>(&self, tag: T) -> Recipient<E>

where A: OnEvent<E, T>, E: TheEvent, T: Tag + Sync + Clone,

pub fn interrupt(&self) -> Result<()>

Trait Implementations

impl<A: Agent> AgentContext<A> for AgentSession<A>

fn session(&mut self) -> &mut AgentSession<A>

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

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

impl<A: Agent> AsRef<Address<A>> for AgentSession<A>

fn as_ref(&self) -> &Address<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Agent> Default for AgentSession<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Agent> Deref for AgentSession<A>

type Target = Address<A>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A: Agent> DerefMut for AgentSession<A>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<A: Agent> ManagedContext for AgentSession<A>

fn is_alive(&self) -> bool

fn shutdown(&mut self)

Marks a context as interrupted.

fn stop(&mut self)

impl<A: Agent> ReachableContext for AgentSession<A>

type Address = Address<A>

An address to interact with the context.

fn address(&self) -> &Self::Address

A reference to an address.