orderbook-rs 0.6.2

A high-performance, lock-free price level implementation for limit order books in Rust. This library provides the building blocks for creating efficient trading systems with support for multiple order types and concurrent access patterns.
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

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

    #[test]
    fn test_uuid_generator_creates_unique_ids() {
        let namespace = Uuid::new_v4();
        let generator = UuidGenerator::new(namespace);

        let id1 = generator.next();
        let id2 = generator.next();

        assert_ne!(id1, id2, "Sequential UUIDs should be different");
    }

    #[test]
    fn test_uuid_generator_is_deterministic() {
        // With the same namespace and sequence, should generate the same UUIDs
        let namespace = Uuid::parse_str("6ba7b810-9dad-11d1-80b4-00c04fd430c8").unwrap();

        let generator1 = UuidGenerator::new(namespace);
        let generator2 = UuidGenerator::new(namespace);

        assert_eq!(
            generator1.next(),
            generator2.next(),
            "First UUIDs should match with same namespace"
        );
        assert_eq!(
            generator1.next(),
            generator2.next(),
            "Second UUIDs should match with same namespace"
        );
    }

    #[test]
    fn test_different_namespaces_generate_different_uuids() {
        let namespace1 = Uuid::new_v4();
        let namespace2 = Uuid::new_v4();

        let generator1 = UuidGenerator::new(namespace1);
        let generator2 = UuidGenerator::new(namespace2);

        assert_ne!(
            generator1.next(),
            generator2.next(),
            "UUIDs from different namespaces should differ"
        );
    }

    #[test]
    fn test_uuid_generator_thread_safety() {
        let namespace = Uuid::new_v4();
        let generator = Arc::new(UuidGenerator::new(namespace));

        let num_threads = 4;
        let ids_per_thread = 25;
        let total_ids = num_threads * ids_per_thread;

        let barrier = Arc::new(Barrier::new(num_threads));
        let all_ids = Arc::new(std::sync::Mutex::new(Vec::with_capacity(total_ids)));

        let mut handles = vec![];

        for _ in 0..num_threads {
            let thread_generator = Arc::clone(&generator);
            let thread_barrier = Arc::clone(&barrier);
            let thread_ids = Arc::clone(&all_ids);

            let handle = thread::spawn(move || {
                // Wait for all threads to be ready
                thread_barrier.wait();

                let mut local_ids = Vec::with_capacity(ids_per_thread);
                for _ in 0..ids_per_thread {
                    local_ids.push(thread_generator.next());
                }

                // Add to shared collection
                let mut all = thread_ids.lock().unwrap();
                all.extend(local_ids);
            });

            handles.push(handle);
        }

        // Wait for all threads to complete
        for handle in handles {
            handle.join().unwrap();
        }

        // Check that all UUIDs are unique
        let all_ids = all_ids.lock().unwrap();
        let unique_ids: HashSet<_> = all_ids.iter().collect();

        assert_eq!(
            unique_ids.len(),
            total_ids,
            "All generated UUIDs should be unique"
        );
    }

    #[test]
    fn test_uuid_version_and_variant() {
        let namespace = Uuid::new_v4();
        let generator = UuidGenerator::new(namespace);

        let id = generator.next();

        // Check UUID version (should be v5, SHA1-based)
        assert_eq!(
            id.get_version(),
            Some(uuid::Version::Sha1),
            "Should be a v5 UUID"
        );

        // Variant should be RFC4122
        assert_eq!(
            id.get_variant(),
            uuid::Variant::RFC4122,
            "Should be RFC4122 variant"
        );
    }
}