rustact 0.1.0

Async terminal UI framework inspired by React, built on top of ratatui and tokio.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::sync::Arc;

type AnyArc = Arc<dyn Any + Send + Sync>;

#[derive(Default, Debug)]
pub struct ContextStack {
    layers: HashMap<TypeId, Vec<AnyArc>>,
}

impl ContextStack {
    pub fn new() -> Self {
        Self {
            layers: HashMap::new(),
        }
    }

    pub fn provide<T>(&mut self, value: T) -> ContextGuard<'_>
    where
        T: Send + Sync + 'static,
    {
        let type_id = TypeId::of::<T>();
        let entry = self.layers.entry(type_id).or_default();
        entry.push(Arc::new(value));
        ContextGuard {
            stack: self,
            type_id,
        }
    }

    pub fn get<T>(&self) -> Option<Arc<T>>
    where
        T: Send + Sync + 'static,
    {
        self.layers
            .get(&TypeId::of::<T>())
            .and_then(|entries| entries.last())
            .and_then(|arc| arc.clone().downcast::<T>().ok())
    }

    fn pop(&mut self, type_id: TypeId) {
        if let Some(stack) = self.layers.get_mut(&type_id) {
            stack.pop();
            if stack.is_empty() {
                self.layers.remove(&type_id);
            }
        }
    }
}

pub struct ContextGuard<'a> {
    stack: &'a mut ContextStack,
    type_id: TypeId,
}

impl Drop for ContextGuard<'_> {
    fn drop(&mut self) {
        self.stack.pop(self.type_id);
    }
}