Add support for source byte-range tracking for ByteRecord

src/byte_record.rs

@@ -86,6 +86,8 @@ impl fmt::Debug for ByteRecord {
 struct ByteRecordInner {
     /// The position of this byte record.
     pos: Option<Position>,
+    /// The source span represented by this byte record.
+    span: Option<Span>,
     /// All fields in this record, stored contiguously.
     fields: Vec<u8>,
     /// The number of and location of each field in this record.
@@ -136,6 +138,7 @@ impl ByteRecord {
     pub fn with_capacity(buffer: usize, fields: usize) -> ByteRecord {
         ByteRecord(Box::new(ByteRecordInner {
             pos: None,
+            span: None,
             fields: vec![0; buffer],
             bounds: Bounds::with_capacity(fields),
         }))
@@ -370,6 +373,7 @@ impl ByteRecord {
         let mut trimmed =
             ByteRecord::with_capacity(self.as_slice().len(), self.len());
         trimmed.set_position(self.position().cloned());
+        trimmed.set_span(self.span().cloned());
         for field in &*self {
             trimmed.push_field(field.trim());
         }
@@ -460,6 +464,18 @@ impl ByteRecord {
         self.0.pos = pos;
     }
 
+    /// Return the source span of this record, if available.
+    #[inline]
+    pub fn span(&self) -> Option<&Span> {
+        self.0.span.as_ref()
+    }
+
+    /// Sets the source span of this record.
+    #[inline]
+    pub fn set_span(&mut self, span: Option<Span>) {
+        self.0.span = span;
+    }
+
     /// Return the start and end position of a field in this record.
     ///
     /// If no such field exists at the given index, then return `None`.
@@ -639,6 +655,40 @@ impl Position {
     }
 }
 
+/// A span in a CSV source bytes
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Span {
+    start: u64,
+    end: u64,
+}
+
+impl Span {
+    /// Create a new span
+    #[inline]
+    pub fn new(start: u64, end: u64) -> Self {
+        assert!(end >= start);
+        Span { start, end }
+    }
+
+    /// Retrieve the start of this span
+    #[inline]
+    pub fn start(&self) -> u64 {
+        self.start
+    }
+
+    /// Retrieve the end of this span
+    #[inline]
+    pub fn end(&self) -> u64 {
+        self.end
+    }
+
+    /// Retrieve the length of this span
+    #[inline]
+    pub fn len(&self) -> usize {
+        (self.end - self.start) as usize
+    }
+}
+
 /// The bounds of fields in a single record.
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct Bounds {

src/lib.rs

@@ -153,7 +153,7 @@ use std::result;
 
 use serde::{Deserialize, Deserializer};
 
-pub use crate::byte_record::{ByteRecord, ByteRecordIter, Position};
+pub use crate::byte_record::{ByteRecord, ByteRecordIter, Position, Span};
 pub use crate::deserializer::{DeserializeError, DeserializeErrorKind};
 pub use crate::error::{
     Error, ErrorKind, FromUtf8Error, IntoInnerError, Result, Utf8Error,

src/reader.rs

@@ -7,7 +7,7 @@ use std::result;
 use csv_core::{Reader as CoreReader, ReaderBuilder as CoreReaderBuilder};
 use serde::de::DeserializeOwned;
 
-use crate::byte_record::{ByteRecord, Position};
+use crate::byte_record::{ByteRecord, Position, Span};
 use crate::error::{Error, ErrorKind, Result, Utf8Error};
 use crate::string_record::StringRecord;
 use crate::{Terminator, Trim};
@@ -1667,6 +1667,7 @@ impl<R: io::Read> Reader<R> {
                 }
                 Record => {
                     record.set_len(endlen);
+                    record.set_span(Some(Span::new(record.position().unwrap().byte(), self.state.cur_pos.byte())));
                     self.state.add_record(record)?;
                     return Ok(true);
                 }

src/writer.rs

@@ -954,7 +954,10 @@ impl<W: io::Write> Writer<W> {
             // The maximum number of bytes for the terminator.
             + 2;
         if self.buf.writable().len() < upper_bound {
-            return self.write_record(record);
+            // Flush before writing a record, so we only flush on whole records
+            self.flush_buf()?;
+            // Fail if we cannot free enough buffer space
+            assert!(self.buf.writable().len() >= upper_bound, "Not enough buffer space");
         }
         let mut first = true;
         for field in record.iter() {
@@ -1082,6 +1085,11 @@ impl<W: io::Write> Writer<W> {
         }
     }
 
+    /// Return an immutable reference to the underlying writer.
+    pub fn inner(&self) -> &W {
+        self.wtr.as_ref().expect("Called inner() with a None self.wtr")
+    }
+
     /// Write a CSV delimiter.
     fn write_delimiter(&mut self) -> Result<()> {
         loop {