Struct overclock::core::AbortableUnboundedHandle

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

Abortable unbounded handle

Implementations

impl<T> AbortableUnboundedHandle<T>

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

Create new abortable unbounded handle

pub 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 is_closed(&self) -> bool

Check if the channel is closed

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

Returns true if senders belong to the same channel

Trait Implementations

impl<T> Clone for AbortableUnboundedHandle<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 AbortableUnboundedHandle<T>

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

Formats the value using the given formatter.

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

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

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

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

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