Struct overclock::core::AbortableBoundedHandle

pub struct AbortableBoundedHandle<T> { /* private fields */ }

Abortable bounded handle

Implementations

impl<T> AbortableBoundedHandle<T>

pub fn new(sender: BoundedHandle<T>) -> Self

Crete new abortable bounded handle

pub async fn send(&self, message: T) -> Result<(), SendError<T>>

Send message to the channel

pub fn send_after( &self, message: T, duration: Duration ) -> JoinHandle<Result<(), SendError<T>>>where T: Send + 'static,

Send message to the channel after the duration pass

pub async fn closed(&self)

Await till the channel is closed

pub fn try_send(&self, message: T) -> Result<(), TrySendError<T>>

Attempts to send message to the channel

pub fn is_closed(&self) -> bool

Check if the channel is closed

pub fn same_channel(&self, other: &Self) -> bool

Returns true if the handle belongs to same channel

Trait Implementations

impl<T> Clone for AbortableBoundedHandle<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for AbortableBoundedHandle<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M: 'static + Send, E> Route<M> for AbortableBoundedHandle<E>where E: TryFrom<M> + Send, E::Error: Send,

fn try_send_msg<'life0, 'async_trait>( &'life0 self, message: M ) -> Pin<Box<dyn Future<Output = Result<Option<M>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Try to send message to the channel.

fn send_msg<'life0, 'async_trait>( &'life0 self, message: M ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

if the Route is behind lock, drop the lock before invoking this method.

impl<E: Send + 'static> Shutdown for AbortableBoundedHandle<E>

fn shutdown<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Send shutdown signal to the corresponding actor

fn scope_id(&self) -> ScopeId

Return the corresponding actor’s scope_id

impl<A: Send + 'static, T: ServiceEvent<A>> SupHandle<A> for AbortableBoundedHandle<T>

type Event = T

The supervisor event type

fn report<'life0, 'async_trait>( &'life0 self, scope_id: ScopeId, service: Service ) -> Pin<Box<dyn Future<Output = Option<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Report any status & service changes return Some(()) if the report success

fn eol<'async_trait>( self, scope_id: ScopeId, service: Service, actor: A, r: ActorResult<()> ) -> Pin<Box<dyn Future<Output = Option<()>> + Send + 'async_trait>>where Self: 'async_trait,

Report End of life for a T actor return Some(()) if the report success