Struct StreamSession 

pub struct StreamSession<A: Agent> { /* private fields */ }

Implementations

impl<A: Agent> StreamSession<A>

pub fn consume<E, S>(&mut self, stream: S)

where A: OnEvent<E>, E: TheEvent, S: Stream<Item = E> + Send + Unpin + 'static,

pub fn consume_events<S>(&mut self, stream: S)

where S: Stream<Item = Envelope<A>> + Send + Unpin + 'static,

Methods from Deref<Target = 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<(), Error>

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

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

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

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

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

Trait Implementations

impl<A: Agent> AgentContext<A> for StreamSession<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> Default for StreamSession<A>

fn default() -> Self

Returns the “default value” for a type.

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

type Target = AgentSession<A>

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

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

fn is_alive(&self) -> bool

fn shutdown(&mut self)

Marks a context as interrupted.

fn stop(&mut self)

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

type Address = Address<A>

An address to interact with the context.

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

A reference to an address.