Add ChunkReader for convenience (#44)

Author: kaidokert

avr_demo/examples/test_streamparser.rs

@@ -4,7 +4,7 @@
 
 use avr_demo as _;
 use avr_demo::stack_measurement::*;
-use picojson::{self, Event, ParseError, PullParser, Reader, StreamParser};
+use picojson::{self, ChunkReader, Event, ParseError, PullParser, StreamParser};
 
 #[allow(unused_imports)]
 use picojson::ArrayBitStack;
@@ -71,37 +71,6 @@ struct Doc<'b> {
     status: &'b str,
 }
 
-// Simple Reader implementation for testing that wraps a slice
-struct SliceReader<'a> {
-    data: &'a [u8],
-    position: usize,
-}
-
-impl<'a> SliceReader<'a> {
-    fn new(data: &'a [u8]) -> Self {
-        Self { data, position: 0 }
-    }
-}
-
-impl<'a> Reader for SliceReader<'a> {
-    type Error = ();
-
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        let remaining = self.data.len().saturating_sub(self.position);
-        if remaining == 0 {
-            return Ok(0);
-        }
-
-        let to_copy = remaining.min(buf.len());
-        if let Ok(copied) = copy_subslice(self.data, self.position, buf, 0, to_copy) {
-            self.position = self.position.wrapping_add(copied);
-            Ok(copied)
-        } else {
-            Err(())
-        }
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq)]
 enum KeyContext {
     None,
@@ -117,7 +86,7 @@ fn parse_json<'b>(json_data: &[u8], scratch: &'b mut [u8]) -> Result<Doc<'b>, Pa
 
     // Create a streaming buffer for StreamParser (balanced size for testing)
     let mut stream_buffer = [0u8; 12];
-    let reader = SliceReader::new(json_data);
+    let reader = ChunkReader::full_slice(json_data);
     let mut parser = StreamParser::<_, PicoConfig>::with_config(reader, &mut stream_buffer);
 
     let mut key_context = KeyContext::None;

picojson/examples/stream_parser_demo.rs

@@ -1,55 +1,9 @@
 // Example demonstrating StreamParser with a Reader over a fixed-size array
 
-use picojson::{Event, ParseError, PullParser, Reader, StreamParser};
-
-/// Simple Reader implementation that reads from a fixed-size byte array
-/// This simulates reading from a stream, network socket, or any other byte source
-struct ArrayReader<'a> {
-    data: &'a [u8],
-    position: usize,
-    chunk_size: usize, // Simulate streaming by reading in chunks
-}
-
-impl<'a> ArrayReader<'a> {
-    /// Create a new ArrayReader from a byte slice
-    /// chunk_size controls how many bytes are read at once (simulates network packets)
-    fn new(data: &'a [u8], chunk_size: usize) -> Self {
-        Self {
-            data,
-            position: 0,
-            chunk_size,
-        }
-    }
-}
-
-impl<'a> Reader for ArrayReader<'a> {
-    type Error = std::io::Error;
-
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        let remaining = self.data.len().saturating_sub(self.position);
-        if remaining == 0 {
-            return Ok(0); // EOF
-        }
-
-        // Read at most chunk_size bytes to simulate streaming behavior
-        let to_read = remaining.min(buf.len()).min(self.chunk_size);
-        let end_pos = self.position + to_read;
-
-        buf[..to_read].copy_from_slice(&self.data[self.position..end_pos]);
-        self.position = end_pos;
-
-        println!(
-            "  📖 Reader: read {} bytes (pos: {}/{})",
-            to_read,
-            self.position,
-            self.data.len()
-        );
-        Ok(to_read)
-    }
-}
+use picojson::{ChunkReader, Event, ParseError, PullParser, StreamParser};
 
 fn main() -> Result<(), ParseError> {
-    println!("🚀 StreamParser Demo with ArrayReader");
+    println!("🚀 StreamParser Demo with ChunkReader");
     println!("=====================================");
 
     // Test JSON with various data types including escape sequences
@@ -59,15 +13,15 @@ fn main() -> Result<(), ParseError> {
     println!("📏 Total size: {} bytes", json.len());
     println!();
 
-    // Create ArrayReader that reads in small chunks (simulates network streaming)
-    let reader = ArrayReader::new(json, 8); // Read 8 bytes at a time
+    // Create ChunkReader that reads in small chunks (simulates network streaming)
+    let reader = ChunkReader::new(json, 8); // Read 8 bytes at a time
 
     // Create StreamParser with a reasonably sized buffer
     let mut buffer = [0u8; 256];
     let buffer_size = buffer.len();
     let mut parser = StreamParser::new(reader, &mut buffer);
 
-    println!("🔄 Starting StreamParser with streaming ArrayReader:");
+    println!("🔄 Starting StreamParser with streaming ChunkReader:");
     println!("   Buffer size: {} bytes", buffer_size);
     println!("   Chunk size: 8 bytes (simulates small network packets)");
     println!();