Initial state

1 files changed, 62 insertions, 0 deletions

diff --git a/src/sync.rs b/src/sync.rs
new file mode 100644
index 0000000..cd626fa
--- /dev/null
+++ b/src/sync.rs
@@ -0,0 +1,62 @@
+//! # Synchronization module
+//!
+//! Provides synchronization objects for thread-safe memory sharing.
+use core::cell::UnsafeCell;
+
+/// # Synchronization interfaces
+///
+/// Provides Synchronization traits.
+pub mod interface {
+	/// # Mutex Trait
+	///
+	/// Basic Locking primitive to allow single-process access to data
+	pub trait Mutex {
+		/// # The data
+		///
+		/// Each mutex protects some internal data from modification across
+		/// processes when it is in use. This is important if the process
+		/// is preempted while the function is using it.
+		type Data;
+		/// # Locking mechanism
+		///
+		/// Locks the mutex to access the data in a closure.
+		/// The data can be read and modified in this closure without worry
+		/// of poisoning the data across processes.
+		fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut Self::Data) -> R) -> R;
+	}
+}
+
+/// # Basic Lock Structure
+pub struct NullLock<T> where T: ?Sized {
+	/// The internal data to safely share
+	data: UnsafeCell<T>,
+}
+
+/// # Allow thread sharing
+unsafe impl<T> Send for NullLock<T> where T: ?Sized + Send {}
+/// # Allow thread sharing
+unsafe impl<T> Sync for NullLock<T> where T: ?Sized + Send {}
+
+impl<T> NullLock<T> {
+	/// # Create a new instance of the lock
+	pub const fn new(data: T) -> Self {
+		Self {
+			data: UnsafeCell::new(data),
+		}
+	}
+}
+
+impl<T> interface::Mutex for NullLock<T> {
+	/// # Underlying data of the lock
+	type Data = T;
+
+	/// # Locking mechanism
+	///
+	/// Locks the Mutex, and passes a mutable reference
+	/// to the encapsulated data to a closure.
+	fn lock<'a, R>(&'a self, f: impl FnOnce(&'a mut T) -> R) -> R {
+		let data = unsafe { &mut *self.data.get() };
+
+		f(data)
+	}
+}