Merge pull request #63 from vorner/const-arc-swap-option

Const ArcSwapOption initialization

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.4.0
+
+* Allow const-initializing ArcSwapOption (`const_empty` method).
+
 # 1.3.2
 
 * More helpful description of the `AsRaw` trait (isn't implemented for owned

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "arc-swap"
-version = "1.3.2"
+version = "1.4.0"
 authors = ["Michal 'vorner' Vaner <[email protected]>"]
 description = "Atomically swappable Arc"
 documentation = "https://docs.rs/arc-swap"

src/lib.rs

@@ -148,6 +148,7 @@ use crate::access::{Access, Map};
 pub use crate::as_raw::AsRaw;
 pub use crate::cache::Cache;
 pub use crate::ref_cnt::RefCnt;
+use crate::strategy::hybrid::{DefaultConfig, HybridStrategy};
 use crate::strategy::sealed::Protected;
 use crate::strategy::{CaS, Strategy};
 pub use crate::strategy::{DefaultStrategy, IndependentStrategy};
@@ -737,6 +738,37 @@ impl<T, S: Strategy<Option<Arc<T>>>> ArcSwapAny<Option<Arc<T>>, S> {
     }
 }
 
+impl<T> ArcSwapOption<T> {
+    /// A const-fn equilavent of [empty].
+    ///
+    /// Just like [empty], this creates an `None`-holding `ArcSwapOption`. The [empty] is, however,
+    /// more general ‒ this is available only for the default strategy, while [empty] is for any
+    /// [Default]-constructible strategy (current or future one).
+    ///
+    /// [empty]: ArcSwapAny::empty
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use std::sync::Arc;
+    /// # use arc_swap::ArcSwapOption;
+    /// static GLOBAL_DATA: ArcSwapOption<usize> = ArcSwapOption::const_empty();
+    ///
+    /// assert!(GLOBAL_DATA.load().is_none());
+    /// GLOBAL_DATA.store(Some(Arc::new(42)));
+    /// assert_eq!(42, **GLOBAL_DATA.load().as_ref().unwrap());
+    /// ```
+    pub const fn const_empty() -> Self {
+        Self {
+            ptr: AtomicPtr::new(ptr::null_mut()),
+            _phantom_arc: PhantomData,
+            strategy: HybridStrategy {
+                _config: DefaultConfig,
+            },
+        }
+    }
+}
+
 /// An atomic storage that doesn't share the internal generation locks with others.
 ///
 /// This makes it bigger and it also might suffer contention (on the HW level) if used from many

src/strategy/hybrid.rs

@@ -171,7 +171,7 @@ impl Config for DefaultConfig {
 
 #[derive(Clone, Default)]
 pub struct HybridStrategy<Cfg> {
-    _config: Cfg,
+    pub(crate) _config: Cfg,
 }
 
 impl<T, Cfg> InnerStrategy<T> for HybridStrategy<Cfg>

src/strategy/mod.rs

@@ -41,7 +41,7 @@ use std::sync::atomic::AtomicPtr;
 
 use crate::ref_cnt::RefCnt;
 
-mod hybrid;
+pub(crate) mod hybrid;
 mod rw_lock;
 // Do not use from outside of the crate.
 #[cfg(feature = "internal-test-strategies")]