Struct TimerDequeConsumer 

pub struct TimerDequeConsumer<R, MODE>
where
    R: PartialEq + Eq + Debug + Display + Send + Clone,
    MODE: OrderedTimerDequeMode,
{ /* private fields */ }

This type of the queue consumes the instance for which the timer is set. The item must be Send and Clone, std::sync::Arc. This is convinient when it is required to store the instance in the timer and retrive it when the timeout happens. This method allows to avoid for lookups in the lists and working directly with the stored items.

Generics

R - an instance which should be stored on the timer dequeue. The instance must implement PartialEq, Eq, fmt::Debug, fmt::Display, Send.

MODE - a OrderedTimerDequeMode which defines the deque behaviour. There are two types of the operation:

• [OrderdTimerDequeOnce] - after timeout the element is removed from the queue.

• [OrderdTimerDequePeriodic] - after timeout the element timeout is extended until the item is not removed from the queue manually.

Example

let mut time_list = 
    OrderedTimerDeque
        ::<DequeOnce, TimerDequeConsumer<u64, _>>
        ::new("test_label1".into(), 4, false, true)
           .unwrap();

or

let mut time_list = 
    OrderedTimerDeque
        ::<DequePeriodic, TimerDequeConsumer<u64, _>>
        ::new("test_label1".into(), 4, false, true)
           .unwrap();

Trait Implementations

impl<R, MODE> Debug for TimerDequeConsumer<R, MODE>

where R: PartialEq + Eq + Debug + Display + Send + Clone + Debug, MODE: OrderedTimerDequeMode + Debug,

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

Formats the value using the given formatter.

impl<R, MODE> Display for TimerDequeConsumer<R, MODE>

where R: PartialEq + Eq + Display + Debug + Send + Clone, MODE: OrderedTimerDequeMode,

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

Formats the value using the given formatter.

impl<R, MODE> Ord for TimerDequeConsumer<R, MODE>

where R: PartialEq + Eq + Display + Debug + Send + Clone, MODE: OrderedTimerDequeMode,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<MODE, R> OrderedTimerDequeHandle<MODE> for TimerDequeConsumer<R, MODE>

where MODE: OrderedTimerDequeMode, R: PartialEq + Eq + Display + Debug + Send + Clone,

type TimerId = R

Input item.

type HandleRes = Vec<<TimerDequeConsumer<R, MODE> as OrderedTimerDequeHandle<MODE>>::TimerId>

A collection which is used to collect the items which are removed from the queue due to timeout.

fn handle( self, timer_self: &mut OrderTimerDeque<MODE, Self>, timer_ids: &mut Self::HandleRes, ) -> TimerResult<()>

A spefic code which is called during timeout routine handling. Normally is should store the result into the collection and reschedule the item if it is repeated.

fn is_same(&self, other: &Self::TimerId) -> bool

Matches the current instance with provided other instances OrderedTimerDequeHandle::TimerId. But, the PartialEq<Self::TimerId> is implemented, so the == can be used to compare.

fn postpone(&mut self, postp_time: RelativeTime) -> TimerResult<()>

Postpones the timeout of the current instance. The postp_time is a RelativeTime i.e inroduces the offset.

fn resched(&mut self, time: MODE) -> TimerResult<()>

Reschedules the current instance. This is different from the postpone as the instance is assagned with a new time. The MODE cannot be changed, only time.

fn into_timer_id(self) -> Option<Self::TimerId>

Attempts to acquire the OrderedTimerDequeHandle::TimerId by consuming the instance.

impl<MODE, R> OrderedTimerDequeInterf<MODE> for TimerDequeConsumer<R, MODE>

where MODE: OrderedTimerDequeMode, R: PartialEq + Eq + Display + Debug + Send + Clone,

fn get_timeout_absolute(&self) -> AbsoluteTime

Returns the absolute time and the timer mode.

impl<R, MODE> PartialEq<R> for TimerDequeConsumer<R, MODE>

where R: PartialEq + Eq + Display + Debug + Send + Clone, MODE: OrderedTimerDequeMode,

fn eq(&self, other: &R) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R, MODE> PartialEq for TimerDequeConsumer<R, MODE>

where R: PartialEq + Eq + Display + Debug + Send + Clone, MODE: OrderedTimerDequeMode,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R, MODE> PartialOrd for TimerDequeConsumer<R, MODE>

where R: PartialEq + Eq + Display + Debug + Send + Clone, MODE: OrderedTimerDequeMode,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<R, MODE> Eq for TimerDequeConsumer<R, MODE>

where R: PartialEq + Eq + Display + Debug + Send + Clone, MODE: OrderedTimerDequeMode,