From 95137ecb2a39496ef6a88cf726b2277cff8f40e6 Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Wed, 15 Dec 2021 13:20:11 +0100 Subject: [PATCH] WIP --- crates/editor/src/multi_buffer.rs | 132 +++++++++++++++++++++++++++--- 1 file changed, 120 insertions(+), 12 deletions(-) diff --git a/crates/editor/src/multi_buffer.rs b/crates/editor/src/multi_buffer.rs index d28beda8d7..f2d846c38a 100644 --- a/crates/editor/src/multi_buffer.rs +++ b/crates/editor/src/multi_buffer.rs @@ -11,8 +11,8 @@ use language::{ }; use std::{ cell::{Ref, RefCell}, - cmp, io, - iter::{self, FromIterator, Peekable}, + cmp, fmt, io, + iter::{self, FromIterator}, ops::{Range, Sub}, str, sync::Arc, @@ -56,11 +56,11 @@ struct Transaction { last_edit_at: Instant, } -pub trait ToOffset: 'static + std::fmt::Debug { +pub trait ToOffset: 'static + fmt::Debug { fn to_offset(&self, snapshot: &MultiBufferSnapshot) -> usize; } -pub trait ToPoint: 'static + std::fmt::Debug { +pub trait ToPoint: 'static + fmt::Debug { fn to_point(&self, snapshot: &MultiBufferSnapshot) -> Point; } @@ -121,7 +121,10 @@ pub struct MultiBufferChunks<'a> { } pub struct MultiBufferBytes<'a> { - chunks: Peekable>, + range: Range, + excerpts: Cursor<'a, Excerpt, usize>, + excerpt_chunks: Option>, + excerpt_chunk: &'a [u8], } impl MultiBuffer { @@ -920,9 +923,17 @@ impl MultiBufferSnapshot { } pub fn bytes_in_range<'a, T: ToOffset>(&'a self, range: Range) -> MultiBufferBytes<'a> { - MultiBufferBytes { - chunks: self.chunks(range, None).peekable(), - } + let range = range.start.to_offset(self)..range.end.to_offset(self); + let mut excerpts = self.excerpts.cursor::(); + excerpts.seek(&range.start, Bias::Right, &()); + let mut bytes = MultiBufferBytes { + range, + excerpts, + excerpt_chunks: None, + excerpt_chunk: &[], + }; + bytes.reset_excerpt_bytes(); + bytes } pub fn chunks<'a, T: ToOffset>( @@ -1518,6 +1529,19 @@ impl Excerpt { } } +impl fmt::Debug for Excerpt { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Excerpt") + .field("id", &self.id) + .field("buffer_id", &self.buffer_id) + .field("range", &self.range) + .field("text_summary", &self.text_summary) + .field("header_height", &self.header_height) + .field("has_trailing_newline", &self.has_trailing_newline) + .finish() + } +} + impl sum_tree::Item for Excerpt { type Summary = ExcerptSummary; @@ -1682,17 +1706,85 @@ impl<'a> Iterator for MultiBufferChunks<'a> { } } +impl<'a> MultiBufferBytes<'a> { + fn peek(&mut self) -> Option<&'a [u8]> { + if self.range.is_empty() { + return None; + } + + let excerpt = self.excerpts.item()?; + let header_end = self.excerpts.start() + excerpt.header_height as usize; + let mut footer_start = self.excerpts.start() + excerpt.text_summary.bytes; + if excerpt.has_trailing_newline { + footer_start -= 1; + } + + dbg!(self.range.start, header_end, footer_start); + if self.range.start < header_end { + let header_height = cmp::min(header_end - self.range.start, self.range.len()); + Some(&NEWLINES[..header_height]) + } else if self.range.start == footer_start { + Some(&NEWLINES[..1]) + } else { + Some(self.excerpt_chunk) + } + } + + fn consume(&mut self, len: usize) { + self.range.start += len; + if self.range.is_empty() { + return; + } + + if let Some(excerpt) = self.excerpts.item() { + let header_end = self.excerpts.start() + excerpt.header_height as usize; + + if self.range.start == self.excerpts.end(&()) { + self.excerpts.next(&()); + self.reset_excerpt_bytes(); + } else if self.range.start > header_end { + self.excerpt_chunks.as_mut().unwrap().next(); + } + } + } + + fn reset_excerpt_bytes(&mut self) { + self.excerpt_chunks = self.excerpts.item().map(|excerpt| { + let start_after_header = self.excerpts.start() + excerpt.header_height as usize; + let mut end_before_footer = self.excerpts.start() + excerpt.text_summary.bytes; + if excerpt.has_trailing_newline { + end_before_footer -= 1; + } + + let buffer_start = excerpt.range.start.to_offset(&excerpt.buffer); + let start = buffer_start + self.range.start.saturating_sub(start_after_header); + let end = buffer_start + + cmp::min(self.range.end, end_before_footer).saturating_sub(start_after_header); + excerpt.buffer.bytes_in_range(start..end) + }); + } +} + impl<'a> Iterator for MultiBufferBytes<'a> { type Item = &'a [u8]; fn next(&mut self) -> Option { - self.chunks.next().map(|chunk| chunk.text.as_bytes()) + let result = self.peek()?; + self.consume(result.len()); + Some(result) } } impl<'a> io::Read for MultiBufferBytes<'a> { - fn read(&mut self, _: &mut [u8]) -> io::Result { - todo!() + fn read(&mut self, buf: &mut [u8]) -> io::Result { + if let Some(chunk) = self.peek() { + let len = cmp::min(buf.len(), chunk.len()); + buf[..len].copy_from_slice(&chunk[..len]); + self.consume(len); + Ok(len) + } else { + Ok(0) + } } } @@ -2195,8 +2287,24 @@ mod tests { for _ in 0..10 { let end_ix = snapshot.clip_offset(rng.gen_range(0..=snapshot.len()), Bias::Right); assert_eq!( + snapshot.reversed_chars_at(end_ix).collect::(), expected_text[..end_ix].chars().rev().collect::(), - snapshot.reversed_chars_at(end_ix).collect::() + ); + } + + for _ in 0..10 { + let end_ix = rng.gen_range(0..=snapshot.len()); + let start_ix = rng.gen_range(0..=end_ix); + dbg!(&expected_text); + assert_eq!( + snapshot + .bytes_in_range(start_ix..end_ix) + .flatten() + .copied() + .collect::>(), + expected_text.as_bytes()[start_ix..end_ix].to_vec(), + "bytes_in_range({:?})", + start_ix..end_ix, ); } }