shared-framework 0.0.17

Reusable building blocks for HTTP services — Hyper routing, SeaORM data layer, validation, OpenAPI docs, jobs, queues, cache.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

//! Shared optional value holder.
//!
//! [`AtomHolder<T>`] is a cheaply clonable, thread-safe container for an
//! optional value of type `T`. Clones share the same slot: [`set`](AtomHolder::set)
//! from one clone is visible via [`get`](AtomHolder::get) on the others.
//!
//! ```ignore
//! let holder = AtomHolder::new();
//! holder.set(42);
//! assert_eq!(holder.get(), Some(42));
//! assert_eq!(holder.take(), Some(42));
//! assert_eq!(holder.get(), None);
//! ```
use std::sync::{Arc, Mutex};

/// Thread-safe holder for an optional value of type `T`. Clones share one slot.
#[derive(Clone)]
pub struct AtomHolder<T: Clone> {
    inner: Arc<Mutex<Option<T>>>,
}

impl<T: Clone> AtomHolder<T> {
    /// Creates an empty holder.
    pub fn new() -> Self { Self { inner: Arc::new(Mutex::new(None)) } }
    /// Replaces the stored value.
    pub fn set(&self, v: T) { *self.inner.lock().unwrap() = Some(v); }
    /// Returns a clone of the stored value, if any.
    pub fn get(&self) -> Option<T> { self.inner.lock().unwrap().clone() }
    /// Removes and returns the stored value, leaving the holder empty.
    pub fn take(&self) -> Option<T> { self.inner.lock().unwrap().take() }
}

impl<T: Clone> Default for AtomHolder<T> {
    fn default() -> Self { Self::new() }
}