Add a const_fn feature to make new usable in statics

Author: phil-opp

Cargo.toml

@@ -9,3 +9,6 @@ documentation = "https://docs.rs/volatile"
 repository = "https://github.com/phil-opp/volatile"
 
 [dependencies]
+
+[features]
+const_fn = []

src/lib.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature="const_fn", feature(const_fn))]
+
 //! Provides wrapper types `Volatile`, `ReadOnly`, `WriteOnly`, `ReadWrite`, which wrap any copy-able type and allows for
 //! volatile memory access to wrapped value. Volatile memory accesses are never optimized away by
 //! the compiler, and are useful in many low-level systems programming and concurrent contexts.
@@ -47,6 +49,23 @@ impl<T: Copy> Volatile<T> {
     /// # Panics
     ///
     /// This method never panics.
+    #[cfg(feature="const_fn")]
+    pub const fn new(value: T) -> Volatile<T> {
+        Volatile(value)
+    }
+
+    /// Construct a new volatile instance wrapping the given value.
+    ///
+    /// ```rust
+    /// use volatile::Volatile;
+    ///
+    /// let value = Volatile::new(0u32);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This method never panics.
+    #[cfg(not(feature="const_fn"))]
     pub fn new(value: T) -> Volatile<T> {
         Volatile(value)
     }
@@ -139,8 +158,25 @@ impl<T: Copy> ReadOnly<T> {
     /// # Panics
     ///
     /// This function never panics.
+    #[cfg(feature = "const_fn")]
+    pub const fn new(value: T) -> ReadOnly<T> {
+        ReadOnly(Volatile::new(value))
+    }
+
+    /// Construct a new read-only volatile wrapper wrapping the given value.
+    ///
+    /// ```rust
+    /// use volatile::ReadOnly;
+    ///
+    /// let value = ReadOnly::new(42u32);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function never panics.
+    #[cfg(not(feature = "const_fn"))]
     pub fn new(value: T) -> ReadOnly<T> {
-        ReadOnly(Volatile(value))
+        ReadOnly(Volatile::new(value))
     }
 
     /// Perform a volatile read of the contained value, returning a copy of the read value.
@@ -179,8 +215,25 @@ impl<T: Copy> WriteOnly<T> {
     /// # Panics
     ///
     /// This function never panics.
+    #[cfg(feature = "const_fn")]
+    pub const fn new(value: T) -> WriteOnly<T> {
+        WriteOnly(Volatile::new(value))
+    }
+
+    /// Constructs a new write only volatile wrapper around the given value.
+    ///
+    /// ```rust
+    /// use volatile::WriteOnly;
+    ///
+    /// let value = WriteOnly::new(0u32);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function never panics.
+    #[cfg(not(feature = "const_fn"))]
     pub fn new(value: T) -> WriteOnly<T> {
-        WriteOnly(Volatile(value))
+        WriteOnly(Volatile::new(value))
     }
 
     /// Performs a volatile write of value `value` into the contained value. Functionally identical