uxum 0.9.3

Opinionated backend service framework based on axum
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! State extractor support for method handlers.

use std::{
    any::{Any, TypeId},
    collections::HashMap,
    hash::{BuildHasherDefault, Hasher},
    sync::LazyLock,
};

use parking_lot::Mutex;

type AnyMap = HashMap<TypeId, Box<dyn StateClone + Send>, BuildHasherDefault<IdHasher>>;

static STATES: LazyLock<Mutex<AnyMap>> = LazyLock::new(|| Mutex::new(Default::default()));

/// Hasher for [`TypeId`] values.
///
/// No transformations are necessary, as type IDs are already pre-hashed by compiler.
#[derive(Default)]
struct IdHasher(u64);

impl Hasher for IdHasher {
    fn write(&mut self, _: &[u8]) {
        unreachable!("TypeId calls write_u64");
    }

    #[inline]
    fn write_u64(&mut self, id: u64) {
        self.0 = id;
    }

    #[inline]
    fn finish(&self) -> u64 {
        self.0
    }
}

/// Get a clone of previously registered state object.
///
/// # Panics
///
/// This call will panic if no previously registered object of type S has been found.
pub fn get<S>() -> S
where
    S: StateClone + Clone + Send,
{
    let type_id = TypeId::of::<S>();
    match STATES.lock().get(&type_id) {
        // SAFETY: It is reasonable to assume that entry keyed as type ID of S
        // will have type S. So unwrap() cannot panic here.
        Some(state) => (**state).as_any().downcast_ref::<S>().unwrap().clone(),
        None => panic!("State is missing from state registry"),
    }
}

/// Register state object for use in handlers.
pub fn put<S>(state: S)
where
    S: StateClone + Clone + Send,
{
    let type_id = TypeId::of::<S>();
    STATES.lock().insert(type_id, Box::new(state));
}

/// Trait that is required to be implemented for types of state objects.
pub trait StateClone: Any {
    /// Auto-boxing clone helper method.
    fn clone_box(&self) -> Box<dyn StateClone + Send>;
    /// Convert to `&dyn Any`.
    fn as_any(&self) -> &dyn Any;
    /// Convert to `&mut dyn Any`.
    fn as_any_mut(&mut self) -> &mut dyn Any;
    /// Convert to `Box<dyn Any>`.
    fn into_any(self: Box<Self>) -> Box<dyn Any>;
}

impl<T> StateClone for T
where
    T: Clone + Send + 'static,
{
    fn clone_box(&self) -> Box<dyn StateClone + Send> {
        Box::new(self.clone())
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    fn into_any(self: Box<Self>) -> Box<dyn Any> {
        self
    }
}

impl Clone for Box<dyn StateClone + Send + 'static> {
    fn clone(&self) -> Self {
        (**self).clone_box()
    }
}