use std::cell::{Cell, RefCell};
use std::sync::Arc;
pub const DEFAULT_DENSITY: f32 = 1.0;
struct Subscriber {
id: u64,
notify: Arc<dyn Fn() + Send + Sync>,
}
thread_local! {
static CURRENT: Cell<f32> = const { Cell::new(DEFAULT_DENSITY) };
static SUBSCRIBERS: RefCell<Vec<Subscriber>> = const { RefCell::new(Vec::new()) };
static WINDOW_DENSITIES: RefCell<Vec<(u32, f32)>> = const { RefCell::new(Vec::new()) };
static WINDOW_SUBSCRIBERS: RefCell<Vec<(u32, Subscriber)>> = const { RefCell::new(Vec::new()) };
static NEXT_SUBSCRIBER_ID: Cell<u64> = const { Cell::new(1) };
}
pub fn density() -> f32 {
match crate::windows::current_window_id() {
0 => CURRENT.with(Cell::get),
window => density_of(window),
}
}
pub fn density_of(window: u32) -> f32 {
WINDOW_DENSITIES.with_borrow(|densities| {
densities
.iter()
.find(|(id, _)| *id == window)
.map_or(DEFAULT_DENSITY, |(_, scale)| *scale)
})
}
pub(crate) fn publish(scale: f32) -> bool {
if CURRENT.with(Cell::get) == scale {
return false;
}
CURRENT.with(|current| current.set(scale));
SUBSCRIBERS.with_borrow(|subscribers| {
for subscriber in subscribers {
(subscriber.notify)();
}
!subscribers.is_empty()
})
}
pub(crate) fn publish_window(window: u32, scale: f32) -> bool {
let changed = WINDOW_DENSITIES.with_borrow_mut(|densities| {
match densities.iter_mut().find(|(id, _)| *id == window) {
Some(entry) => {
if entry.1 == scale {
return false;
}
entry.1 = scale;
true
}
None => {
densities.push((window, scale));
scale != DEFAULT_DENSITY
}
}
});
if !changed {
return false;
}
WINDOW_SUBSCRIBERS.with_borrow(|subscribers| {
let mut woke = false;
for (id, subscriber) in subscribers {
if *id == window {
(subscriber.notify)();
woke = true;
}
}
woke
})
}
pub(crate) fn window_state_len() -> usize {
WINDOW_DENSITIES.with_borrow(Vec::len) + WINDOW_SUBSCRIBERS.with_borrow(Vec::len)
}
pub(crate) fn forget_window(window: u32) {
WINDOW_DENSITIES.with_borrow_mut(|densities| densities.retain(|(id, _)| *id != window));
}
#[doc(hidden)]
pub fn reset_density() {
CURRENT.with(|current| current.set(DEFAULT_DENSITY));
SUBSCRIBERS.with_borrow_mut(Vec::clear);
WINDOW_DENSITIES.with_borrow_mut(Vec::clear);
WINDOW_SUBSCRIBERS.with_borrow_mut(Vec::clear);
}
fn next_subscriber_id() -> u64 {
NEXT_SUBSCRIBER_ID.with(|next| {
let id = next.get();
next.set(id + 1);
id
})
}
pub struct DensitySubscription {
id: u64,
}
pub fn subscribe(notify: Arc<dyn Fn() + Send + Sync>) -> DensitySubscription {
let id = next_subscriber_id();
SUBSCRIBERS.with_borrow_mut(|subscribers| subscribers.push(Subscriber { id, notify }));
DensitySubscription { id }
}
impl Drop for DensitySubscription {
fn drop(&mut self) {
SUBSCRIBERS.with_borrow_mut(|subscribers| {
subscribers.retain(|subscriber| subscriber.id != self.id);
});
}
}
pub struct WindowDensitySubscription {
id: u64,
}
pub fn subscribe_window(
window: u32,
notify: Arc<dyn Fn() + Send + Sync>,
) -> WindowDensitySubscription {
let id = next_subscriber_id();
WINDOW_SUBSCRIBERS.with_borrow_mut(|subscribers| {
subscribers.push((window, Subscriber { id, notify }));
});
WindowDensitySubscription { id }
}
impl Drop for WindowDensitySubscription {
fn drop(&mut self) {
WINDOW_SUBSCRIBERS.with_borrow_mut(|subscribers| {
subscribers.retain(|(_, subscriber)| subscriber.id != self.id);
});
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
#[test]
fn fr43_density_defaults_to_one_before_the_first_event() {
reset_density();
assert_eq!(density(), 1.0);
assert_eq!(density_of(7), 1.0);
}
#[test]
fn fr43_a_density_report_wakes_only_on_change() {
reset_density();
let woken = Arc::new(AtomicUsize::new(0));
let counter = woken.clone();
let _subscription = subscribe(Arc::new(move || {
counter.fetch_add(1, Ordering::SeqCst);
}));
assert!(!publish(1.0), "1.0 is what was read before any report");
assert!(publish(2.0));
assert!(!publish(2.0), "the same report twice is one change");
assert_eq!(woken.load(Ordering::SeqCst), 1);
assert_eq!(density(), 2.0);
reset_density();
}
#[test]
fn fr43_a_window_density_wakes_only_that_window() {
reset_density();
let woken = Arc::new(AtomicUsize::new(0));
let counter = woken.clone();
let _subscription = subscribe_window(
4,
Arc::new(move || {
counter.fetch_add(1, Ordering::SeqCst);
}),
);
assert!(!publish_window(5, 2.0), "nobody reads window 5");
assert!(!publish_window(4, 1.0), "1.0 is what window 4 read before");
assert!(publish_window(4, 1.5));
assert!(!publish_window(4, 1.5));
assert_eq!(woken.load(Ordering::SeqCst), 1);
assert_eq!((density_of(4), density_of(5)), (1.5, 2.0));
forget_window(4);
assert_eq!(density_of(4), 1.0);
reset_density();
}
}