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
use std::fmt;
use std::sync::atomic::{AtomicU16, AtomicU64, Ordering};
use std::sync::Arc;
pub trait Sequencer: fmt::Debug {
fn next_sequence_number(&self) -> u16;
fn roll_over_count(&self) -> u64;
fn clone_to(&self) -> Box<dyn Sequencer + Send + Sync>;
}
impl Clone for Box<dyn Sequencer + Send + Sync> {
fn clone(&self) -> Box<dyn Sequencer + Send + Sync> {
self.clone_to()
}
}
pub fn new_random_sequencer() -> impl Sequencer {
SequencerImpl {
sequence_number: Arc::new(AtomicU16::new(rand::random::<u16>())),
roll_over_count: Arc::new(AtomicU64::new(0)),
}
}
pub fn new_fixed_sequencer(s: u16) -> impl Sequencer {
SequencerImpl {
sequence_number: if s == 0 {
Arc::new(AtomicU16::new(0xFFFF))
} else {
Arc::new(AtomicU16::new(s - 1))
},
roll_over_count: Arc::new(AtomicU64::new(0)),
}
}
#[derive(Debug, Clone)]
struct SequencerImpl {
sequence_number: Arc<AtomicU16>,
roll_over_count: Arc<AtomicU64>,
}
impl Sequencer for SequencerImpl {
fn next_sequence_number(&self) -> u16 {
let sequence_number = self.sequence_number.load(Ordering::SeqCst);
if sequence_number == std::u16::MAX {
self.roll_over_count.fetch_add(1, Ordering::SeqCst);
self.sequence_number.store(0, Ordering::SeqCst);
0
} else {
self.sequence_number
.store(sequence_number + 1, Ordering::SeqCst);
sequence_number + 1
}
}
fn roll_over_count(&self) -> u64 {
self.roll_over_count.load(Ordering::SeqCst)
}
fn clone_to(&self) -> Box<dyn Sequencer + Send + Sync> {
Box::new(self.clone())
}
}