chunk WIP

Author: Noam Lewis

src/main.rs

@@ -23,8 +23,13 @@ mod lines {
         pub fn empty() -> LoadedLine {
             LoadedLine { chars: vec![] }
         }
-        pub fn new(chars: Vec<char>) -> LoadedLine {
-            LoadedLine { chars }
+        pub fn new(chars: &[char]) -> LoadedLine {
+            LoadedLine {
+                chars: Vec::from(chars),
+            }
+        }
+        pub fn from_vec(chars: Vec<char>) -> LoadedLine {
+            LoadedLine { chars: chars }
         }
         pub fn len(&self) -> usize {
             self.chars.len()
@@ -56,6 +61,154 @@ mod lines {
     }
 }
 
+mod chunks {
+
+    use crate::lines::LoadedLine;
+
+    pub struct Chunk<'a> {
+        file_offset: u64,
+        is_modified: bool,
+        data: &'a [char],
+    }
+
+    impl Chunk<'_> {
+        pub fn from_disk(file_offset: u64, data: &[char]) -> Chunk {
+            Chunk {
+                file_offset,
+                is_modified: false,
+                data,
+            }
+        }
+
+        pub fn lines_iter(&self) -> ChunkLinesIter {
+            ChunkLinesIter {
+                chunk: self,
+                offset_in_chunk: 0,
+            }
+        }
+    }
+
+    pub struct ChunkLinesIter<'a> {
+        chunk: &'a Chunk<'a>,
+        offset_in_chunk: usize,
+    }
+
+    impl<'a> Iterator for ChunkLinesIter<'a> {
+        type Item = LoadedLine;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            for (i, c) in self
+                .chunk
+                .data
+                .iter()
+                .skip(self.offset_in_chunk)
+                .enumerate()
+            {
+                if *c != '\n' {
+                    continue;
+                }
+                let slice = &self.chunk.data[self.offset_in_chunk..i];
+                let line = LoadedLine::new(slice);
+                self.offset_in_chunk = i;
+                return Some(line);
+            }
+            self.offset_in_chunk = self.chunk.data.len();
+            return None;
+        }
+    }
+    impl<'a> DoubleEndedIterator for ChunkLinesIter<'a> {
+        fn next_back(&mut self) -> Option<Self::Item> {
+            for (i, c) in self
+                .chunk
+                .data
+                .iter()
+                .skip(self.offset_in_chunk)
+                .rev()
+                .enumerate()
+            {
+                if *c != '\n' {
+                    continue;
+                }
+                let slice = &self.chunk.data[self.offset_in_chunk..i];
+                let line = LoadedLine::new(slice);
+                self.offset_in_chunk = i;
+                return Some(line);
+            }
+            self.offset_in_chunk = self.chunk.data.len();
+            return None;
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+
+    use chunks::Chunk;
+
+    #[test]
+    fn test_chunk_lines_iter() {
+        let data: Vec<char> = "line1\nline2\nline3\n".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line1"
+        );
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line2"
+        );
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line3"
+        );
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_chunk_lines_iter_empty() {
+        let data: Vec<char> = "".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_chunk_lines_iter_no_newline() {
+        let data: Vec<char> = "line1".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line1"
+        );
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_chunk_lines_iter_double_ended() {
+        let data: Vec<char> = "line1\nline2\nline3\n".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert_eq!(
+            iter.next_back().unwrap().chars_iter().collect::<String>(),
+            "line3"
+        );
+        assert_eq!(
+            iter.next_back().unwrap().chars_iter().collect::<String>(),
+            "line2"
+        );
+        assert_eq!(
+            iter.next_back().unwrap().chars_iter().collect::<String>(),
+            "line1"
+        );
+        assert!(iter.next_back().is_none());
+    }
+}
+
 use lines::LoadedLine;
 
 // TODO
@@ -65,7 +218,7 @@ use lines::LoadedLine;
 //
 // Other editors:
 // - emacs: gap buffer
-// - vim: rope
+// - vim: rope (https://github.com/vim/vim/blob/master/src/memline.c and https://github.com/vim/vim/blob/master/src/memfile.c)
 //
 // Idea:
 // List of contiguous chunks: (disk_offset, data, is_modified).
@@ -340,7 +493,7 @@ impl State {
         self.cursor.y += 1;
         self.cursor.x = 0;
         self.lines
-            .insert(self.cursor.y as usize, LoadedLine::new(new_line));
+            .insert(self.cursor.y as usize, LoadedLine::from_vec(new_line));
     }
 
     fn draw_frame(&self, frame: &mut Frame) {