menmos-std 0.2.6

Menmos library containing misc. reusable utilities
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use std::collections::LinkedList;

use parking_lot::Mutex;

#[derive(Debug)]
pub struct ConcurrentList<T> {
    data: Mutex<LinkedList<T>>,
}

impl<T> Default for ConcurrentList<T> {
    fn default() -> Self {
        Self {
            data: Mutex::new(LinkedList::new()),
        }
    }
}

impl<T> ConcurrentList<T> {
    pub fn pop_front(&self) -> Option<T> {
        let mut guard = self.data.lock();
        guard.pop_front()
    }

    pub fn pop_back(&self) -> Option<T> {
        let mut guard = self.data.lock();
        guard.pop_back()
    }

    pub fn push_front(&self, v: T) {
        let mut guard = self.data.lock();
        guard.push_front(v)
    }

    pub fn push_back(&self, v: T) {
        let mut guard = self.data.lock();
        guard.push_back(v)
    }
}

impl<T> ConcurrentList<T>
where
    T: Clone,
{
    pub fn get_all(&self) -> Vec<T> {
        let guard = self.data.lock();
        guard.iter().cloned().collect()
    }

    /// Fetches the head of the list and swaps it to the back of the list atomically.
    pub fn fetch_swap(&self) -> Option<T> {
        let mut guard = self.data.lock();
        match guard.pop_front() {
            Some(v) => {
                let value_copy = v.clone();
                guard.push_back(v);
                Some(value_copy)
            }
            None => None,
        }
    }
}