1. Updated Github actions to fully test "features".

2. Library version updated to 1.0.3.
3. Added support for AbortManuallyDrop (requires support for std), in case of undefined behavior breaks the entire program with an error output.
4. Documentation update
5. Updated examples
6. Detector code for the default ManuallyDrop type has been updated.

Author: denisandroid

.github/workflows/CI.yml

@@ -34,4 +34,11 @@ jobs:
       run: cargo test --no-default-features --lib --verbose
     - name: Run cargo alltest
       run: cargo test --all-features --verbose
-
+    - name: PanicManDrop
+      run: cargo test --no-default-features --features always_build_flagstable,allow_fullinternal_debug_assertions,always_check_in_case_debug_assertions,always_deftrig_panic,support_panic_trig --lib --verbose
+    - name: AbortManDrop
+      run: cargo test --no-default-features --features always_build_flagstable,allow_fullinternal_debug_assertions,always_check_in_case_debug_assertions,always_deftrig_abort,support_abort_trig --lib --verbose
+    - name: HookFnManDrop
+      run: cargo test --no-default-features --features always_build_flagstable,allow_fullinternal_debug_assertions,always_check_in_case_debug_assertions,always_deftrig_hookfn,support_hookfn_trig --lib --verbose
+    - name: CountFnManDrop
+      run: cargo test --no-default-features --features always_build_flagstable,allow_fullinternal_debug_assertions,always_check_in_case_debug_assertions,always_deftrig_count,support_count_trig --lib --verbose

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "SafeManuallyDrop"
-version = "1.0.2"
+version = "1.0.3"
 authors = ["Denis Kotlyarov (Денис Котляров) <[email protected]>"]
 repository = "https://github.com/clucompany/SafeManuallyDrop.git"
 edition = "2021"
@@ -23,7 +23,6 @@ rustdoc-args = ["--cfg", "docsrs"]
 default = [
 	# Flags:
 	#
-	
 	# ManuallyDrop and AutoManuallyDrop are always type safe and are automatically 
 	# checked on use if the debug_assertions flag is enabled (the flag is automatically 
 	# enabled if test build, debug build, or env: CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS=true).
@@ -54,13 +53,16 @@ default = [
 
 	# Trigs:
 	#
-	
 	# Ability to determine if an empty loop trigger has been executed.
 	"support_istrig_loop",
 
 	# Support for PanicManuallyDrop, in case of undefined behavior 
-	# of PanicManuallyDrop there will be a panic.
-	"support_panic_trig", 
+	# of ManuallyDrop there will be a panic.
+	"support_panic_trig",
+	
+	# Support for AbortManuallyDrop, in case of undefined behavior 
+	# of ManuallyDrop there will be a abort. (Note that this feature requires std.)
+	#"support_abort_trig",
 
 	# HookManuallyDrop support, in case of undefined HookManuallyDrop behavior, 
 	# the hook function will be called.
@@ -74,9 +76,13 @@ default = [
 	# cause a panic in case of undefined behavior.
 	#"always_deftrig_panic",
 
+	# The behavior for the simple AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop type will always 
+	# cause a abort in case of undefined behavior.
+	#"always_deftrig_abort",
+	
 	# The behavior for the simple AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop type will always 
 	# call the hook function in case of undefined behavior.
-	#"always_deftrig_hookfn",
+	"always_deftrig_hookfn",
 
 	# The behavior for the simple AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop type will always call 
 	# the +1 counter function in case of undefined behavior.
@@ -85,39 +91,61 @@ default = [
 	# The behavior for the simple type AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop will always call 
 	# the eternal loop function in case of undefined behavior.
 	#"always_deftrig_loop"
-	
-	# INFO:
-	# If the behavior for the general AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop is not fixed, 
-	# the behavior will be determined according to the following scheme:
-	#
-	#	always_deftrig_panic not exists AND
-	#	always_deftrig_hookfn not exists AND
-	#	always_deftrig_count not exists AND
-	#	always_deftrig_loop not exists THEN
-	#
-	#	support_hookfn_trig -> Hook,	else:
-	#	support_panic_trig -> Panic,	else:
-	#	support_count_trig -> Count,	else:
-	#		Loop
-	#
 ]
+
+# ManuallyDrop and AutoManuallyDrop are always type safe and are automatically 
+# checked on use if the debug_assertions flag is enabled (the flag is automatically 
+# enabled if test build, debug build, or env: CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS=true).
+#
+# (Also, AlwaysSafeManuallyDrop is always checked for safety when it is used, regardless of the flags.)
 always_check_in_case_debug_assertions = []
+# ManuallyDrop and AutoManuallyDrop are always checked when used, 
+# regardless of external flags.
+#
+# (Also, AlwaysSafeManuallyDrop is always checked for safety when it is used, regardless of the flags.)
 always_safe_manuallydrop = []
 
+# Enable additional internal checks of the SafeManuallyDrop library when 
+# the debug_assertions flag is enabled (does not depend on the always_check_in_case_debug_assertions 
+# and always_safe_manuallydrop options). This flag type only applies to internal 
+# library function checks, it is independent of ManuallyDrop and its valid or invalid usage.
 allow_fullinternal_debug_assertions = []
 
+# Always create a modular table of library flags used in the build.
+# (crate::core::flags)
 always_build_flagstable = []
 
 support_hookfn_trig = []
+# Support for CounterManuallyDrop, in case of undefined behavior, 
+# CounterManuallyDrop will add +1 to the counter.
 support_count_trig = []
+# Support for AbortManuallyDrop, in case of undefined behavior 
+# of ManuallyDrop there will be a abort. (Note that this feature requires std.)
+support_abort_trig = []
+# Support for PanicManuallyDrop, in case of undefined behavior 
+# of ManuallyDrop there will be a panic.
 support_panic_trig = []
+# Ability to determine if an empty loop trigger has been executed.
 support_istrig_loop = []
 
+# Preserve unsafe fn flags even if functions are safe 
+# (may be required for additional compatibility with the standard API)
 always_compatible_stdapi = []
 
+# The behavior for the simple AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop type will always 
+# cause a panic in case of undefined behavior.
 always_deftrig_panic = []
+# The behavior for the simple AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop type will always 
+# cause a abort in case of undefined behavior.
+always_deftrig_abort = []
+# The behavior for the simple AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop type will always 
+# call the hook function in case of undefined behavior.
 always_deftrig_hookfn = []
+# The behavior for the simple AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop type will always call 
+# the +1 counter function in case of undefined behavior.
 always_deftrig_count = []
+# The behavior for the simple type AutoSafeManuallyDrop/AlwaysSafeManuallyDrop/ManuallyDrop will always call 
+# the eternal loop function in case of undefined behavior.
 always_deftrig_loop = []
 
 [dependencies]

examples/abort.rs

@@ -0,0 +1,41 @@
+
+
+// This example requires `support_abort_trig` support to work.
+
+#[cfg(feature = "support_abort_trig")]
+use SafeManuallyDrop::AlwaysSafeAbortManuallyDrop as ManuallyDrop;
+
+#[cfg(not(feature = "support_abort_trig"))]
+use SafeManuallyDrop::ManuallyDrop;
+
+use std::ops::Deref;
+
+#[allow(unreachable_code)]
+fn main() {
+	#[cfg(not(feature = "support_abort_trig"))] {
+		println!("To run the example, a build with feature: support_abort_trig is required,");
+		println!("exp: cargo run --example abort --all-features");
+		println!("end.");
+		
+		return;
+	}
+	
+	let mut data = ManuallyDrop::new(vec![1, 2, 3, 4]);
+	println!("data: {:?}", data.deref());
+	
+	#[allow(unused_unsafe)] // to avoid warning if the always_compatible_stdapi flag is not used (can be removed)
+	unsafe {
+		assert_eq!(data.is_next_trig(), false); // VALID
+		ManuallyDrop::drop(&mut data); // VALID
+		assert_eq!(data.is_next_trig(), true); // VALID
+		
+		// <<-- PANIC
+		/*
+			Undefined behavior when using ManuallyDrop(combo_replace_manudropstate), 
+			instead of the expected default state, the current state: DropModeTrig.
+			
+			Emergency stop.
+		*/
+		ManuallyDrop::drop(&mut data); // INVALID, COMBO DROP
+	}
+}

examples/easy_struct.rs

@@ -0,0 +1,79 @@
+
+// 1. In production code, it is recommended to use AutoSafe instead of AlwaysSafe, 
+// this will eliminate unnecessary checks in the release build, but leave 
+// them in the test build.
+//
+// 2. It is generally recommended to use Panic or Abort as a trigger for undefined behavior.
+//
+use SafeManuallyDrop::AlwaysSafePanicManuallyDrop as ManuallyDrop;
+
+#[derive(Default, Debug)]
+struct ControlDrop(usize);
+
+// Properly created and validated MyLogicData structure.
+#[derive(Default)]
+struct MyLogicData {
+	data: ManuallyDrop<ControlDrop>
+}
+
+impl MyLogicData {
+	/// Exceptional logic. As a result, the original value will always be returned.
+	pub fn ignore_mylogic_and_getdata(mut self) -> ControlDrop {
+		// Note that you can only `take` once, any further operation with 
+		// ManuallyDrop will cause a panic.
+		let data = unsafe {
+			ManuallyDrop::take(&mut self.data)
+		};
+		
+		// ManuallyDrop::forget analog forget(self).
+		ManuallyDrop::forget(self);
+		
+		/*
+			data logic
+		*/
+		
+		data
+	}
+}
+
+impl Drop for MyLogicData {
+	fn drop(&mut self) {
+		/*
+			def logic
+		*/
+		println!("MyLogicData, indata: {:?}", self.data);
+		
+		/*
+			Notification
+			1. `ManuallyDrop` always requires it to be freed when it is no longer needed.
+			2. Once `ManuallyDrop` is freed, you will not be able to read data from it
+			3. You cannot drop `ManuallyDrop` twice.
+			...
+			
+			You can remove the `unsafe` flags if you don't use the `always_compatible_stdapi` flag.
+		*/
+		unsafe {
+			ManuallyDrop::drop(&mut self.data);
+		}
+	}
+}
+
+fn main() {
+	{
+		// run my logic
+		let indata = MyLogicData::default();
+		drop(indata);
+		
+		// This case will just make the logic default by executing the code in drop.
+	}
+	{
+		// ignore_mylogic
+		let indata = MyLogicData::default();
+		let cd_data = indata.ignore_mylogic_and_getdata();
+	
+		println!("ignore_mylogic: {:?}", cd_data);
+		
+		// In this case, the standard reset logic is eliminated and another 
+		// specific principle is used, which is embedded in the function with data return.
+	}
+}

src/beh/auto.rs

@@ -1,4 +1,7 @@
 
+//! Depending on the build flag, a protected version of ManuallyDrop 
+//! or an unprotected version of ManuallyDrop.
+
 /// An internal macro that replaces many built-in assembly safety checks for 
 /// the default ManuallyDrop type.
 /// 

src/beh/safe.rs

@@ -1,4 +1,6 @@
 
+//! A safe version of the insecure manual control of freeing memory.
+
 use crate::UnsafeStdManuallyDrop;
 use crate::core::trig::TrigManuallyDrop;
 use core::marker::PhantomData;

src/beh/unsafe.rs

@@ -1,4 +1,6 @@
 
+//! Insecure standard implementation of manual memory management.
+
 use core::marker::PhantomData;
 use crate::UnsafeStdManuallyDrop;
 use crate::core::trig::TrigManuallyDrop;

src/core/flags.rs

@@ -1,4 +1,6 @@
 
+//! Flags used when building this library
+
 /// Whether a table of build flags to use was created
 /// when the library was compiled.
 pub const IS_BUILD_FLAGSTABLE: bool = true;
@@ -29,6 +31,17 @@ pub const IS_SUPPORT_HOOKFN_TRIG: bool = {
 	}
 };
 
+/// Whether the library build flag was used to support abort_trig.
+pub const IS_SUPPORT_ABORT_TRIG: bool = {
+	#[cfg(feature = "support_abort_trig")] {
+		true
+	}
+	
+	#[cfg(not(feature = "support_abort_trig"))] {
+		false
+	}
+};
+
 /// Whether the library build flag was used to support count_trig.
 pub const IS_SUPPORT_COUNT_TRIG: bool = {
 	#[cfg(feature = "support_count_trig")] {

src/core/state.rs

@@ -1,4 +1,6 @@
 
+//! AtomicStates for ManuallyDrop
+
 #[cfg(all(test, feature = "support_panic_trig"))]
 use crate::core::trig::panic::PanicTrigManuallyDrop;
 use core::fmt::Display;

src/core/trig/abort.rs

@@ -0,0 +1,30 @@
+
+use core::fmt::Arguments;
+use crate::core::trig::TrigManuallyDrop;
+
+/// A protected version of ManuallyDrop with a function to 
+/// execute a abort in case of undefined behavior of the ManuallyDrop logic.
+pub type AlwaysSafeAbortManuallyDrop<T> = crate::beh::safe::SafeManuallyDrop<T, AbortTrigManuallyDrop>;
+
+/// A secure or non-secure version of ManuallyDrop with a function to trigger 
+/// a abort in case of undefined behavior of the ManuallyDrop logic.
+pub type AutoSafeAbortManuallyDrop<T> = crate::beh::auto::AutoSafeManuallyDrop<T, AbortTrigManuallyDrop>;
+
+/// In case of undefined behavior of manual memory management, 
+/// perform a normal abort.
+pub enum AbortTrigManuallyDrop {}
+
+impl TrigManuallyDrop for AbortTrigManuallyDrop {
+	#[inline(always)]
+	fn trig_next_invalid_beh<'a>(a: Arguments<'a>) -> trig_manuallydrop_returntype!() {
+		use std::io::Write;
+		
+		{
+			let mut lock = std::io::stderr().lock();
+			let _e = write!(lock, "{}\n", a);
+			let _e = lock.flush();
+		}
+		
+		std::process::abort();
+	}
+}