//! # 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)
	}
}