kabel 0.5.0

kabel
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
103
104
105
106
107
108
109
110
111
112
113
114

use std::{
	any::{Any, TypeId},
	sync::{Arc, LazyLock, OnceLock, atomic::Ordering},
};

use scc::HashMap;
use sdd::{AtomicOwned, Guard, Owned, Tag};

use crate::error::ServiceNotFoundError;

pub type Scope = HashMap<(TypeId, Option<TypeId>), std::sync::OnceLock<Arc<dyn Any + Send + Sync>>>;

pub trait ScopeDefault: ScopeProvider + Sized + 'static {
	fn initialize(scope: Arc<Scope>);
	fn update(scope: Arc<Scope>);
	fn set_as_default(self) {
		let provider: Arc<dyn ScopeProvider> = Arc::new(self);
		let _ =
			DEFAULT_SCOPE_PROVIDER.swap((Some(Owned::new(provider)), Tag::None), Ordering::SeqCst);
	}
}

pub trait ScopeProvider: Send + Sync {
	fn provide_scope(&self) -> Result<Arc<Scope>, ServiceNotFoundError>;
}

static DEFAULT_SCOPE_PROVIDER: LazyLock<AtomicOwned<Arc<dyn ScopeProvider>>> =
	LazyLock::new(|| {
		let provider: Arc<dyn ScopeProvider> = Arc::new(GlobalScopeProvider);
		AtomicOwned::new(provider)
	});

pub fn get_default_scope() -> Arc<dyn ScopeProvider> {
	let guard = Guard::new();
	DEFAULT_SCOPE_PROVIDER
		.load(Ordering::SeqCst, &guard)
		.as_ref()
		.map(Arc::clone)
		.expect("Default scope provider not initialized")
}

pub fn get_default_scope_full() -> Arc<dyn ScopeProvider> { get_default_scope() }

pub fn set_default_scope<T: ScopeDefault + 'static>(scope: T) {
	let provider: Arc<dyn ScopeProvider> = Arc::new(scope);
	let _ = DEFAULT_SCOPE_PROVIDER.swap((Some(Owned::new(provider)), Tag::None), Ordering::SeqCst);
}

pub struct GlobalScopeProvider;

impl ScopeDefault for GlobalScopeProvider {
	fn initialize(scope: Arc<Scope>) { let _ = GLOBAL_SCOPE.set(AtomicOwned::new(scope)); }

	fn update(new_scope: Arc<Scope>) {
		let Some(scope) = GLOBAL_SCOPE.get() else {
			return;
		};
		let _ = scope.swap((Some(Owned::new(new_scope)), Tag::None), Ordering::SeqCst);
	}
}

impl ScopeProvider for GlobalScopeProvider {
	fn provide_scope(&self) -> Result<Arc<Scope>, ServiceNotFoundError> {
		let Some(scope) = GLOBAL_SCOPE.get() else {
			return Err(ServiceNotFoundError);
		};
		let guard = Guard::new();
		scope
			.load(Ordering::SeqCst, &guard)
			.as_ref()
			.map(Arc::clone)
			.ok_or(ServiceNotFoundError)
	}
}

static GLOBAL_SCOPE: OnceLock<AtomicOwned<Arc<Scope>>> = OnceLock::new();

pub struct ThreadLocalScope;

impl ScopeDefault for ThreadLocalScope {
	fn initialize(scope: Arc<Scope>) { let _ = TL_SCOPE.with(|s| s.set(AtomicOwned::new(scope))); }

	fn update(new_scope: Arc<Scope>) {
		TL_SCOPE.with(|s| {
			let Some(scope) = s.get() else {
				return;
			};
			let _ = scope.swap((Some(Owned::new(new_scope)), Tag::None), Ordering::SeqCst);
		});
	}
}

impl ScopeProvider for ThreadLocalScope {
	fn provide_scope(&self) -> Result<Arc<Scope>, ServiceNotFoundError> {
		TL_SCOPE.with(|s| {
			let Some(scope) = s.get() else {
				return Err(ServiceNotFoundError);
			};
			let guard = Guard::new();
			scope
				.load(Ordering::SeqCst, &guard)
				.as_ref()
				.map(Arc::clone)
				.ok_or(ServiceNotFoundError)
		})
	}
}

thread_local! {
	static TL_SCOPE: OnceLock<AtomicOwned<Arc<Scope>>> = OnceLock::new();
}

#[cfg(feature = "tokio")]
pub mod tasks;