qbase 0.5.0

Core structure of the QUIC protocol, a part of dquic
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
133
134
135

use std::{
    hash::Hash,
    sync::atomic::{AtomicUsize, Ordering},
};

use derive_more::Into;

/// Opque, hashable, unique ID type.
#[derive(Debug, Clone, Copy, Into, PartialEq, Eq, Hash)]
pub struct UniqueId(usize);

/// Thread safe, lock free unique ID generator.
#[derive(Debug)]
pub struct UniqueIdGenerator(AtomicUsize);

impl Default for UniqueIdGenerator {
    fn default() -> Self {
        Self::new()
    }
}

impl UniqueIdGenerator {
    /// Create a new `UniqueIdGenerator`
    ///
    /// # Example
    ///
    /// ```
    /// use qbase::util::UniqueIdGenerator;
    ///
    /// let generator = UniqueIdGenerator::new();
    /// let id1 = generator.generate();
    /// let id2 = generator.generate();
    /// assert_ne!(id1, id2);
    /// ```
    pub const fn new() -> Self {
        UniqueIdGenerator(AtomicUsize::new(1))
    }

    /// Generated a new `UniqueId` starting from a specific value
    ///
    /// # Example
    ///
    /// ```
    /// use qbase::util::UniqueIdGenerator;
    ///
    /// let generator = UniqueIdGenerator::new();
    /// let id1 = generator.generate();
    /// let id2 = generator.generate();
    /// assert_ne!(id1, id2);
    /// ```
    pub fn generate(&self) -> UniqueId {
        let id = self.0.fetch_add(1, Ordering::Relaxed);
        assert_ne!(id, 0, "UniqueId overflow");
        UniqueId(id)
    }
}

#[cfg(test)]
mod tests {
    use std::{collections::HashSet, sync::Arc, thread};

    use super::*;

    #[test]
    fn test_unique_id_basic() {
        let generator = UniqueIdGenerator::new();
        let id1 = generator.generate();
        let id2 = generator.generate();

        assert_ne!(id1, id2);
        assert_eq!(id1.0, 1);
        assert_eq!(id2.0, 2);
    }

    #[test]
    fn test_unique_id_hash() {
        let generator = UniqueIdGenerator::new();
        let id1 = generator.generate();
        let id2 = generator.generate();

        let mut set = HashSet::new();
        set.insert(id1);
        set.insert(id2);

        assert_eq!(set.len(), 2);
    }

    #[test]
    fn test_unique_id_clone_copy() {
        let generator = UniqueIdGenerator::new();
        let id1 = generator.generate();
        let id2 = id1; // Copy

        assert_eq!(id1, id2);
    }

    #[test]
    fn test_thread_safety() {
        let generator = Arc::new(UniqueIdGenerator::new());
        let mut handles = vec![];

        // 启动多个线程同时生成ID
        for _ in 0..10 {
            let generator = Arc::clone(&generator);
            let handle = thread::spawn(move || {
                let mut ids = Vec::new();
                for _ in 0..100 {
                    ids.push(generator.generate());
                }
                ids
            });
            handles.push(handle);
        }

        // 收集所有生成的ID
        let mut all_ids = HashSet::new();
        for handle in handles {
            let ids = handle.join().unwrap();
            for id in ids {
                assert!(all_ids.insert(id), "Duplicate ID found: {id:?}");
            }
        }

        // 应该有1000个唯一的ID
        assert_eq!(all_ids.len(), 1000);
    }

    #[test]
    fn test_default_generator() {
        let gen1 = UniqueIdGenerator::new();
        let gen2 = UniqueIdGenerator::new();

        assert_eq!(gen1.generate(), gen2.generate())
    }
}