async_priority_limiter/limiter/
builder.rs

1use super::Limiter;
2use crate::{
3    blocks::Blocks,
4    intervals::Intervals,
5    traits::{Key, Priority, TaskResult},
6};
7
8use std::time::Duration;
9use tokio::time::Instant;
10
11#[derive(Debug)]
12pub struct LimiterBuilder<K: Key> {
13    pub(crate) concurrent_tasks: usize,
14    pub(crate) blocks: Blocks<K>,
15    pub(crate) intervals: Intervals<K>,
16}
17
18impl LimiterBuilder<String> {
19    pub fn new<K: Key>(concurrent_tasks: usize) -> LimiterBuilder<K> {
20        LimiterBuilder {
21            concurrent_tasks,
22            blocks: Default::default(),
23            intervals: Default::default(),
24        }
25    }
26}
27
28impl<K: Key> LimiterBuilder<K> {
29    pub fn with_concurrent_tasks(mut self, concurrent_tasks: usize) -> Self {
30        self.concurrent_tasks = concurrent_tasks;
31        self
32    }
33    pub fn with_default_block_until(mut self, instant: Option<Instant>) -> Self {
34        self.blocks.set_default(instant);
35        self
36    }
37    pub fn with_default_block_until_at_least(mut self, instant: Instant) -> Self {
38        self.blocks.set_default_at_least(instant);
39        self
40    }
41    pub fn with_block_by_key_until(mut self, instant: Option<Instant>, key: K) -> Self {
42        self.blocks.set_by_key(instant, key);
43        self
44    }
45    pub fn with_block_by_key_until_at_least(mut self, instant: Instant, key: K) -> Self {
46        self.blocks.set_at_least_by_key(instant, key);
47        self
48    }
49
50    pub fn with_default_interval(mut self, period: Option<Duration>) -> Self {
51        self.intervals.set_default(period);
52        self
53    }
54    pub fn with_default_interval_at_least(mut self, period: Duration) -> Self {
55        self.intervals.set_default_at_least(period);
56        self
57    }
58    pub fn with_interval_by_key(mut self, period: Option<Duration>, key: K) -> Self {
59        self.intervals.set_by_key(period, key);
60        self
61    }
62    pub fn with_interval_by_key_at_least(mut self, period: Duration, key: K) -> Self {
63        self.intervals.set_at_least_by_key(period, key);
64        self
65    }
66
67    pub fn build<P: Priority, T: TaskResult>(self) -> Limiter<K, P, T> {
68        Limiter::new_with::<K>(self.concurrent_tasks, self.blocks, self.intervals)
69    }
70}
async_priority_limiter/limiter/builder.rs

async_priority_limiter/limiter/
builder.rs
