Trait overclock::core::Channel

pub trait Channel: Send + Sized {
    type Event: Send;
    type Handle: Send + Clone + Shutdown;
    type Inbox: Send + Sync;
    type Metric: Collector + Clone;

    // Required method
    fn channel<T>(
        self,
        scope_id: ScopeId
    ) -> (Self::Handle, Self::Inbox, AbortRegistration, Option<Self::Metric>, Option<Box<dyn Route<Self::Event>>>);

    // Provided method
    fn type_name() -> Cow<'static, str> { ... }
}

Defines a channel which becomes a sender and receiver half

Required Associated Types

type Event: Send

The channel Event type

type Handle: Send + Clone + Shutdown

The sender half of the channel

type Inbox: Send + Sync

The receiver half of the channel

type Metric: Collector + Clone

Metric Collector

Required Methods

fn channel<T>( self, scope_id: ScopeId ) -> (Self::Handle, Self::Inbox, AbortRegistration, Option<Self::Metric>, Option<Box<dyn Route<Self::Event>>>)

Create a sender and receiver of the appropriate types

Provided Methods

fn type_name() -> Cow<'static, str>

Get this channel’s name

Implementations on Foreign Types

impl Channel for Duration

type Event = Instant

type Handle = IntervalHandle

type Inbox = Abortable<IntervalStream>

type Metric = GenericGauge<AtomicI64>

fn channel<T>( self, scope_id: ScopeId ) -> (Self::Handle, Self::Inbox, AbortRegistration, Option<IntGauge>, Option<Box<dyn Route<Self::Event>>>)

Implementors

impl Channel for NullChannel

type Event = ()

type Handle = NullHandle

type Inbox = NullInbox

type Metric = GenericGauge<AtomicI64>

impl Channel for TcpListenerStream

type Event = ()

type Handle = TcpListenerHandle

type Inbox = Abortable<TcpListenerStream>

type Metric = GenericGauge<AtomicI64>

impl<E: Send + 'static> Channel for AbortableUnboundedChannel<E>

type Event = E

type Handle = AbortableUnboundedHandle<E>

type Inbox = AbortableUnboundedInbox<E>

type Metric = GenericGauge<AtomicI64>

impl<E: Send + 'static, const C: usize> Channel for AbortableBoundedChannel<E, C>

type Event = E

type Handle = AbortableBoundedHandle<E>

type Inbox = AbortableBoundedInbox<E>

type Metric = GenericGauge<AtomicI64>

impl<E: ShutdownEvent + 'static> Channel for UnboundedChannel<E>

type Event = E

type Handle = UnboundedHandle<E>

type Inbox = UnboundedInbox<E>

type Metric = GenericGauge<AtomicI64>

impl<E: ShutdownEvent + 'static, const C: usize> Channel for BoundedChannel<E, C>

type Event = E

type Handle = BoundedHandle<E>

type Inbox = BoundedInbox<E>

type Metric = GenericGauge<AtomicI64>

impl<S> Channel for IoChannel<S>where S: Send + 'static + Sync,

type Event = ()

type Handle = IoHandle

type Inbox = Abortable<S>

type Metric = GenericGauge<AtomicI64>

impl<T, B: Send + Sync + 'static> Channel for Marker<T, B>where T: Channel,

type Event = <T as Channel>::Event

type Handle = Marker<<T as Channel>::Handle, B>

type Inbox = <T as Channel>::Inbox

type Metric = <T as Channel>::Metric

impl<const I: u64> Channel for IntervalChannel<I>

type Event = Instant

type Handle = IntervalHandle

type Inbox = Abortable<IntervalStream>

type Metric = GenericGauge<AtomicI64>