use std::time::Duration;
use tokio::time::{Instant, sleep_until};
use tracing::info;
use crate::{LOG, update_trigger::UpdateTrigger};
pub struct Rate<T> {
update_interval: Duration,
trigger_value: T,
next_trigger: Instant,
}
impl<T> Rate<T> {
pub fn new(sleep_duration: Duration, trigger_value: T) -> Self {
Self {
update_interval: sleep_duration,
trigger_value,
next_trigger: Instant::now(),
}
}
pub fn set_interval(&mut self, interval: Duration) {
self.next_trigger -= self.update_interval;
self.next_trigger += interval;
self.update_interval = interval;
}
}
impl<T: Clone> UpdateTrigger<T> for Rate<T> {
async fn update_triggered(&mut self) -> Result<T, crate::update_trigger::UpdateTriggerError> {
sleep_until(self.next_trigger).await;
self.next_trigger = Instant::now() + self.update_interval;
info!(target: LOG, "Slept for {} seconds. Time to check for updates.", self.update_interval.as_secs());
Ok(self.trigger_value.clone())
}
}
pub struct Immediately<T: Clone> {
value: T,
}
impl<T: Clone> Immediately<T> {
pub fn new(value: T) -> Self {
Self { value }
}
}
impl<T: Clone> UpdateTrigger<T> for Immediately<T> {
async fn update_triggered(&mut self) -> Result<T, crate::update_trigger::UpdateTriggerError> {
Ok(self.value.clone())
}
}
#[test]
fn test_change_rate() {
let mut trigger = Rate::new(Duration::from_secs(5), ());
let next_trigger = trigger.next_trigger;
trigger.set_interval(Duration::from_secs(30)); assert_eq!(trigger.next_trigger, next_trigger + Duration::from_secs(25));
trigger.set_interval(Duration::from_secs(10)); assert_eq!(trigger.next_trigger, next_trigger + Duration::from_secs(5));
}