Skip to content

Commit f42c893

Browse files
authored
feat(sdk): Improve ChunkIdentifierGenerator
feat(sdk): Improve `ChunkIdentifierGenerator`
2 parents 7df3140 + 199275f commit f42c893

File tree

1 file changed

+22
-35
lines changed

1 file changed

+22
-35
lines changed

crates/matrix-sdk/src/event_cache/linked_chunk.rs

Lines changed: 22 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ impl<Item, Gap, const CAP: usize> LinkedChunk<Item, Gap, CAP> {
107107
/// Push a gap at the end of the [`LinkedChunk`], i.e. after the last
108108
/// chunk.
109109
pub fn push_gap_back(&mut self, content: Gap) {
110-
let next_identifier = self.chunk_identifier_generator.generate_next().unwrap();
110+
let next_identifier = self.chunk_identifier_generator.next();
111111

112112
let last_chunk = self.latest_chunk_mut();
113113
last_chunk.insert_next(Chunk::new_gap_leaked(next_identifier, content));
@@ -210,10 +210,8 @@ impl<Item, Gap, const CAP: usize> LinkedChunk<Item, Gap, CAP> {
210210
// `chunk.previous.is_some()` in the `if` statement.
211211
.expect("Previous chunk must be present");
212212

213-
previous_chunk.insert_next(Chunk::new_gap_leaked(
214-
chunk_identifier_generator.generate_next().unwrap(),
215-
content,
216-
));
213+
previous_chunk
214+
.insert_next(Chunk::new_gap_leaked(chunk_identifier_generator.next(), content));
217215

218216
// We don't need to update `self.last` because we have inserted a new chunk
219217
// before `chunk`.
@@ -237,14 +235,9 @@ impl<Item, Gap, const CAP: usize> LinkedChunk<Item, Gap, CAP> {
237235

238236
chunk
239237
// Insert a new gap chunk.
240-
.insert_next(Chunk::new_gap_leaked(
241-
chunk_identifier_generator.generate_next().unwrap(),
242-
content,
243-
))
238+
.insert_next(Chunk::new_gap_leaked(chunk_identifier_generator.next(), content))
244239
// Insert a new items chunk.
245-
.insert_next(Chunk::new_items_leaked(
246-
chunk_identifier_generator.generate_next().unwrap(),
247-
))
240+
.insert_next(Chunk::new_items_leaked(chunk_identifier_generator.next()))
248241
// Finally, push the items that have been detached.
249242
.push_items(detached_items.into_iter(), &chunk_identifier_generator)
250243
}
@@ -295,9 +288,8 @@ impl<Item, Gap, const CAP: usize> LinkedChunk<Item, Gap, CAP> {
295288

296289
let last_inserted_chunk = chunk
297290
// Insert a new items chunk…
298-
.insert_next(Chunk::new_items_leaked(
299-
chunk_identifier_generator.generate_next().unwrap(),
300-
)) // … and insert the items.
291+
.insert_next(Chunk::new_items_leaked(chunk_identifier_generator.next()))
292+
// … and insert the items.
301293
.push_items(items, &chunk_identifier_generator);
302294

303295
(
@@ -590,18 +582,17 @@ impl ChunkIdentifierGenerator {
590582
/// Generate the next unique identifier.
591583
///
592584
/// Note that it can fail if there is no more unique identifier available.
593-
/// In this case, `Result::Err` contains the previous unique identifier.
594-
pub fn generate_next(&self) -> Result<ChunkIdentifier, ChunkIdentifier> {
585+
/// In this case, this method will panic.
586+
pub fn next(&self) -> ChunkIdentifier {
595587
let previous = self.next.fetch_add(1, Ordering::Relaxed);
596-
let current = self.next.load(Ordering::Relaxed);
597588

598589
// Check for overflows.
599590
// unlikely — TODO: call `std::intrinsics::unlikely` once it's stable.
600-
if current < previous {
601-
return Err(ChunkIdentifier(previous));
591+
if previous == u64::MAX {
592+
panic!("No more chunk identifiers available. Congrats, you did it. 2^64 identifiers have been consumed.")
602593
}
603594

604-
Ok(ChunkIdentifier(current))
595+
ChunkIdentifier(previous + 1)
605596
}
606597
}
607598

@@ -836,9 +827,7 @@ impl<Item, Gap, const CAPACITY: usize> Chunk<Item, Gap, CAPACITY> {
836827
ChunkContent::Gap(..) => {
837828
self
838829
// Insert a new items chunk.
839-
.insert_next(Self::new_items_leaked(
840-
chunk_identifier_generator.generate_next().unwrap(),
841-
))
830+
.insert_next(Self::new_items_leaked(chunk_identifier_generator.next()))
842831
// Now push the new items on the next chunk, and return the result of
843832
// `push_items`.
844833
.push_items(new_items, chunk_identifier_generator)
@@ -862,9 +851,7 @@ impl<Item, Gap, const CAPACITY: usize> Chunk<Item, Gap, CAPACITY> {
862851

863852
self
864853
// Insert a new items chunk.
865-
.insert_next(Self::new_items_leaked(
866-
chunk_identifier_generator.generate_next().unwrap(),
867-
))
854+
.insert_next(Self::new_items_leaked(chunk_identifier_generator.next()))
868855
// Now push the rest of the new items on the next chunk, and return the
869856
// result of `push_items`.
870857
.push_items(new_items, chunk_identifier_generator)
@@ -1041,18 +1028,18 @@ mod tests {
10411028
fn test_chunk_identifier_generator() {
10421029
let generator = ChunkIdentifierGenerator::new_from_scratch();
10431030

1044-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(1)));
1045-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(2)));
1046-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(3)));
1047-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(4)));
1031+
assert_eq!(generator.next(), ChunkIdentifier(1));
1032+
assert_eq!(generator.next(), ChunkIdentifier(2));
1033+
assert_eq!(generator.next(), ChunkIdentifier(3));
1034+
assert_eq!(generator.next(), ChunkIdentifier(4));
10481035

10491036
let generator =
10501037
ChunkIdentifierGenerator::new_from_previous_chunk_identifier(ChunkIdentifier(42));
10511038

1052-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(43)));
1053-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(44)));
1054-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(45)));
1055-
assert_eq!(generator.generate_next(), Ok(ChunkIdentifier(46)));
1039+
assert_eq!(generator.next(), ChunkIdentifier(43));
1040+
assert_eq!(generator.next(), ChunkIdentifier(44));
1041+
assert_eq!(generator.next(), ChunkIdentifier(45));
1042+
assert_eq!(generator.next(), ChunkIdentifier(46));
10561043
}
10571044

10581045
#[test]

0 commit comments

Comments
 (0)