SafeManuallyDrop 1.0.3

A safe version of ManuallyDrop with various features and options to track undefined behavior when working with ManuallyDrop.
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


use core::fmt::Arguments;
use crate::core::trig::TrigManuallyDrop;

#[cfg(feature = "support_istrig_loop")]
mod _support_istrig_loop {
	use core::sync::atomic::Ordering;
	use core::sync::atomic::AtomicBool;

	pub static IS_TRIG_LOOPSAFEMANUALLYDROP: AtomicBool = AtomicBool::new(false);

	pub const DEF_SETORDERING: Ordering = Ordering::SeqCst;
	pub const DEF_GETORDERING: Ordering = Ordering::Relaxed;
}

//

/// The safe version of ManuallyDrop loops the current thread in case of undefined behavior, 
/// and using the `support_istrig_loop` build flag, you can determine whether the 
/// thread looped. 
pub type AlwaysSafeEmptyLoopManuallyDrop<T> = crate::beh::safe::SafeManuallyDrop<T, EmptyLoopTrigManuallyDrop>;

/// The safe or unsafe version of ManuallyDrop loops the current thread in case 
/// of undefined behavior, and with the build flag `support_istrig_loop` you 
/// can determine if the thread is looped.
pub type AutoSafeEmptyLoopManuallyDrop<T> = crate::beh::auto::AutoSafeManuallyDrop<T, EmptyLoopTrigManuallyDrop>;

/// Starts looping the current thread on error, and with the 
/// `support_istrig_loop` build flag you can determine if a thread is looped.
pub enum EmptyLoopTrigManuallyDrop {}

impl TrigManuallyDrop for EmptyLoopTrigManuallyDrop {
	#[inline]
	fn trig_next_invalid_beh<'a>(_a: Arguments<'a>) -> trig_manuallydrop_returntype!() {
		#[cfg(feature = "support_istrig_loop")] {
			unsafe {
				crate::core::trig::r#loop::trig_next_invalid_beh()
			}
		}
		
		loop {}
	}
}

/// Globally marks the presence state of a 
/// looped thread when undefined behavior is detected.
#[cfg(feature = "support_istrig_loop")]
#[inline]
pub unsafe fn trig_next_invalid_beh() {
	_support_istrig_loop::IS_TRIG_LOOPSAFEMANUALLYDROP.store(
		true, 
		_support_istrig_loop::DEF_SETORDERING
	);
}

/// Globally marks the presence state of a 
/// looped thread when undefined behavior is detected.
#[cfg(not(feature = "support_istrig_loop"))]
#[inline]
pub const unsafe fn trig_next_invalid_beh() {}

/// Check if at least one thread has been globally 
/// looped to avoid undefined behavior.
#[cfg(feature = "support_istrig_loop")]
#[inline]
pub fn is_trig_next_invalid_beh() -> bool {
	_support_istrig_loop::IS_TRIG_LOOPSAFEMANUALLYDROP.load(
		_support_istrig_loop::DEF_GETORDERING
	)
}

/// Check if at least one thread has been globally 
/// looped to avoid undefined behavior.
/// (Because `support_istrig_loop` is disabled, this function will always return false.)
#[cfg(not(feature = "support_istrig_loop"))]
#[inline]
pub const fn is_trig_next_invalid_beh() -> bool {
	false
}

impl AutoSafeEmptyLoopManuallyDrop<()> {
	/// Check if at least one thread has been globally looped to avoid undefined behavior.
	#[inline(always)]
	pub fn is_trig_next_invalid_beh() -> bool {
		crate::core::trig::r#loop::is_trig_next_invalid_beh()
	}
}