summavy 0.25.3

Search engine library
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::ops::Range;
use std::sync::atomic::Ordering;
use std::sync::Arc;

use crate::Opstamp;

#[cfg(not(target_arch = "arm"))]
mod atomic_impl {

    use std::sync::atomic::{AtomicU64, Ordering};

    use crate::Opstamp;

    #[derive(Default)]
    pub struct AtomicU64Wrapper(AtomicU64);

    impl AtomicU64Wrapper {
        pub fn new(first_opstamp: Opstamp) -> AtomicU64Wrapper {
            AtomicU64Wrapper(AtomicU64::new(first_opstamp))
        }

        pub fn fetch_add(&self, val: u64, order: Ordering) -> u64 {
            self.0.fetch_add(val, order)
        }

        pub fn revert(&self, val: u64, order: Ordering) -> u64 {
            self.0.store(val, order);
            val
        }
    }
}

#[cfg(target_arch = "arm")]
mod atomic_impl {

    /// Under other architecture, we rely on a mutex.
    use std::sync::atomic::Ordering;
    use std::sync::RwLock;

    use crate::Opstamp;

    #[derive(Default)]
    pub struct AtomicU64Wrapper(RwLock<u64>);

    impl AtomicU64Wrapper {
        pub fn new(first_opstamp: Opstamp) -> AtomicU64Wrapper {
            AtomicU64Wrapper(RwLock::new(first_opstamp))
        }

        pub fn fetch_add(&self, incr: u64, _order: Ordering) -> u64 {
            let mut lock = self.0.write().unwrap();
            let previous_val = *lock;
            *lock = previous_val + incr;
            previous_val
        }

        pub fn revert(&self, val: u64, _order: Ordering) -> u64 {
            let mut lock = self.0.write().unwrap();
            *lock = val;
            val
        }
    }
}

use self::atomic_impl::AtomicU64Wrapper;

/// Stamper provides Opstamps, which is just an auto-increment id to label
/// an operation.
///
/// Cloning does not "fork" the stamp generation. The stamper actually wraps an `Arc`.
#[derive(Clone, Default)]
pub struct Stamper(Arc<AtomicU64Wrapper>);

impl Stamper {
    pub fn new(first_opstamp: Opstamp) -> Stamper {
        Stamper(Arc::new(AtomicU64Wrapper::new(first_opstamp)))
    }

    pub fn stamp(&self) -> Opstamp {
        self.0.fetch_add(1u64, Ordering::SeqCst)
    }

    /// Given a desired count `n`, `stamps` returns an iterator that
    /// will supply `n` number of u64 stamps.
    pub fn stamps(&self, n: u64) -> Range<Opstamp> {
        let start = self.0.fetch_add(n, Ordering::SeqCst);
        Range {
            start,
            end: start + n,
        }
    }

    /// Reverts the stamper to a given `Opstamp` value and returns it
    pub fn revert(&self, to_opstamp: Opstamp) -> Opstamp {
        self.0.revert(to_opstamp, Ordering::SeqCst)
    }
}

#[cfg(test)]
mod test {

    use super::Stamper;

    #[test]
    fn test_stamper() {
        let stamper = Stamper::new(7u64);
        assert_eq!(stamper.stamp(), 7u64);
        assert_eq!(stamper.stamp(), 8u64);

        let stamper_clone = stamper.clone();
        assert_eq!(stamper.stamp(), 9u64);

        assert_eq!(stamper.stamp(), 10u64);
        assert_eq!(stamper_clone.stamp(), 11u64);
        assert_eq!(stamper.stamps(3u64), (12..15));
        assert_eq!(stamper.stamp(), 15u64);
    }

    #[test]
    fn test_stamper_revert() {
        let stamper = Stamper::new(7u64);
        assert_eq!(stamper.stamp(), 7u64);
        assert_eq!(stamper.stamp(), 8u64);

        let stamper_clone = stamper.clone();
        assert_eq!(stamper_clone.stamp(), 9u64);

        stamper.revert(6);
        assert_eq!(stamper.stamp(), 6);
        assert_eq!(stamper_clone.stamp(), 7);
    }
}