Struct overclock::core::UnboundedHandle

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

Unbounded handle

Implementations

impl<T> UnboundedHandle<T>

pub fn new(
    sender: UnboundedSender<T>,
    gauge: IntGauge,
    abort_handle: AbortHandle,
    scope_id: ScopeId
) -> Self

Create new abortable 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 unbounded receiver is dropped/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 UnboundedHandle<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 UnboundedHandle<T>

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

Formats the value using the given formatter.

impl<M: 'static + Send, E: Send> Route<M> for UnboundedHandle<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: 'static + ShutdownEvent> Shutdown for UnboundedHandle<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 UnboundedHandle<T>

type Event = T

The supervisor event type

fn report<'life0, 'async_trait>(
    &'life0 self,
    scope_id: ScopeId,
    data: 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