Merge pull request #11 from worm-blossom/rename_cursors

Rename all instances of Cursor to SliceProducer or SliceConsumer

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

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;

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;

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(

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,22 +48,22 @@ 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,
         );
 
         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.

fuzz/fuzz_targets/local_nb/cursors.rs → 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(_) => {

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);

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);

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(

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,22 +47,22 @@ 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,
     );
 
     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.

fuzz/fuzz_targets/sync/cursors.rs → 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(_) => {

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<!, CursorFullError>> {
+    fn pipes_from_slice_producer_to_slice_consumer(
+    ) -> Result<(), PipeError<!, SliceConsumerFullError>> {
         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<!, CursorFullError>>
-    {
+    fn bulk_pipes_from_slice_producer_to_slice_consumer(
+    ) -> Result<(), BulkPipeError<!, SliceConsumerFullError>> {
         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?;

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;