use_consistency/
lib.rs

1#![forbid(unsafe_code)]
2#![doc = include_str!("../README.md")]
3
4use core::fmt;
5
6/// Consistency level labels for read/write modeling.
7#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
8pub enum ConsistencyLevel {
9    One,
10    Two,
11    Three,
12    Quorum,
13    All,
14    LocalQuorum,
15    EventuallyConsistent,
16    StronglyConsistent,
17    #[default]
18    Unknown,
19}
20
21impl ConsistencyLevel {
22    /// Returns a stable lowercase label.
23    pub const fn as_str(self) -> &'static str {
24        match self {
25            Self::One => "one",
26            Self::Two => "two",
27            Self::Three => "three",
28            Self::Quorum => "quorum",
29            Self::All => "all",
30            Self::LocalQuorum => "local-quorum",
31            Self::EventuallyConsistent => "eventually-consistent",
32            Self::StronglyConsistent => "strongly-consistent",
33            Self::Unknown => "unknown",
34        }
35    }
36}
37
38impl fmt::Display for ConsistencyLevel {
39    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
40        formatter.write_str(self.as_str())
41    }
42}
43
44/// A read concern label.
45#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
46pub struct ReadConcern(ConsistencyLevel);
47
48impl ReadConcern {
49    /// Creates a read concern.
50    pub const fn new(level: ConsistencyLevel) -> Self {
51        Self(level)
52    }
53
54    /// Returns the consistency level.
55    pub const fn level(self) -> ConsistencyLevel {
56        self.0
57    }
58}
59
60impl fmt::Display for ReadConcern {
61    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
62        self.0.fmt(formatter)
63    }
64}
65
66/// A write concern label.
67#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
68pub struct WriteConcern(ConsistencyLevel);
69
70impl WriteConcern {
71    /// Creates a write concern.
72    pub const fn new(level: ConsistencyLevel) -> Self {
73        Self(level)
74    }
75
76    /// Returns the consistency level.
77    pub const fn level(self) -> ConsistencyLevel {
78        self.0
79    }
80}
81
82impl fmt::Display for WriteConcern {
83    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
84        self.0.fmt(formatter)
85    }
86}
87
88/// Durability labels for write persistence modeling.
89#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
90pub enum DurabilityLevel {
91    Memory,
92    Disk,
93    Replicated,
94    Majority,
95    #[default]
96    Unknown,
97}
98
99impl DurabilityLevel {
100    /// Returns a stable lowercase label.
101    pub const fn as_str(self) -> &'static str {
102        match self {
103            Self::Memory => "memory",
104            Self::Disk => "disk",
105            Self::Replicated => "replicated",
106            Self::Majority => "majority",
107            Self::Unknown => "unknown",
108        }
109    }
110}
111
112impl fmt::Display for DurabilityLevel {
113    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
114        formatter.write_str(self.as_str())
115    }
116}
117
118/// A replication factor count.
119#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
120pub struct ReplicationFactor(u16);
121
122impl ReplicationFactor {
123    /// Creates a replication factor.
124    pub const fn new(value: u16) -> Self {
125        Self(value)
126    }
127
128    /// Returns the replication factor value.
129    pub const fn value(self) -> u16 {
130        self.0
131    }
132}
133
134impl fmt::Display for ReplicationFactor {
135    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
136        write!(formatter, "{}", self.0)
137    }
138}
139
140/// A quorum count.
141#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
142pub struct Quorum(u16);
143
144impl Quorum {
145    /// Creates a quorum count.
146    pub const fn new(value: u16) -> Self {
147        Self(value)
148    }
149
150    /// Returns the quorum value.
151    pub const fn value(self) -> u16 {
152        self.0
153    }
154}
155
156impl fmt::Display for Quorum {
157    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
158        write!(formatter, "{}", self.0)
159    }
160}
161
162#[cfg(test)]
163mod tests {
164    use super::{
165        ConsistencyLevel, DurabilityLevel, Quorum, ReadConcern, ReplicationFactor, WriteConcern,
166    };
167
168    #[test]
169    fn formats_consistency_levels() {
170        assert_eq!(ConsistencyLevel::One.to_string(), "one");
171        assert_eq!(ConsistencyLevel::Quorum.to_string(), "quorum");
172        assert_eq!(ConsistencyLevel::LocalQuorum.to_string(), "local-quorum");
173        assert_eq!(
174            ConsistencyLevel::EventuallyConsistent.to_string(),
175            "eventually-consistent"
176        );
177        assert_eq!(
178            ConsistencyLevel::StronglyConsistent.to_string(),
179            "strongly-consistent"
180        );
181        assert_eq!(ConsistencyLevel::Unknown.to_string(), "unknown");
182    }
183
184    #[test]
185    fn builds_concern_and_replication_labels() {
186        let read = ReadConcern::new(ConsistencyLevel::Quorum);
187        let write = WriteConcern::new(ConsistencyLevel::All);
188        let replication = ReplicationFactor::new(3);
189        let quorum = Quorum::new(2);
190
191        assert_eq!(read.to_string(), "quorum");
192        assert_eq!(write.level(), ConsistencyLevel::All);
193        assert_eq!(replication.value(), 3);
194        assert_eq!(quorum.to_string(), "2");
195        assert_eq!(DurabilityLevel::Replicated.to_string(), "replicated");
196    }
197}
use_consistency/lib.rs

use_consistency/
lib.rs
