cluStaticData 1.2.0

Initializers of static values. Manual initialization, automatic initialization.
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131


pub mod core {
	mod always_lock;
	pub use self::always_lock::*;
	
	mod atomic_lock;
	pub use self::atomic_lock::*;
}

pub mod generic;

#[macro_use]
mod macros;
pub use self::macros::*;

use ::core::fmt::Debug;
use ::core::fmt::Display;
use ::core::ops::Deref;
use ::core::sync::atomic::AtomicU8;
use ::core::cell::UnsafeCell;
use ::core::fmt;

use crate::once_const_static::generic::GenericStaticData;
use crate::once_const_static::generic::UnsafeGenericStaticData;
use crate::once_const_static::core::AlwaysLockOnce;

use crate::err::StaticErr;
use crate::err::IgnoreInitErr;




pub type StaticData<T>			= UnkStaticData<T, AtomicU8>;
pub type StaticDataAlwaysLock<T>	= UnkStaticData<T, AlwaysLockOnce>;

pub struct UnkStaticData<T, I> {
	data: UnsafeCell<T>,
	sync_data: I,
}

unsafe impl<T, I> Sync for UnkStaticData<T, I> where T: Sync {}
unsafe impl<T, I> Send for UnkStaticData<T, I> where T: Sync + Send {}

//DONT TRAIT!
impl<T, I> UnkStaticData<T, I> where Self: UnsafeGenericStaticData<T> {
	#[inline(always)]
	pub unsafe fn set_box(&self, v: Box<T>) -> Result<(), StaticErr<Box<T>>> {
		UnsafeGenericStaticData::set_box(self, v)
	}
	
	#[inline(always)]
	pub unsafe fn set_raw(&self, v: T) -> Result<(), StaticErr<T>> {
		UnsafeGenericStaticData::set_raw(self, v)
	}
}

impl<T, I> UnkStaticData<T, I> where Self: GenericStaticData<T> {
	#[inline(always)]
	pub fn set(&self, v: T) -> Result<(), StaticErr<T>> {
		GenericStaticData::set(self, v)
	}
	
	#[inline(always)]
	pub fn replace(&self, v: T) -> Result<T, StaticErr<T>> {
		GenericStaticData::replace(self, v)
	}
	
	#[inline(always)]
	pub unsafe fn unsafe_replace(&self, v: T) -> T {
		GenericStaticData::unsafe_replace(self, v)
	}
	
	#[inline(always)]
	pub fn get<'a>(&'a self) -> &'a T {
		GenericStaticData::get(self)
	}
	
	#[inline(always)]
	pub fn ignore_initialize(&self) -> Result<(), IgnoreInitErr> {
		GenericStaticData::ignore_initialize(self)	
	}
	
	#[inline(always)]
	pub fn ignore_initialize_dont_result(&self) {
		GenericStaticData::ignore_initialize_dont_result(self)
	}
	
	#[inline(always)]
	pub fn is_init_state(&self) -> bool {
		GenericStaticData::is_init_state(self)
	}
	
	#[inline(always)]
	pub fn is_noinit_state(&self) -> bool {
		GenericStaticData::is_noinit_state(self)
	}
}


impl<T, I> AsRef<T> for UnkStaticData<T, I> where Self: GenericStaticData<T> {
	#[inline(always)]
	fn as_ref(&self) -> &T {
		self.get()
	}
}

impl<T, I> Deref for UnkStaticData<T, I> where Self: GenericStaticData<T> {
	type Target = T;
	
	#[inline(always)]
	fn deref(&self) -> &Self::Target {
		self.get()
	}
}

impl<T, I> Debug for UnkStaticData<T, I> where T: Debug, Self: GenericStaticData<T> {
	#[inline(always)]
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		self.get().fmt(f)
	}
}

impl<T, I> Display for UnkStaticData<T, I> where T: Display, Self: GenericStaticData<T> {
	#[inline(always)]
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		self.get().fmt(f)
	}
}