use rustc_hash::FxHashSet;
use std::cell::RefCell;
use web_time::Instant;
use crate::core::clock;
pub(crate) mod keys {
pub const CURSOR_BLINK: u64 = 4;
pub const TOOLTIP: u64 = 10;
pub const ANIM_DRIVER: u64 = 0x414E_494D; pub const EXIT_ANIMS: u64 = 0x4558_4954; pub const TOAST: u64 = 0x70A5_70A5;
pub const NS_SPINNER: u32 = 1;
#[allow(dead_code)]
pub const NS_DRIVER: u32 = 2;
pub const NS_ACCORDION: u32 = 3;
#[allow(dead_code)]
pub const NS_DEVTOOLS: u32 = 4;
pub fn element_key(ns: u32, eid: crate::core::ElementId) -> u64 {
((ns as u64) << 32) | (eid.0 & 0xFFFF_FFFF)
}
#[allow(dead_code)]
pub fn register_key() -> u64 {
use std::sync::atomic::{AtomicU64, Ordering};
static NEXT: AtomicU64 = AtomicU64::new(0x1000_0000_0000);
NEXT.fetch_add(1, Ordering::Relaxed)
}
}
struct DeadlineEntry {
instant: Instant,
key: u64,
}
#[derive(Default)]
struct SchedulerDomain {
continuous: RefCell<FxHashSet<u64>>,
element_renewed: RefCell<FxHashSet<u64>>,
discrete: RefCell<Vec<DeadlineEntry>>,
}
fn domain() -> std::rc::Rc<SchedulerDomain> {
crate::core::app_context::current_app().extension::<SchedulerDomain>()
}
pub(crate) fn acquire_continuous(key: u64) {
domain().continuous.borrow_mut().insert(key);
}
pub(crate) fn release_continuous(key: u64) {
domain().continuous.borrow_mut().remove(&key);
}
pub(crate) fn acquire_element_continuous(key: u64) {
let dom = domain();
dom.continuous.borrow_mut().insert(key);
dom.element_renewed.borrow_mut().insert(key);
}
pub(crate) fn sweep_stale_element_wakes() {
let dom = domain();
let renewed = std::mem::take(&mut *dom.element_renewed.borrow_mut());
dom.continuous
.borrow_mut()
.retain(|k| (k >> 32) == 0 || renewed.contains(k));
}
pub(crate) fn schedule_at(instant: Instant, key: u64) {
let dom = domain();
let mut v = dom.discrete.borrow_mut();
v.retain(|e| e.key != key);
v.push(DeadlineEntry { instant, key });
}
pub(crate) fn cancel(key: u64) {
let dom = domain();
dom.discrete.borrow_mut().retain(|e| e.key != key);
dom.continuous.borrow_mut().remove(&key);
}
pub fn next_deadline() -> Option<Instant> {
let dom = domain();
if !dom.continuous.borrow().is_empty() {
return Some(clock::now());
}
let v = dom.discrete.borrow();
v.iter().map(|e| e.instant).min()
}
pub fn has_continuous() -> bool {
!domain().continuous.borrow().is_empty()
}
pub(crate) fn expired_discrete() -> bool {
let now = clock::now();
domain().discrete.borrow().iter().any(|e| e.instant <= now)
}
pub(crate) fn drain_expired() -> bool {
let now = clock::now();
let dom = domain();
let mut v = dom.discrete.borrow_mut();
let before = v.len();
v.retain(|e| e.instant > now);
before != v.len()
}
pub(crate) fn any_active() -> bool {
let dom = domain();
if !dom.continuous.borrow().is_empty() {
return true;
}
let pending = !dom.discrete.borrow().is_empty();
pending
}
pub(crate) fn reset() {
let dom = domain();
dom.continuous.borrow_mut().clear();
dom.element_renewed.borrow_mut().clear();
dom.discrete.borrow_mut().clear();
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::clock;
use std::time::Duration;
#[test]
fn continuous_is_reference_counted_by_key() {
reset();
acquire_continuous(1);
acquire_continuous(2);
release_continuous(1);
assert!(has_continuous(), "key 2 still holds the wake");
release_continuous(2);
assert!(!has_continuous(), "all keys released -> sleep");
}
#[test]
fn acquire_is_idempotent_per_key() {
reset();
acquire_continuous(7);
acquire_continuous(7);
release_continuous(7);
assert!(
!has_continuous(),
"one release clears an idempotent acquire"
);
}
#[test]
fn cancel_clears_both_discrete_and_continuous_for_key() {
reset();
clock::install_virtual();
acquire_continuous(9);
schedule_at(clock::now() + Duration::from_millis(100), 9);
cancel(9);
assert!(!any_active(), "cancel(key) evicts continuous AND discrete");
clock::reset_to_wall();
}
#[test]
fn release_of_foreign_key_does_not_affect_others() {
reset();
acquire_continuous(11);
release_continuous(12); assert!(has_continuous());
release_continuous(11);
assert!(!has_continuous());
}
#[test]
fn empty_scheduler_has_no_deadline() {
reset();
assert!(!any_active());
assert!(next_deadline().is_none());
}
#[test]
fn discrete_deadline_returns_earliest() {
reset();
clock::install_virtual();
let t0 = clock::now();
schedule_at(t0 + Duration::from_millis(500), 1);
schedule_at(t0 + Duration::from_millis(300), 2);
let d = next_deadline().unwrap();
assert_eq!(d, t0 + Duration::from_millis(300));
}
#[test]
fn cancel_removes_discrete() {
reset();
clock::install_virtual();
let t0 = clock::now();
schedule_at(t0 + Duration::from_millis(500), 1);
assert!(any_active());
cancel(1);
assert!(!any_active());
assert!(next_deadline().is_none());
}
#[test]
fn continuous_overrides_discrete() {
reset();
clock::install_virtual();
let t0 = clock::now();
schedule_at(t0 + Duration::from_millis(5000), 1);
acquire_continuous(42);
let d = next_deadline().unwrap();
assert!(d <= clock::now());
}
#[test]
fn release_continuous_restores_discrete() {
reset();
clock::install_virtual();
let t0 = clock::now();
schedule_at(t0 + Duration::from_millis(500), 1);
acquire_continuous(42);
release_continuous(42);
let d = next_deadline().unwrap();
assert_eq!(d, t0 + Duration::from_millis(500));
}
#[test]
fn schedule_same_key_replaces() {
reset();
clock::install_virtual();
let t0 = clock::now();
schedule_at(t0 + Duration::from_millis(500), 1);
schedule_at(t0 + Duration::from_millis(200), 1); let d = next_deadline().unwrap();
assert_eq!(d, t0 + Duration::from_millis(200));
}
}