Added helper types for delayed or exactly once initialisation

Signed-off-by: SlyMarbo <[email protected]>

Author: SlyMarbo

kernel/src/structures/lazy.rs

@@ -0,0 +1,43 @@
+//! lazy implements a simple wrapper type, which can be left
+//! uninitialised until it is written to for the first time.
+
+use core::ops::{Deref, DerefMut};
+
+/// Lazy is a wrapper type that can be left uninitialized until
+/// the first time it is overwritten.
+///
+pub struct Lazy<T> {
+    value: Option<T>,
+}
+
+impl<T> Lazy<T> {
+    pub const fn new() -> Lazy<T> {
+        Lazy { value: None }
+    }
+
+    pub fn get(&self) -> &T {
+        self.value.as_ref().expect("Lazy not yet initialised")
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        self.value.as_mut().expect("Lazy not yet initialised")
+    }
+
+    pub fn set(&mut self, value: T) {
+        self.value = Some(value);
+    }
+}
+
+impl<T> Deref for Lazy<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.get()
+    }
+}
+
+impl<T> DerefMut for Lazy<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.get_mut()
+    }
+}

kernel/src/structures/mod.rs

@@ -1,3 +1,5 @@
 //! structures implements various data structures used elsewhere in the kernel.
 
 pub mod bitmap;
+pub mod lazy;
+pub mod once;

kernel/src/structures/once.rs

@@ -0,0 +1,38 @@
+//! once implements a simple wrapper type, which is initialised
+//! exactly once.
+
+use core::ops::{Deref, DerefMut};
+
+/// Once is a wrapper, which is initialised
+/// extacly once.
+///
+pub struct Once<T> {
+    inner: spin::Once<T>,
+}
+
+impl<T> Once<T> {
+    pub const fn new() -> Once<T> {
+        Once {
+            inner: spin::Once::new(),
+        }
+    }
+
+    pub fn init<F: FnOnce() -> T>(&self, f: F) {
+        assert!(!self.inner.is_completed());
+        self.inner.call_once(f);
+    }
+}
+
+impl<T> Deref for Once<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.inner.get().expect("Once not yet initialised")
+    }
+}
+
+impl<T> DerefMut for Once<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.inner.get_mut().expect("Once not yet initialised")
+    }
+}