From e3e6871a14389568dbf847ea289b418223a89806 Mon Sep 17 00:00:00 2001 From: glyph Date: Tue, 11 Jun 2024 14:05:18 +0100 Subject: [PATCH] rename all instances of Cursor to SliceProducer or SliceConsumer --- fuzz/Cargo.toml | 8 +- fuzz/fuzz_targets/local_nb/into_vec.rs | 6 +- .../local_nb/into_vec_fallible.rs | 6 +- .../local_nb/scramble_consumer.rs | 4 +- .../local_nb/scramble_producer.rs | 10 +- .../local_nb/{cursors.rs => slices.rs} | 12 +-- fuzz/fuzz_targets/sync/into_vec.rs | 6 +- fuzz/fuzz_targets/sync/into_vec_fallible.rs | 6 +- fuzz/fuzz_targets/sync/scramble_consumer.rs | 4 +- fuzz/fuzz_targets/sync/scramble_producer.rs | 10 +- .../sync/{cursors.rs => slices.rs} | 12 +-- src/local_nb.rs | 29 +++--- src/local_nb/consumer.rs | 4 +- src/local_nb/consumer/invariant.rs | 39 ++++---- .../consumer/{cursor.rs => slice_consumer.rs} | 66 ++++++------- src/local_nb/producer.rs | 4 +- src/local_nb/producer/invariant.rs | 71 +++++++------- .../producer/{cursor.rs => slice_producer.rs} | 56 +++++------ src/sync.rs | 27 +++--- src/sync/consumer.rs | 4 +- src/sync/consumer/invariant.rs | 37 ++++---- .../consumer/{cursor.rs => slice_consumer.rs} | 92 +++++++++---------- src/sync/producer.rs | 4 +- src/sync/producer/invariant.rs | 68 +++++++------- .../producer/{cursor.rs => slice_producer.rs} | 68 +++++++------- 25 files changed, 332 insertions(+), 321 deletions(-) rename fuzz/fuzz_targets/local_nb/{cursors.rs => slices.rs} (81%) rename fuzz/fuzz_targets/sync/{cursors.rs => slices.rs} (80%) rename src/local_nb/consumer/{cursor.rs => slice_consumer.rs} (67%) rename src/local_nb/producer/{cursor.rs => slice_producer.rs} (67%) rename src/sync/consumer/{cursor.rs => slice_consumer.rs} (68%) rename src/sync/producer/{cursor.rs => slice_producer.rs} (69%) diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml index 8de13f0..e7f21d8 100644 --- a/fuzz/Cargo.toml +++ b/fuzz/Cargo.toml @@ -16,8 +16,8 @@ wrapper = "0.1.1" path = ".." [[bin]] -name = "cursors" -path = "fuzz_targets/sync/cursors.rs" +name = "slices" +path = "fuzz_targets/sync/slices.rs" test = false doc = false bench = false @@ -51,8 +51,8 @@ doc = false bench = false [[bin]] -name = "local_nb_cursors" -path = "fuzz_targets/local_nb/cursors.rs" +name = "local_nb_slices" +path = "fuzz_targets/local_nb/slices.rs" test = false doc = false bench = false diff --git a/fuzz/fuzz_targets/local_nb/into_vec.rs b/fuzz/fuzz_targets/local_nb/into_vec.rs index ce39d55..6c9a20f 100644 --- a/fuzz/fuzz_targets/local_nb/into_vec.rs +++ b/fuzz/fuzz_targets/local_nb/into_vec.rs @@ -5,11 +5,11 @@ use libfuzzer_sys::fuzz_target; use ufotofu::local_nb; use ufotofu::local_nb::consumer::IntoVec; -use ufotofu::local_nb::producer::Cursor as ProducerCursor; +use ufotofu::local_nb::producer::SliceProducer; fn fuzz_pipe(data: &[u8]) { smol::block_on(async { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVec::new(); let _ = local_nb::pipe(&mut o, &mut i).await; @@ -20,7 +20,7 @@ fn fuzz_pipe(data: &[u8]) { fn fuzz_bulk_pipe(data: &[u8]) { smol::block_on(async { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVec::new(); let _ = local_nb::bulk_pipe(&mut o, &mut i).await; diff --git a/fuzz/fuzz_targets/local_nb/into_vec_fallible.rs b/fuzz/fuzz_targets/local_nb/into_vec_fallible.rs index 2a45599..dfce6b1 100644 --- a/fuzz/fuzz_targets/local_nb/into_vec_fallible.rs +++ b/fuzz/fuzz_targets/local_nb/into_vec_fallible.rs @@ -5,11 +5,11 @@ use libfuzzer_sys::fuzz_target; use ufotofu::local_nb; use ufotofu::local_nb::consumer::IntoVecFallible; -use ufotofu::local_nb::producer::Cursor as ProducerCursor; +use ufotofu::local_nb::producer::SliceProducer; fn fuzz_pipe(data: &[u8]) { smol::block_on(async { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVecFallible::new(); let _ = local_nb::pipe(&mut o, &mut i).await; @@ -20,7 +20,7 @@ fn fuzz_pipe(data: &[u8]) { fn fuzz_bulk_pipe(data: &[u8]) { smol::block_on(async { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVecFallible::new(); let _ = local_nb::bulk_pipe(&mut o, &mut i).await; diff --git a/fuzz/fuzz_targets/local_nb/scramble_consumer.rs b/fuzz/fuzz_targets/local_nb/scramble_consumer.rs index 2c6a316..de62745 100644 --- a/fuzz/fuzz_targets/local_nb/scramble_consumer.rs +++ b/fuzz/fuzz_targets/local_nb/scramble_consumer.rs @@ -9,7 +9,7 @@ use core::cmp::min; use wrapper::Wrapper; use ufotofu::local_nb::consumer::{ConsumeOperations, IntoVec, Scramble}; -use ufotofu::local_nb::producer::Cursor; +use ufotofu::local_nb::producer::SliceProducer; use ufotofu::local_nb::{self, LocalBufferedConsumer}; fn data_is_invalid(data: &TestData) -> bool { @@ -51,7 +51,7 @@ fuzz_target!(|data: TestData| { let into_vec = IntoVec::new(); // Producer. - let mut o = Cursor::new(&producer_buffer[..]); + let mut o = SliceProducer::new(&producer_buffer[..]); // Scrambler wrapping a scrambler with an inner `into_vec` consumer. let mut i = Scramble::new( diff --git a/fuzz/fuzz_targets/local_nb/scramble_producer.rs b/fuzz/fuzz_targets/local_nb/scramble_producer.rs index 6b6e129..1092993 100644 --- a/fuzz/fuzz_targets/local_nb/scramble_producer.rs +++ b/fuzz/fuzz_targets/local_nb/scramble_producer.rs @@ -9,7 +9,7 @@ use core::cmp::min; use wrapper::Wrapper; use ufotofu::local_nb::consumer::IntoVec; -use ufotofu::local_nb::producer::{Cursor, ProduceOperations, Scramble}; +use ufotofu::local_nb::producer::{ProduceOperations, Scramble, SliceProducer}; use ufotofu::local_nb::{self, LocalBufferedConsumer}; fn data_is_invalid(data: &TestData) -> bool { @@ -48,14 +48,14 @@ fuzz_target!(|data: TestData| { } = data; // Producer. - let cursor = Cursor::new(&mut producer_buffer[..]); + let slice_producer = SliceProducer::new(&mut producer_buffer[..]); // Consumer. let mut i = IntoVec::new(); - // Scrambler wrapping a scrambler with an inner `cursor` producer. + // Scrambler wrapping a scrambler with an inner `slice_producer`. let mut o = Scramble::new( - Scramble::new(cursor, inner_operations, inner_capacity), + Scramble::new(slice_producer, inner_operations, inner_capacity), outer_operations, outer_capacity, ); @@ -63,7 +63,7 @@ fuzz_target!(|data: TestData| { let _ = local_nb::bulk_pipe(&mut o, &mut i).await; let _ = i.flush().await; - // Access the inner producer (`cursor`). + // Access the inner producer (`slice_producer`). let o = o.into_inner().into_inner(); // Compare the contents of the producer and consumer. diff --git a/fuzz/fuzz_targets/local_nb/cursors.rs b/fuzz/fuzz_targets/local_nb/slices.rs similarity index 81% rename from fuzz/fuzz_targets/local_nb/cursors.rs rename to fuzz/fuzz_targets/local_nb/slices.rs index ff386a8..4610ab1 100644 --- a/fuzz/fuzz_targets/local_nb/cursors.rs +++ b/fuzz/fuzz_targets/local_nb/slices.rs @@ -6,8 +6,8 @@ use libfuzzer_sys::fuzz_target; use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary}; use ufotofu::local_nb; -use ufotofu::local_nb::consumer::Cursor as ConsumerCursor; -use ufotofu::local_nb::producer::Cursor as ProducerCursor; +use ufotofu::local_nb::consumer::SliceConsumer; +use ufotofu::local_nb::producer::SliceProducer; #[derive(Debug, Clone, Arbitrary)] struct TestData { @@ -41,8 +41,8 @@ fn fuzz_pipe(mut data: TestData) { return; } - let mut o = ProducerCursor::new(&data.input_buf[data.input_start..data.input_end]); - let mut i = ConsumerCursor::new(&mut data.output_buf[data.output_start..data.output_end]); + let mut o = SliceProducer::new(&data.input_buf[data.input_start..data.input_end]); + let mut i = SliceConsumer::new(&mut data.output_buf[data.output_start..data.output_end]); match local_nb::pipe(&mut o, &mut i).await { Ok(_) => { @@ -68,8 +68,8 @@ fn fuzz_bulk_pipe(mut data: TestData) { return; } - let mut o = ProducerCursor::new(&data.input_buf[data.input_start..data.input_end]); - let mut i = ConsumerCursor::new(&mut data.output_buf[data.output_start..data.output_end]); + let mut o = SliceProducer::new(&data.input_buf[data.input_start..data.input_end]); + let mut i = SliceConsumer::new(&mut data.output_buf[data.output_start..data.output_end]); match local_nb::bulk_pipe(&mut o, &mut i).await { Ok(_) => { diff --git a/fuzz/fuzz_targets/sync/into_vec.rs b/fuzz/fuzz_targets/sync/into_vec.rs index 3fc1f6e..8c32d54 100644 --- a/fuzz/fuzz_targets/sync/into_vec.rs +++ b/fuzz/fuzz_targets/sync/into_vec.rs @@ -5,10 +5,10 @@ use libfuzzer_sys::fuzz_target; use ufotofu::sync; use ufotofu::sync::consumer::IntoVec; -use ufotofu::sync::producer::Cursor as ProducerCursor; +use ufotofu::sync::producer::SliceProducer; fn fuzz_pipe(data: &[u8]) { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVec::new(); let _ = sync::pipe(&mut o, &mut i); @@ -17,7 +17,7 @@ fn fuzz_pipe(data: &[u8]) { } fn fuzz_bulk_pipe(data: &[u8]) { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVec::new(); let _ = sync::bulk_pipe(&mut o, &mut i); diff --git a/fuzz/fuzz_targets/sync/into_vec_fallible.rs b/fuzz/fuzz_targets/sync/into_vec_fallible.rs index 4813c23..18ea553 100644 --- a/fuzz/fuzz_targets/sync/into_vec_fallible.rs +++ b/fuzz/fuzz_targets/sync/into_vec_fallible.rs @@ -5,10 +5,10 @@ use libfuzzer_sys::fuzz_target; use ufotofu::sync; use ufotofu::sync::consumer::IntoVecFallible; -use ufotofu::sync::producer::Cursor as ProducerCursor; +use ufotofu::sync::producer::SliceProducer; fn fuzz_pipe(data: &[u8]) { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVecFallible::new(); let _ = sync::pipe(&mut o, &mut i); @@ -17,7 +17,7 @@ fn fuzz_pipe(data: &[u8]) { } fn fuzz_bulk_pipe(data: &[u8]) { - let mut o = ProducerCursor::new(&data[..]); + let mut o = SliceProducer::new(&data[..]); let mut i = IntoVecFallible::new(); let _ = sync::bulk_pipe(&mut o, &mut i); diff --git a/fuzz/fuzz_targets/sync/scramble_consumer.rs b/fuzz/fuzz_targets/sync/scramble_consumer.rs index edfa066..eb6b9bd 100644 --- a/fuzz/fuzz_targets/sync/scramble_consumer.rs +++ b/fuzz/fuzz_targets/sync/scramble_consumer.rs @@ -9,7 +9,7 @@ use core::cmp::min; use wrapper::Wrapper; use ufotofu::sync::consumer::{ConsumeOperations, IntoVec, Scramble}; -use ufotofu::sync::producer::Cursor; +use ufotofu::sync::producer::SliceProducer; use ufotofu::sync::{self, BufferedConsumer}; fn data_is_invalid(data: &TestData) -> bool { @@ -50,7 +50,7 @@ fuzz_target!(|data: TestData| { let into_vec = IntoVec::new(); // Producer. - let mut o = Cursor::new(&producer_buffer[..]); + let mut o = SliceProducer::new(&producer_buffer[..]); // Scrambler wrapping a scrambler with an inner `into_vec` consumer. let mut i = Scramble::new( diff --git a/fuzz/fuzz_targets/sync/scramble_producer.rs b/fuzz/fuzz_targets/sync/scramble_producer.rs index 7b9d994..a6949dc 100644 --- a/fuzz/fuzz_targets/sync/scramble_producer.rs +++ b/fuzz/fuzz_targets/sync/scramble_producer.rs @@ -9,7 +9,7 @@ use core::cmp::min; use wrapper::Wrapper; use ufotofu::sync::consumer::IntoVec; -use ufotofu::sync::producer::{Cursor, ProduceOperations, Scramble}; +use ufotofu::sync::producer::{ProduceOperations, Scramble, SliceProducer}; use ufotofu::sync::{self, BufferedConsumer}; fn data_is_invalid(data: &TestData) -> bool { @@ -47,14 +47,14 @@ fuzz_target!(|data: TestData| { } = data; // Producer. - let cursor = Cursor::new(&mut producer_buffer[..]); + let slice_producer = SliceProducer::new(&mut producer_buffer[..]); // Consumer. let mut i = IntoVec::new(); - // Scrambler wrapping a scrambler with an inner `cursor` producer. + // Scrambler wrapping a scrambler with an inner `slice_producer`. let mut o = Scramble::new( - Scramble::new(cursor, inner_operations, inner_capacity), + Scramble::new(slice_producer, inner_operations, inner_capacity), outer_operations, outer_capacity, ); @@ -62,7 +62,7 @@ fuzz_target!(|data: TestData| { let _ = sync::bulk_pipe(&mut o, &mut i); let _ = i.flush(); - // Access the inner producer (`cursor`). + // Access the inner producer (`slice_producer`). let o = o.into_inner().into_inner(); // Compare the contents of the producer and consumer. diff --git a/fuzz/fuzz_targets/sync/cursors.rs b/fuzz/fuzz_targets/sync/slices.rs similarity index 80% rename from fuzz/fuzz_targets/sync/cursors.rs rename to fuzz/fuzz_targets/sync/slices.rs index 96bc39b..95de472 100644 --- a/fuzz/fuzz_targets/sync/cursors.rs +++ b/fuzz/fuzz_targets/sync/slices.rs @@ -6,8 +6,8 @@ use libfuzzer_sys::fuzz_target; use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary}; use ufotofu::sync; -use ufotofu::sync::consumer::Cursor as ConsumerCursor; -use ufotofu::sync::producer::Cursor as ProducerCursor; +use ufotofu::sync::consumer::SliceConsumer; +use ufotofu::sync::producer::SliceProducer; #[derive(Debug, Clone, Arbitrary)] struct TestData { @@ -40,8 +40,8 @@ fn fuzz_pipe(mut data: TestData) { return; } - let mut o = ProducerCursor::new(&data.input_buf[data.input_start..data.input_end]); - let mut i = ConsumerCursor::new(&mut data.output_buf[data.output_start..data.output_end]); + let mut o = SliceProducer::new(&data.input_buf[data.input_start..data.input_end]); + let mut i = SliceConsumer::new(&mut data.output_buf[data.output_start..data.output_end]); match sync::pipe(&mut o, &mut i) { Ok(_) => { @@ -65,8 +65,8 @@ fn fuzz_bulk_pipe(mut data: TestData) { return; } - let mut o = ProducerCursor::new(&data.input_buf[data.input_start..data.input_end]); - let mut i = ConsumerCursor::new(&mut data.output_buf[data.output_start..data.output_end]); + let mut o = SliceProducer::new(&data.input_buf[data.input_start..data.input_end]); + let mut i = SliceConsumer::new(&mut data.output_buf[data.output_start..data.output_end]); match sync::bulk_pipe(&mut o, &mut i) { Ok(_) => { diff --git a/src/local_nb.rs b/src/local_nb.rs index 50bd936..3dc1cb1 100644 --- a/src/local_nb.rs +++ b/src/local_nb.rs @@ -354,17 +354,18 @@ where mod tests { use super::*; - use crate::local_nb::consumer::{Cursor as ConsumerCursor, IntoVec}; - use crate::local_nb::producer::Cursor as ProducerCursor; - use crate::sync::consumer::CursorFullError; + use crate::local_nb::consumer::{IntoVec, SliceConsumer}; + use crate::local_nb::producer::SliceProducer; + use crate::sync::consumer::SliceConsumerFullError; #[test] - fn pipes_from_producer_to_consumer_cursor() -> Result<(), PipeError> { + fn pipes_from_slice_producer_to_slice_consumer( + ) -> Result<(), PipeError> { smol::block_on(async { let mut buf = [0; 3]; - let mut o = ProducerCursor::new(b"ufo"); - let mut i = ConsumerCursor::new(&mut buf); + let mut o = SliceProducer::new(b"ufo"); + let mut i = SliceConsumer::new(&mut buf); pipe(&mut o, &mut i).await?; @@ -377,9 +378,9 @@ mod tests { } #[test] - fn pipes_from_producer_to_consumer_into_vec() -> Result<(), PipeError> { + fn pipes_from_slice_producer_to_consumer_into_vec() -> Result<(), PipeError> { smol::block_on(async { - let mut o = ProducerCursor::new(b"tofu"); + let mut o = SliceProducer::new(b"tofu"); let mut i = IntoVec::new(); pipe(&mut o, &mut i).await?; @@ -391,13 +392,13 @@ mod tests { } #[test] - fn bulk_pipes_from_producer_to_consumer_cursor() -> Result<(), BulkPipeError> - { + fn bulk_pipes_from_slice_producer_to_slice_consumer( + ) -> Result<(), BulkPipeError> { smol::block_on(async { let mut buf = [0; 3]; - let mut o = ProducerCursor::new(b"ufo"); - let mut i = ConsumerCursor::new(&mut buf); + let mut o = SliceProducer::new(b"ufo"); + let mut i = SliceConsumer::new(&mut buf); bulk_pipe(&mut o, &mut i).await?; @@ -410,9 +411,9 @@ mod tests { } #[test] - fn bulk_pipes_from_producer_to_consumer_into_vec() -> Result<(), BulkPipeError> { + fn bulk_pipes_from_slice_producer_to_consumer_into_vec() -> Result<(), BulkPipeError> { smol::block_on(async { - let mut o = ProducerCursor::new(b"tofu"); + let mut o = SliceProducer::new(b"tofu"); let mut i = IntoVec::new(); bulk_pipe(&mut o, &mut i).await?; diff --git a/src/local_nb/consumer.rs b/src/local_nb/consumer.rs index 13fe4c0..ab1ab92 100644 --- a/src/local_nb/consumer.rs +++ b/src/local_nb/consumer.rs @@ -1,11 +1,11 @@ -mod cursor; mod into_vec; mod into_vec_fallible; mod invariant; mod invariant_noop; mod scramble; +mod slice_consumer; -pub use cursor::Cursor; pub use into_vec::IntoVec; pub use into_vec_fallible::IntoVecFallible; pub use scramble::{ConsumeOperations, Scramble}; +pub use slice_consumer::SliceConsumer; diff --git a/src/local_nb/consumer/invariant.rs b/src/local_nb/consumer/invariant.rs index a59e357..bafd570 100644 --- a/src/local_nb/consumer/invariant.rs +++ b/src/local_nb/consumer/invariant.rs @@ -164,22 +164,22 @@ where mod tests { use super::*; - use crate::local_nb::consumer::{Cursor, IntoVec}; - use crate::sync::consumer::CursorFullError; + use crate::local_nb::consumer::{IntoVec, SliceConsumer}; + use crate::sync::consumer::SliceConsumerFullError; #[test] fn accepts_valid_did_consume_amount() { smol::block_on(async { - // Create a cursor that exposes four slots. + // Create a slice consumer that exposes four slots. let mut buf = [0; 4]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); // Copy data to three of the available slots and call `did_consume`. let data = b"ufo"; - let slots = cursor.consumer_slots().await.unwrap(); + let slots = slice_consumer.consumer_slots().await.unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..3], &data[0..3]); unsafe { - assert!(cursor.did_consume(3).await.is_ok()); + assert!(slice_consumer.did_consume(3).await.is_ok()); } }) } @@ -190,21 +190,21 @@ mod tests { )] fn panics_on_second_did_consume_with_amount_greater_than_available_slots() { smol::block_on(async { - // Create a cursor that exposes four slots. + // Create a slice consumer that exposes four slots. let mut buf = [0; 4]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); // Copy data to three of the available slots and call `did_consume`. let data = b"ufo"; - let slots = cursor.consumer_slots().await.unwrap(); + let slots = slice_consumer.consumer_slots().await.unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..3], &data[0..3]); unsafe { - assert!(cursor.did_consume(3).await.is_ok()); + assert!(slice_consumer.did_consume(3).await.is_ok()); } // Make a second call to `did_consume` which exceeds the number of available slots. unsafe { - let _ = cursor.did_consume(2).await; + let _ = slice_consumer.did_consume(2).await; } }) } @@ -212,27 +212,30 @@ mod tests { #[test] fn errors_on_consumer_slots_when_none_are_available() { smol::block_on(async { - // Create a cursor that exposes four slots. + // Create a slice consumer that exposes four slots. let mut buf = [0; 4]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); // Copy data to two of the available slots and call `did_consume`. let data = b"tofu"; - let slots = cursor.consumer_slots().await.unwrap(); + let slots = slice_consumer.consumer_slots().await.unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..2], &data[0..2]); unsafe { - assert!(cursor.did_consume(2).await.is_ok()); + assert!(slice_consumer.did_consume(2).await.is_ok()); } // Copy data to two of the available slots and call `did_consume`. - let slots = cursor.consumer_slots().await.unwrap(); + let slots = slice_consumer.consumer_slots().await.unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..2], &data[0..2]); unsafe { - assert!(cursor.did_consume(2).await.is_ok()); + assert!(slice_consumer.did_consume(2).await.is_ok()); } // Make a third call to `consumer_slots` after all available slots have been used. - assert_eq!(cursor.consumer_slots().await.unwrap_err(), CursorFullError); + assert_eq!( + slice_consumer.consumer_slots().await.unwrap_err(), + SliceConsumerFullError + ); }) } diff --git a/src/local_nb/consumer/cursor.rs b/src/local_nb/consumer/slice_consumer.rs similarity index 67% rename from src/local_nb/consumer/cursor.rs rename to src/local_nb/consumer/slice_consumer.rs index 20f28f0..b3c41a6 100644 --- a/src/local_nb/consumer/cursor.rs +++ b/src/local_nb/consumer/slice_consumer.rs @@ -5,50 +5,50 @@ use wrapper::Wrapper; use crate::local_nb::sync_to_local_nb::SyncToLocalNbConsumer; use crate::local_nb::{LocalBufferedConsumer, LocalBulkConsumer, LocalConsumer}; -use crate::sync::consumer::{Cursor as SyncCursor, CursorFullError}; +use crate::sync::consumer::{SliceConsumer as SyncSliceConsumer, SliceConsumerFullError}; /// Consumes data into a mutable slice. #[derive(Debug)] -pub struct Cursor<'a, T>(SyncToLocalNbConsumer>); +pub struct SliceConsumer<'a, T>(SyncToLocalNbConsumer>); /// Creates a consumer which places consumed data into the given slice. -impl<'a, T> Cursor<'a, T> { - pub fn new(slice: &mut [T]) -> Cursor<'_, T> { - let cursor = SyncCursor::new(slice); +impl<'a, T> SliceConsumer<'a, T> { + pub fn new(slice: &mut [T]) -> SliceConsumer<'_, T> { + let slice_consumer = SyncSliceConsumer::new(slice); - Cursor(SyncToLocalNbConsumer(cursor)) + SliceConsumer(SyncToLocalNbConsumer(slice_consumer)) } } -impl<'a, T> AsRef<[T]> for Cursor<'a, T> { +impl<'a, T> AsRef<[T]> for SliceConsumer<'a, T> { fn as_ref(&self) -> &[T] { let inner = self.0.as_ref(); inner.as_ref() } } -impl<'a, T> AsMut<[T]> for Cursor<'a, T> { +impl<'a, T> AsMut<[T]> for SliceConsumer<'a, T> { fn as_mut(&mut self) -> &mut [T] { let inner = self.0.as_mut(); inner.as_mut() } } -impl<'a, T> Wrapper<&'a [T]> for Cursor<'a, T> { +impl<'a, T> Wrapper<&'a [T]> for SliceConsumer<'a, T> { fn into_inner(self) -> &'a [T] { let inner = self.0.into_inner(); inner.into_inner() } } -impl<'a, T> LocalConsumer for Cursor<'a, T> { +impl<'a, T> LocalConsumer for SliceConsumer<'a, T> { /// The type of the items to be consumed. type Item = T; /// The value signifying the end of the consumed sequence. type Final = (); /// The value emitted when the consumer is full and a subsequent /// call is made to `consume()` or `consumer_slots()`. - type Error = CursorFullError; + type Error = SliceConsumerFullError; async fn consume(&mut self, item: Self::Item) -> Result<(), Self::Error> { self.0.consume(item).await @@ -59,13 +59,13 @@ impl<'a, T> LocalConsumer for Cursor<'a, T> { } } -impl<'a, T> LocalBufferedConsumer for Cursor<'a, T> { +impl<'a, T> LocalBufferedConsumer for SliceConsumer<'a, T> { async fn flush(&mut self) -> Result<(), Self::Error> { self.0.flush().await } } -impl<'a, T: Copy> LocalBulkConsumer for Cursor<'a, T> { +impl<'a, T: Copy> LocalBulkConsumer for SliceConsumer<'a, T> { async fn consumer_slots<'b>( &'b mut self, ) -> Result<&'b mut [MaybeUninit], Self::Error> @@ -102,9 +102,9 @@ mod tests { smol::block_on(async { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()).await; - let _ = cursor.consume(7).await; + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()).await; + let _ = slice_consumer.consume(7).await; }) } @@ -114,9 +114,9 @@ mod tests { smol::block_on(async { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()).await; - let _ = cursor.close(()).await; + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()).await; + let _ = slice_consumer.close(()).await; }) } @@ -126,9 +126,9 @@ mod tests { smol::block_on(async { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()).await; - let _ = cursor.flush().await; + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()).await; + let _ = slice_consumer.flush().await; }) } @@ -138,9 +138,9 @@ mod tests { smol::block_on(async { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()).await; - let _ = cursor.consumer_slots().await; + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()).await; + let _ = slice_consumer.consumer_slots().await; }) } @@ -150,11 +150,11 @@ mod tests { smol::block_on(async { let mut buf = [0; 8]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()).await; + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()).await; unsafe { - let _ = cursor.did_consume(7).await; + let _ = slice_consumer.did_consume(7).await; } }) } @@ -165,9 +165,9 @@ mod tests { smol::block_on(async { let mut buf = [0; 8]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()).await; - let _ = cursor.bulk_consume(b"ufo").await; + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()).await; + let _ = slice_consumer.bulk_consume(b"ufo").await; }) } @@ -179,10 +179,10 @@ mod tests { smol::block_on(async { let mut buf = [0; 8]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); unsafe { - let _ = cursor.did_consume(21).await; + let _ = slice_consumer.did_consume(21).await; } }) } diff --git a/src/local_nb/producer.rs b/src/local_nb/producer.rs index e01c4f0..856eeb1 100644 --- a/src/local_nb/producer.rs +++ b/src/local_nb/producer.rs @@ -1,7 +1,7 @@ -mod cursor; mod invariant; mod invariant_noop; mod scramble; +mod slice_producer; -pub use cursor::Cursor; pub use scramble::{ProduceOperations, Scramble}; +pub use slice_producer::SliceProducer; diff --git a/src/local_nb/producer/invariant.rs b/src/local_nb/producer/invariant.rs index 6c2e9cd..6e3a859 100644 --- a/src/local_nb/producer/invariant.rs +++ b/src/local_nb/producer/invariant.rs @@ -163,19 +163,19 @@ mod tests { use super::*; - use crate::local_nb::producer::Cursor; + use crate::local_nb::producer::SliceProducer; #[test] fn accepts_valid_did_produce_amount() { smol::block_on(async { - // Create a cursor with data that occupies four slots. - let mut cursor = Cursor::new(b"tofu"); + // Create a slice producer with data that occupies four slots. + let mut slice_producer = SliceProducer::new(b"tofu"); // Copy data from three of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots().await { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots().await { MaybeUninit::copy_from_slice(&mut buf[0..3], &slots[0..3]); - assert!(cursor.did_produce(3).await.is_ok()); + assert!(slice_producer.did_produce(3).await.is_ok()); } }) } @@ -186,44 +186,47 @@ mod tests { )] fn panics_on_second_did_produce_with_amount_greater_than_available_slots() { smol::block_on(async { - // Create a cursor with data that occupies four slots. - let mut cursor = Cursor::new(b"tofu"); + // Create a slice producer with data that occupies four slots. + let mut slice_producer = SliceProducer::new(b"tofu"); // Copy data from three of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots().await { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots().await { MaybeUninit::copy_from_slice(&mut buf[0..3], &slots[0..3]); - assert!(cursor.did_produce(3).await.is_ok()); + assert!(slice_producer.did_produce(3).await.is_ok()); } // Make a second call to `did_produce` which exceeds the number of available slots. - let _ = cursor.did_produce(2).await; + let _ = slice_producer.did_produce(2).await; }) } #[test] fn produces_final_value_on_producer_slots_after_complete_production() { smol::block_on(async { - // Create a cursor with data that occupies four slots. - let mut cursor = Cursor::new(b"tofu"); + // Create a slice producer with data that occupies four slots. + let mut slice_producer = SliceProducer::new(b"tofu"); // Copy data from two of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots().await { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots().await { MaybeUninit::copy_from_slice(&mut buf[0..2], &slots[0..2]); - assert!(cursor.did_produce(2).await.is_ok()); + assert!(slice_producer.did_produce(2).await.is_ok()); } // Copy data from two of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots().await { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots().await { MaybeUninit::copy_from_slice(&mut buf[0..2], &slots[0..2]); - assert!(cursor.did_produce(2).await.is_ok()); + assert!(slice_producer.did_produce(2).await.is_ok()); } // Make a third call to `producer_slots` after all items have been yielded, // ensuring that the final value is returned. - assert_eq!(cursor.producer_slots().await.unwrap(), Either::Right(())); + assert_eq!( + slice_producer.producer_slots().await.unwrap(), + Either::Right(()) + ); }) } @@ -242,15 +245,15 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_produce_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { // Call `produce()` until the final value is emitted. - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.produce().await; + let _ = slice_producer.produce().await; }) } @@ -258,14 +261,14 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_slurp_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.slurp().await; + let _ = slice_producer.slurp().await; }) } @@ -273,14 +276,14 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_producer_slots_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.producer_slots().await; + let _ = slice_producer.producer_slots().await; }) } @@ -288,14 +291,14 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_did_produce_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.did_produce(3).await; + let _ = slice_producer.did_produce(3).await; }) } @@ -303,15 +306,15 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_bulk_produce_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"tofu"); + let mut slice_producer = SliceProducer::new(b"tofu"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - let _ = cursor.bulk_produce(&mut buf).await; + let _ = slice_producer.bulk_produce(&mut buf).await; }) } @@ -321,9 +324,9 @@ mod tests { )] fn panics_on_did_produce_with_amount_greater_than_available_slots() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); - let _ = cursor.did_produce(21).await; + let _ = slice_producer.did_produce(21).await; }) } } diff --git a/src/local_nb/producer/cursor.rs b/src/local_nb/producer/slice_producer.rs similarity index 67% rename from src/local_nb/producer/cursor.rs rename to src/local_nb/producer/slice_producer.rs index a4b9503..0292563 100644 --- a/src/local_nb/producer/cursor.rs +++ b/src/local_nb/producer/slice_producer.rs @@ -5,36 +5,36 @@ use wrapper::Wrapper; use crate::local_nb::sync_to_local_nb::SyncToLocalNbProducer; use crate::local_nb::{LocalBufferedProducer, LocalBulkProducer, LocalProducer}; -use crate::sync::producer::Cursor as SyncCursor; +use crate::sync::producer::SliceProducer as SyncSliceProducer; #[derive(Debug)] /// Produces data from a slice. -pub struct Cursor<'a, T>(SyncToLocalNbProducer>); +pub struct SliceProducer<'a, T>(SyncToLocalNbProducer>); -impl<'a, T> Cursor<'a, T> { +impl<'a, T> SliceProducer<'a, T> { /// Create a producer which produces the data in the given slice. - pub fn new(slice: &'a [T]) -> Cursor<'a, T> { - let cursor = SyncCursor::new(slice); + pub fn new(slice: &'a [T]) -> SliceProducer<'a, T> { + let slice_producer = SyncSliceProducer::new(slice); - Cursor(SyncToLocalNbProducer(cursor)) + SliceProducer(SyncToLocalNbProducer(slice_producer)) } } -impl<'a, T> AsRef<[T]> for Cursor<'a, T> { +impl<'a, T> AsRef<[T]> for SliceProducer<'a, T> { fn as_ref(&self) -> &[T] { let inner = self.0.as_ref(); inner.as_ref() } } -impl<'a, T> Wrapper<&'a [T]> for Cursor<'a, T> { +impl<'a, T> Wrapper<&'a [T]> for SliceProducer<'a, T> { fn into_inner(self) -> &'a [T] { let inner = self.0.into_inner(); inner.into_inner() } } -impl<'a, T: Clone> LocalProducer for Cursor<'a, T> { +impl<'a, T: Clone> LocalProducer for SliceProducer<'a, T> { /// The type of the items to be produced. type Item = T; /// The final value emitted once the end of the slice has been reached. @@ -47,13 +47,13 @@ impl<'a, T: Clone> LocalProducer for Cursor<'a, T> { } } -impl<'a, T: Copy> LocalBufferedProducer for Cursor<'a, T> { +impl<'a, T: Copy> LocalBufferedProducer for SliceProducer<'a, T> { async fn slurp(&mut self) -> Result<(), Self::Error> { self.0.slurp().await } } -impl<'a, T: Copy> LocalBulkProducer for Cursor<'a, T> { +impl<'a, T: Copy> LocalBulkProducer for SliceProducer<'a, T> { async fn producer_slots<'b>( &'b mut self, ) -> Result, Self::Error> @@ -89,15 +89,15 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_produce_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { // Call `produce()` until the final value is emitted. - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.produce().await; + let _ = slice_producer.produce().await; }) } @@ -105,14 +105,14 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_slurp_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.slurp().await; + let _ = slice_producer.slurp().await; }) } @@ -120,14 +120,14 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_producer_slots_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.producer_slots().await; + let _ = slice_producer.producer_slots().await; }) } @@ -135,14 +135,14 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_did_produce_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } - let _ = cursor.did_produce(3).await; + let _ = slice_producer.did_produce(3).await; }) } @@ -150,15 +150,15 @@ mod tests { #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_bulk_produce_after_final() { smol::block_on(async { - let mut cursor = Cursor::new(b"tofu"); + let mut slice_producer = SliceProducer::new(b"tofu"); loop { - if let Ok(Either::Right(_)) = cursor.produce().await { + if let Ok(Either::Right(_)) = slice_producer.produce().await { break; } } let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - let _ = cursor.bulk_produce(&mut buf).await; + let _ = slice_producer.bulk_produce(&mut buf).await; }) } @@ -168,9 +168,9 @@ mod tests { )] fn panics_on_did_produce_with_amount_greater_than_available_slots() { smol::block_on(async { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); - let _ = cursor.did_produce(21).await; + let _ = slice_producer.did_produce(21).await; }) } } diff --git a/src/sync.rs b/src/sync.rs index 3c775f8..7000b9c 100644 --- a/src/sync.rs +++ b/src/sync.rs @@ -346,15 +346,16 @@ where mod tests { use super::*; - use crate::sync::consumer::{Cursor as ConsumerCursor, CursorFullError, IntoVec}; - use crate::sync::producer::Cursor as ProducerCursor; + use crate::sync::consumer::{IntoVec, SliceConsumer, SliceConsumerFullError}; + use crate::sync::producer::SliceProducer; #[test] - fn pipes_from_producer_to_consumer_cursor() -> Result<(), PipeError> { + fn pipes_from_slice_producer_to_slice_consumer( + ) -> Result<(), PipeError> { let mut buf = [0; 3]; - let mut o = ProducerCursor::new(b"ufo"); - let mut i = ConsumerCursor::new(&mut buf); + let mut o = SliceProducer::new(b"ufo"); + let mut i = SliceConsumer::new(&mut buf); pipe(&mut o, &mut i)?; @@ -366,8 +367,8 @@ mod tests { } #[test] - fn pipes_from_producer_to_consumer_into_vec() -> Result<(), PipeError> { - let mut o = ProducerCursor::new(b"tofu"); + fn pipes_from_slice_producer_to_consumer_into_vec() -> Result<(), PipeError> { + let mut o = SliceProducer::new(b"tofu"); let mut i = IntoVec::new(); pipe(&mut o, &mut i)?; @@ -378,12 +379,12 @@ mod tests { } #[test] - fn bulk_pipes_from_producer_to_consumer_cursor() -> Result<(), BulkPipeError> - { + fn bulk_pipes_from_slice_producer_to_slice_consumer( + ) -> Result<(), BulkPipeError> { let mut buf = [0; 3]; - let mut o = ProducerCursor::new(b"ufo"); - let mut i = ConsumerCursor::new(&mut buf); + let mut o = SliceProducer::new(b"ufo"); + let mut i = SliceConsumer::new(&mut buf); bulk_pipe(&mut o, &mut i)?; @@ -395,8 +396,8 @@ mod tests { } #[test] - fn bulk_pipes_from_producer_to_consumer_into_vec() -> Result<(), BulkPipeError> { - let mut o = ProducerCursor::new(b"tofu"); + fn bulk_pipes_from_slice_producer_to_consumer_into_vec() -> Result<(), BulkPipeError> { + let mut o = SliceProducer::new(b"tofu"); let mut i = IntoVec::new(); bulk_pipe(&mut o, &mut i)?; diff --git a/src/sync/consumer.rs b/src/sync/consumer.rs index 733787a..12064c0 100644 --- a/src/sync/consumer.rs +++ b/src/sync/consumer.rs @@ -1,14 +1,14 @@ -mod cursor; mod into_vec; mod into_vec_fallible; mod invariant; mod invariant_noop; mod scramble; +mod slice_consumer; -pub use cursor::{Cursor, CursorFullError}; pub use into_vec::IntoVec; pub use into_vec_fallible::{IntoVecError, IntoVecFallible}; pub use scramble::{ConsumeOperations, Scramble}; +pub use slice_consumer::{SliceConsumer, SliceConsumerFullError}; // During testing we use a wrapper which panics on invariant transgressions. // The no-op version of the wrapper is used for production code compilation. diff --git a/src/sync/consumer/invariant.rs b/src/sync/consumer/invariant.rs index 38dd876..fb85142 100644 --- a/src/sync/consumer/invariant.rs +++ b/src/sync/consumer/invariant.rs @@ -158,20 +158,20 @@ where mod tests { use super::*; - use crate::sync::consumer::{Cursor, CursorFullError, IntoVec}; + use crate::sync::consumer::{IntoVec, SliceConsumer, SliceConsumerFullError}; #[test] fn accepts_valid_did_consume_amount() { - // Create a cursor that exposes four slots. + // Create a slice consumer that exposes four slots. let mut buf = [0; 4]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); // Copy data to three of the available slots and call `did_consume`. let data = b"ufo"; - let slots = cursor.consumer_slots().unwrap(); + let slots = slice_consumer.consumer_slots().unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..3], &data[0..3]); unsafe { - assert!(cursor.did_consume(3).is_ok()); + assert!(slice_consumer.did_consume(3).is_ok()); } } @@ -180,47 +180,50 @@ mod tests { expected = "may not call `did_consume` with an amount exceeding the total number of exposed slots" )] fn panics_on_second_did_consume_with_amount_greater_than_available_slots() { - // Create a cursor that exposes four slots. + // Create a slice consumer that exposes four slots. let mut buf = [0; 4]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); // Copy data to three of the available slots and call `did_consume`. let data = b"ufo"; - let slots = cursor.consumer_slots().unwrap(); + let slots = slice_consumer.consumer_slots().unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..3], &data[0..3]); unsafe { - assert!(cursor.did_consume(3).is_ok()); + assert!(slice_consumer.did_consume(3).is_ok()); } // Make a second call to `did_consume` which exceeds the number of available slots. unsafe { - let _ = cursor.did_consume(2); + let _ = slice_consumer.did_consume(2); } } #[test] fn errors_on_consumer_slots_when_none_are_available() { - // Create a cursor that exposes four slots. + // Create a slice consumer that exposes four slots. let mut buf = [0; 4]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); // Copy data to two of the available slots and call `did_consume`. let data = b"tofu"; - let slots = cursor.consumer_slots().unwrap(); + let slots = slice_consumer.consumer_slots().unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..2], &data[0..2]); unsafe { - assert!(cursor.did_consume(2).is_ok()); + assert!(slice_consumer.did_consume(2).is_ok()); } // Copy data to two of the available slots and call `did_consume`. - let slots = cursor.consumer_slots().unwrap(); + let slots = slice_consumer.consumer_slots().unwrap(); MaybeUninit::copy_from_slice(&mut slots[0..2], &data[0..2]); unsafe { - assert!(cursor.did_consume(2).is_ok()); + assert!(slice_consumer.did_consume(2).is_ok()); } // Make a third call to `consumer_slots` after all available slots have been used. - assert_eq!(cursor.consumer_slots().unwrap_err(), CursorFullError); + assert_eq!( + slice_consumer.consumer_slots().unwrap_err(), + SliceConsumerFullError + ); } // Panic conditions: diff --git a/src/sync/consumer/cursor.rs b/src/sync/consumer/slice_consumer.rs similarity index 68% rename from src/sync/consumer/cursor.rs rename to src/sync/consumer/slice_consumer.rs index 0108499..135786d 100644 --- a/src/sync/consumer/cursor.rs +++ b/src/sync/consumer/slice_consumer.rs @@ -9,52 +9,52 @@ use crate::sync::consumer::Invariant; use crate::sync::{BufferedConsumer, BulkConsumer, Consumer}; #[derive(Clone, Copy, Debug, Error, Eq, PartialEq)] -#[error("cursor is full")] -pub struct CursorFullError; +#[error("slice consumer is full")] +pub struct SliceConsumerFullError; /// Consumes data into a mutable slice. #[derive(Debug)] -pub struct Cursor<'a, T>(Invariant>); +pub struct SliceConsumer<'a, T>(Invariant>); /// Creates a consumer which places consumed data into the given slice. -impl<'a, T> Cursor<'a, T> { - pub fn new(slice: &mut [T]) -> Cursor<'_, T> { - // Wrap the inner cursor in the invariant type. - let invariant = Invariant::new(CursorInner(slice, 0)); +impl<'a, T> SliceConsumer<'a, T> { + pub fn new(slice: &mut [T]) -> SliceConsumer<'_, T> { + // Wrap the inner slice consumer in the invariant type. + let invariant = Invariant::new(SliceConsumerInner(slice, 0)); - Cursor(invariant) + SliceConsumer(invariant) } } -impl<'a, T> AsRef<[T]> for Cursor<'a, T> { +impl<'a, T> AsRef<[T]> for SliceConsumer<'a, T> { fn as_ref(&self) -> &[T] { let inner = self.0.as_ref(); inner.as_ref() } } -impl<'a, T> AsMut<[T]> for Cursor<'a, T> { +impl<'a, T> AsMut<[T]> for SliceConsumer<'a, T> { fn as_mut(&mut self) -> &mut [T] { let inner = self.0.as_mut(); inner.as_mut() } } -impl<'a, T> Wrapper<&'a [T]> for Cursor<'a, T> { +impl<'a, T> Wrapper<&'a [T]> for SliceConsumer<'a, T> { fn into_inner(self) -> &'a [T] { let inner = self.0.into_inner(); inner.into_inner() } } -impl<'a, T> Consumer for Cursor<'a, T> { +impl<'a, T> Consumer for SliceConsumer<'a, T> { /// The type of the items to be consumed. type Item = T; /// The value signifying the end of the consumed sequence. type Final = (); /// The value emitted when the consumer is full and a subsequent /// call is made to `consume()` or `consumer_slots()`. - type Error = CursorFullError; + type Error = SliceConsumerFullError; fn consume(&mut self, item: T) -> Result<(), Self::Error> { self.0.consume(item) @@ -65,13 +65,13 @@ impl<'a, T> Consumer for Cursor<'a, T> { } } -impl<'a, T> BufferedConsumer for Cursor<'a, T> { +impl<'a, T> BufferedConsumer for SliceConsumer<'a, T> { fn flush(&mut self) -> Result<(), Self::Error> { self.0.flush() } } -impl<'a, T: Copy> BulkConsumer for Cursor<'a, T> { +impl<'a, T: Copy> BulkConsumer for SliceConsumer<'a, T> { fn consumer_slots(&mut self) -> Result<&mut [MaybeUninit], Self::Error> { self.0.consumer_slots() } @@ -83,39 +83,39 @@ impl<'a, T: Copy> BulkConsumer for Cursor<'a, T> { // A tuple of slice and counter (amount of items). #[derive(Debug)] -pub struct CursorInner<'a, T>(&'a mut [T], usize); +pub struct SliceConsumerInner<'a, T>(&'a mut [T], usize); -impl<'a, T> AsRef<[T]> for CursorInner<'a, T> { +impl<'a, T> AsRef<[T]> for SliceConsumerInner<'a, T> { fn as_ref(&self) -> &[T] { self.0 } } -impl<'a, T> AsMut<[T]> for CursorInner<'a, T> { +impl<'a, T> AsMut<[T]> for SliceConsumerInner<'a, T> { fn as_mut(&mut self) -> &mut [T] { self.0 } } -impl<'a, T> Wrapper<&'a mut [T]> for CursorInner<'a, T> { +impl<'a, T> Wrapper<&'a mut [T]> for SliceConsumerInner<'a, T> { fn into_inner(self) -> &'a mut [T] { self.0 } } -impl<'a, T> Consumer for CursorInner<'a, T> { +impl<'a, T> Consumer for SliceConsumerInner<'a, T> { /// The type of the items to be consumed. type Item = T; /// The value signifying the end of the consumed sequence. type Final = (); /// The value emitted when the consumer is full and a subsequent /// call is made to `consume()` or `consumer_slots()`. - type Error = CursorFullError; + type Error = SliceConsumerFullError; fn consume(&mut self, item: T) -> Result { - // The inner cursor is completely full. + // The inner slice consumer is completely full. if self.0.len() == self.1 { - Err(CursorFullError) + Err(SliceConsumerFullError) } else { // Copy the item to the slice at the given index. self.0[self.1] = item; @@ -131,16 +131,16 @@ impl<'a, T> Consumer for CursorInner<'a, T> { } } -impl<'a, T> BufferedConsumer for CursorInner<'a, T> { +impl<'a, T> BufferedConsumer for SliceConsumerInner<'a, T> { fn flush(&mut self) -> Result { Ok(()) } } -impl<'a, T: Copy> BulkConsumer for CursorInner<'a, T> { +impl<'a, T: Copy> BulkConsumer for SliceConsumerInner<'a, T> { fn consumer_slots(&mut self) -> Result<&mut [MaybeUninit], Self::Error> { if self.0.len() == self.1 { - Err(CursorFullError) + Err(SliceConsumerFullError) } else { Ok(maybe_uninit_slice_mut(&mut self.0[self.1..])) } @@ -174,9 +174,9 @@ mod tests { fn panics_on_consume_after_close() { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()); - let _ = cursor.consume(7); + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()); + let _ = slice_consumer.consume(7); } #[test] @@ -184,9 +184,9 @@ mod tests { fn panics_on_close_after_close() { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()); - let _ = cursor.close(()); + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()); + let _ = slice_consumer.close(()); } #[test] @@ -194,9 +194,9 @@ mod tests { fn panics_on_flush_after_close() { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()); - let _ = cursor.flush(); + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()); + let _ = slice_consumer.flush(); } #[test] @@ -204,9 +204,9 @@ mod tests { fn panics_on_consumer_slots_after_close() { let mut buf = [0; 1]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()); - let _ = cursor.consumer_slots(); + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()); + let _ = slice_consumer.consumer_slots(); } #[test] @@ -214,11 +214,11 @@ mod tests { fn panics_on_did_consume_after_close() { let mut buf = [0; 8]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()); + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()); unsafe { - let _ = cursor.did_consume(7); + let _ = slice_consumer.did_consume(7); } } @@ -227,9 +227,9 @@ mod tests { fn panics_on_bulk_consume_after_close() { let mut buf = [0; 8]; - let mut cursor = Cursor::new(&mut buf); - let _ = cursor.close(()); - let _ = cursor.bulk_consume(b"ufo"); + let mut slice_consumer = SliceConsumer::new(&mut buf); + let _ = slice_consumer.close(()); + let _ = slice_consumer.bulk_consume(b"ufo"); } #[test] @@ -239,10 +239,10 @@ mod tests { fn panics_on_did_consume_with_amount_greater_than_available_slots() { let mut buf = [0; 8]; - let mut cursor = Cursor::new(&mut buf); + let mut slice_consumer = SliceConsumer::new(&mut buf); unsafe { - let _ = cursor.did_consume(21); + let _ = slice_consumer.did_consume(21); } } } diff --git a/src/sync/producer.rs b/src/sync/producer.rs index 3433e73..b26cf31 100644 --- a/src/sync/producer.rs +++ b/src/sync/producer.rs @@ -1,10 +1,10 @@ -mod cursor; mod invariant; mod invariant_noop; mod scramble; +mod slice_producer; -pub use cursor::Cursor; pub use scramble::{ProduceOperations, Scramble}; +pub use slice_producer::SliceProducer; // During testing we use a wrapper which panics on invariant transgressions. // The no-op version of the wrapper is used for production code compilation. diff --git a/src/sync/producer/invariant.rs b/src/sync/producer/invariant.rs index e6571a1..62ca73d 100644 --- a/src/sync/producer/invariant.rs +++ b/src/sync/producer/invariant.rs @@ -156,18 +156,18 @@ mod tests { use super::*; - use crate::sync::producer::Cursor; + use crate::sync::producer::SliceProducer; #[test] fn accepts_valid_did_produce_amount() { - // Create a cursor with data that occupies four slots. - let mut cursor = Cursor::new(b"tofu"); + // Create a slice producer with data that occupies four slots. + let mut slice_producer = SliceProducer::new(b"tofu"); // Copy data from three of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots() { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots() { MaybeUninit::copy_from_slice(&mut buf[0..3], &slots[0..3]); - assert!(cursor.did_produce(3).is_ok()); + assert!(slice_producer.did_produce(3).is_ok()); } } @@ -176,42 +176,42 @@ mod tests { expected = "may not call `did_produce` with an amount exceeding the total number of exposed slots" )] fn panics_on_second_did_produce_with_amount_greater_than_available_slots() { - // Create a cursor with data that occupies four slots. - let mut cursor = Cursor::new(b"tofu"); + // Create a slice producer with data that occupies four slots. + let mut slice_producer = SliceProducer::new(b"tofu"); // Copy data from three of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots() { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots() { MaybeUninit::copy_from_slice(&mut buf[0..3], &slots[0..3]); - assert!(cursor.did_produce(3).is_ok()); + assert!(slice_producer.did_produce(3).is_ok()); } // Make a second call to `did_produce` which exceeds the number of available slots. - let _ = cursor.did_produce(2); + let _ = slice_producer.did_produce(2); } #[test] fn produces_final_value_on_producer_slots_after_complete_production() { - // Create a cursor with data that occupies four slots. - let mut cursor = Cursor::new(b"tofu"); + // Create a slice producer with data that occupies four slots. + let mut slice_producer = SliceProducer::new(b"tofu"); // Copy data from two of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots() { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots() { MaybeUninit::copy_from_slice(&mut buf[0..2], &slots[0..2]); - assert!(cursor.did_produce(2).is_ok()); + assert!(slice_producer.did_produce(2).is_ok()); } // Copy data from two of the occupied slots and call `did_produce`. let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - if let Ok(Either::Left(slots)) = cursor.producer_slots() { + if let Ok(Either::Left(slots)) = slice_producer.producer_slots() { MaybeUninit::copy_from_slice(&mut buf[0..2], &slots[0..2]); - assert!(cursor.did_produce(2).is_ok()); + assert!(slice_producer.did_produce(2).is_ok()); } // Make a third call to `producer_slots` after all items have been yielded, // ensuring that the final value is returned. - assert_eq!(cursor.producer_slots().unwrap(), Either::Right(())); + assert_eq!(slice_producer.producer_slots().unwrap(), Either::Right(())); } // Panic conditions: @@ -228,68 +228,68 @@ mod tests { #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_produce_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { // Call `produce()` until the final value is emitted. - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.produce(); + let _ = slice_producer.produce(); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_slurp_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.slurp(); + let _ = slice_producer.slurp(); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_producer_slots_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.producer_slots(); + let _ = slice_producer.producer_slots(); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_did_produce_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.did_produce(3); + let _ = slice_producer.did_produce(3); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_bulk_produce_after_final() { - let mut cursor = Cursor::new(b"tofu"); + let mut slice_producer = SliceProducer::new(b"tofu"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - let _ = cursor.bulk_produce(&mut buf); + let _ = slice_producer.bulk_produce(&mut buf); } #[test] @@ -297,8 +297,8 @@ mod tests { expected = "may not call `did_produce` with an amount exceeding the total number of exposed slots" )] fn panics_on_did_produce_with_amount_greater_than_available_slots() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); - let _ = cursor.did_produce(21); + let _ = slice_producer.did_produce(21); } } diff --git a/src/sync/producer/cursor.rs b/src/sync/producer/slice_producer.rs similarity index 69% rename from src/sync/producer/cursor.rs rename to src/sync/producer/slice_producer.rs index bd628fe..b7e1dcd 100644 --- a/src/sync/producer/cursor.rs +++ b/src/sync/producer/slice_producer.rs @@ -8,33 +8,33 @@ use crate::sync::{BufferedProducer, BulkProducer, Producer}; #[derive(Debug)] /// Produces data from a slice. -pub struct Cursor<'a, T>(Invariant>); +pub struct SliceProducer<'a, T>(Invariant>); -impl<'a, T> Cursor<'a, T> { +impl<'a, T> SliceProducer<'a, T> { /// Create a producer which produces the data in the given slice. - pub fn new(slice: &'a [T]) -> Cursor<'a, T> { - // Wrap the inner cursor in the invariant type. - let invariant = Invariant::new(CursorInner(slice, 0)); + pub fn new(slice: &'a [T]) -> SliceProducer<'a, T> { + // Wrap the inner slice producer in the invariant type. + let invariant = Invariant::new(SliceProducerInner(slice, 0)); - Cursor(invariant) + SliceProducer(invariant) } } -impl<'a, T> AsRef<[T]> for Cursor<'a, T> { +impl<'a, T> AsRef<[T]> for SliceProducer<'a, T> { fn as_ref(&self) -> &[T] { let inner = self.0.as_ref(); inner.as_ref() } } -impl<'a, T> Wrapper<&'a [T]> for Cursor<'a, T> { +impl<'a, T> Wrapper<&'a [T]> for SliceProducer<'a, T> { fn into_inner(self) -> &'a [T] { let inner = self.0.into_inner(); inner.into_inner() } } -impl<'a, T: Clone> Producer for Cursor<'a, T> { +impl<'a, T: Clone> Producer for SliceProducer<'a, T> { /// The type of the items to be produced. type Item = T; /// The final value emitted once the end of the slice has been reached. @@ -47,13 +47,13 @@ impl<'a, T: Clone> Producer for Cursor<'a, T> { } } -impl<'a, T: Copy> BufferedProducer for Cursor<'a, T> { +impl<'a, T: Copy> BufferedProducer for SliceProducer<'a, T> { fn slurp(&mut self) -> Result<(), Self::Error> { self.0.slurp() } } -impl<'a, T: Copy> BulkProducer for Cursor<'a, T> { +impl<'a, T: Copy> BulkProducer for SliceProducer<'a, T> { fn producer_slots(&mut self) -> Result, Self::Error> { self.0.producer_slots() } @@ -64,21 +64,21 @@ impl<'a, T: Copy> BulkProducer for Cursor<'a, T> { } #[derive(Debug)] -pub struct CursorInner<'a, T>(&'a [T], usize); +pub struct SliceProducerInner<'a, T>(&'a [T], usize); -impl<'a, T> AsRef<[T]> for CursorInner<'a, T> { +impl<'a, T> AsRef<[T]> for SliceProducerInner<'a, T> { fn as_ref(&self) -> &[T] { self.0 } } -impl<'a, T> Wrapper<&'a [T]> for CursorInner<'a, T> { +impl<'a, T> Wrapper<&'a [T]> for SliceProducerInner<'a, T> { fn into_inner(self) -> &'a [T] { self.0 } } -impl<'a, T: Clone> Producer for CursorInner<'a, T> { +impl<'a, T: Clone> Producer for SliceProducerInner<'a, T> { /// The type of the items to be produced. type Item = T; /// The final value emitted once the end of the slice has been reached. @@ -100,14 +100,14 @@ impl<'a, T: Clone> Producer for CursorInner<'a, T> { } } -impl<'a, T: Copy> BufferedProducer for CursorInner<'a, T> { +impl<'a, T: Copy> BufferedProducer for SliceProducerInner<'a, T> { fn slurp(&mut self) -> Result<(), Self::Error> { // There are no effects to perform so we simply return. Ok(()) } } -impl<'a, T: Copy> BulkProducer for CursorInner<'a, T> { +impl<'a, T: Copy> BulkProducer for SliceProducerInner<'a, T> { fn producer_slots(&mut self) -> Result, Self::Error> { let slice = &self.0[self.1..]; if slice.is_empty() { @@ -144,68 +144,68 @@ mod tests { #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_produce_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { // Call `produce()` until the final value is emitted. - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.produce(); + let _ = slice_producer.produce(); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_slurp_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.slurp(); + let _ = slice_producer.slurp(); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_producer_slots_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.producer_slots(); + let _ = slice_producer.producer_slots(); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_did_produce_after_final() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } - let _ = cursor.did_produce(3); + let _ = slice_producer.did_produce(3); } #[test] #[should_panic(expected = "may not call `Producer` methods after the sequence has ended")] fn panics_on_bulk_produce_after_final() { - let mut cursor = Cursor::new(b"tofu"); + let mut slice_producer = SliceProducer::new(b"tofu"); loop { - if let Ok(Either::Right(_)) = cursor.produce() { + if let Ok(Either::Right(_)) = slice_producer.produce() { break; } } let mut buf: [MaybeUninit; 4] = MaybeUninit::uninit_array(); - let _ = cursor.bulk_produce(&mut buf); + let _ = slice_producer.bulk_produce(&mut buf); } #[test] @@ -213,8 +213,8 @@ mod tests { expected = "may not call `did_produce` with an amount exceeding the total number of exposed slots" )] fn panics_on_did_produce_with_amount_greater_than_available_slots() { - let mut cursor = Cursor::new(b"ufo"); + let mut slice_producer = SliceProducer::new(b"ufo"); - let _ = cursor.did_produce(21); + let _ = slice_producer.did_produce(21); } }