Struct Throttler

pub struct Throttler<T, F> {
    pub recv_count: usize,
    pub sent_count: usize,
    pub is_limiting: bool,
    pub limit: usize,
    pub buffer: VecDeque<T>,
    pub timestamps: VecDeque<UnixNanos>,
    pub clock: Rc<RefCell<dyn Clock>>,
    pub actor_id: Ustr,
    /* private fields */
}

Throttler rate limits messages by dropping or buffering them.

Throttler takes messages of type T and callback of type F for dropping or processing messages.

Fields

recv_count: usize

The number of messages received.

sent_count: usize

The number of messages sent.

is_limiting: bool

Whether the throttler is currently limiting the message rate.

limit: usize

The maximum number of messages that can be sent within the interval.

buffer: VecDeque<T>

The buffer of messages to be sent.

timestamps: VecDeque<UnixNanos>

The timestamps of the sent messages.

clock: Rc<RefCell<dyn Clock>>

The clock used to keep track of time.

actor_id: Ustr

The actor ID of the throttler.

Implementations

impl<T, F> Throttler<T, F>

pub fn new( limit: usize, interval: u64, clock: Rc<RefCell<dyn Clock>>, timer_name: String, output_send: F, output_drop: Option<F>, actor_id: Ustr, ) -> Self

pub fn set_timer(&mut self, callback: Option<TimeEventCallback>)

Set timer with a callback to be triggered on next interval.

Typically used to register callbacks:

• to process buffered messages
• to stop buffering

pub fn delta_next(&mut self) -> u64

Time delta when the next message can be sent.

pub fn reset(&mut self)

Reset the throttler which clears internal state.

pub fn used(&self) -> f64

Fractional value of rate limit consumed in current interval.

pub fn qsize(&self) -> usize

Number of messages queued in buffer.

impl<T, F> Throttler<T, F>

where T: 'static, F: Fn(T) + 'static,

pub fn to_actor(self) -> Rc<UnsafeCell<Self>>

pub fn send_msg(&mut self, msg: T)

pub fn limit_msg(&mut self, msg: T)

pub fn send(&mut self, msg: T)

where T: 'static, F: Fn(T) + 'static,

Trait Implementations

impl<T, F> Actor for Throttler<T, F>

where T: 'static, F: Fn(T) + 'static,

fn id(&self) -> Ustr

fn handle(&mut self, _msg: &dyn Any)

fn as_any(&self) -> &dyn Any

impl<T, F> Debug for Throttler<T, F>

where T: Debug,

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

Formats the value using the given formatter.