From bbe276e3a80571dd0d72a9b32fb7bed38c3be868 Mon Sep 17 00:00:00 2001 From: Joe Wilm Date: Thu, 12 Oct 2017 19:07:49 -0700 Subject: Back Grid with VecDeque VecDeque offers improved performance beyond a plain Vec for common scrolling situations (full screen scroll). Additionally, VecDeque is necessary for performant scrollback since recycling old rows for a Vec would be expensive (push/pop front would shift entire vec). --- src/grid.rs | 282 ++++++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 191 insertions(+), 91 deletions(-) (limited to 'src/grid.rs') diff --git a/src/grid.rs b/src/grid.rs index f40ceec9..1b4236f7 100644 --- a/src/grid.rs +++ b/src/grid.rs @@ -22,9 +22,10 @@ use std::borrow::ToOwned; use std::cmp::Ordering; +use std::collections::{VecDeque, vec_deque}; use std::iter::IntoIterator; use std::ops::{Deref, DerefMut, Range, RangeTo, RangeFrom, RangeFull, Index, IndexMut}; -use std::slice::{self, Iter, IterMut}; +use std::slice; use index::{self, Point, Line, Column, IndexRange, RangeInclusive}; @@ -58,7 +59,7 @@ impl Deref for Indexed { pub struct Grid { /// Lines in the grid. Each row holds a list of cells corresponding to the /// columns in that row. - raw: Vec>, + raw: VecDeque>, /// Number of columns cols: index::Column, @@ -76,9 +77,9 @@ pub struct GridIterator<'a, T: 'a> { impl Grid { pub fn new(lines: index::Line, cols: index::Column, template: &T) -> Grid { - let mut raw = Vec::with_capacity(*lines); + let mut raw = VecDeque::with_capacity(*lines); for _ in IndexRange(index::Line(0)..lines) { - raw.push(Row::new(cols, template)); + raw.push_back(Row::new(cols, template)); } Grid { @@ -109,7 +110,7 @@ impl Grid { fn grow_lines(&mut self, lines: index::Line, template: &T) { for _ in IndexRange(self.num_lines()..lines) { - self.raw.push(Row::new(self.cols, template)); + self.raw.push_back(Row::new(self.cols, template)); } self.lines = lines; @@ -125,14 +126,168 @@ impl Grid { } + +/// A subset of lines in the grid +/// +/// May be constructed using Grid::region(..) +pub struct Region<'a, T: 'a> { + start: Line, + end: Line, + raw: &'a VecDeque>, +} + +/// A mutable subset of lines in the grid +/// +/// May be constructed using Grid::region_mut(..) +pub struct RegionMut<'a, T: 'a> { + start: Line, + end: Line, + raw: &'a mut VecDeque>, +} + +pub trait IndexRegion { + /// Get an immutable region of Self + fn region<'a>(&'a self, _: I) -> Region<'a, T>; + + /// Get a mutable region of Self + fn region_mut<'a>(&'a mut self, _: I) -> RegionMut<'a, T>; +} + +impl IndexRegion, T> for Grid { + fn region(&self, index: Range) -> Region { + assert!(index.start < self.num_lines()); + assert!(index.end <= self.num_lines()); + assert!(index.start <= index.end); + Region { + start: index.start, + end: index.end, + raw: &self.raw + } + } + fn region_mut(&mut self, index: Range) -> RegionMut { + assert!(index.start < self.num_lines()); + assert!(index.end <= self.num_lines()); + assert!(index.start <= index.end); + RegionMut { + start: index.start, + end: index.end, + raw: &mut self.raw + } + } +} + +impl IndexRegion, T> for Grid { + fn region(&self, index: RangeTo) -> Region { + assert!(index.end <= self.num_lines()); + Region { + start: Line(0), + end: index.end, + raw: &self.raw + } + } + fn region_mut(&mut self, index: RangeTo) -> RegionMut { + assert!(index.end <= self.num_lines()); + RegionMut { + start: Line(0), + end: index.end, + raw: &mut self.raw + } + } +} + +impl IndexRegion, T> for Grid { + fn region(&self, index: RangeFrom) -> Region { + assert!(index.start < self.num_lines()); + Region { + start: index.start, + end: self.num_lines(), + raw: &self.raw + } + } + fn region_mut(&mut self, index: RangeFrom) -> RegionMut { + assert!(index.start < self.num_lines()); + RegionMut { + start: index.start, + end: self.num_lines(), + raw: &mut self.raw + } + } +} + +pub struct RegionIter<'a, T: 'a> { + end: Line, + cur: Line, + raw: &'a VecDeque>, +} + +pub struct RegionIterMut<'a, T: 'a> { + end: Line, + cur: Line, + raw: &'a mut VecDeque>, +} + +impl<'a, T> IntoIterator for Region<'a, T> { + type Item = &'a Row; + type IntoIter = RegionIter<'a, T>; + + fn into_iter(self) -> Self::IntoIter { + RegionIter { + end: self.end, + cur: self.start, + raw: self.raw + } + } +} + +impl<'a, T> IntoIterator for RegionMut<'a, T> { + type Item = &'a mut Row; + type IntoIter = RegionIterMut<'a, T>; + + fn into_iter(self) -> Self::IntoIter { + RegionIterMut { + end: self.end, + cur: self.start, + raw: self.raw + } + } +} + +impl<'a, T> Iterator for RegionIter<'a, T> { + type Item = &'a Row; + fn next(&mut self) -> Option { + if self.cur < self.end { + let index = self.cur; + self.cur += 1; + Some(&self.raw[*index]) + } else { + None + } + } +} + +impl<'a, T> Iterator for RegionIterMut<'a, T> { + type Item = &'a mut Row; + fn next(&mut self) -> Option { + if self.cur < self.end { + let index = self.cur; + self.cur += 1; + unsafe { + Some(&mut *(&mut self.raw[index.0] as *mut _)) + } + } else { + None + } + } +} + impl Grid { #[inline] - pub fn lines(&self) -> Iter> { + pub fn lines(&self) -> vec_deque::Iter> { self.raw.iter() } #[inline] - pub fn lines_mut(&mut self) -> IterMut> { + pub fn lines_mut(&mut self) -> vec_deque::IterMut> { self.raw.iter_mut() } @@ -146,21 +301,35 @@ impl Grid { self.cols } - pub fn iter_rows(&self) -> slice::Iter> { - self.raw.iter() - } - #[inline] pub fn scroll_down(&mut self, region: &Range, positions: index::Line) { - for line in IndexRange((region.start + positions)..region.end).rev() { - self.swap_lines(line, line - positions); + if region.start == Line(0) && region.end == self.num_lines() { + // Full rotation + for _ in 0..positions.0 { + let item = self.raw.pop_back().unwrap(); + self.raw.push_front(item); + } + } else { + // Subregion rotation + for line in IndexRange((region.start + positions)..region.end).rev() { + self.swap_lines(line, line - positions); + } } } #[inline] pub fn scroll_up(&mut self, region: &Range, positions: index::Line) { - for line in IndexRange(region.start..(region.end - positions)) { - self.swap_lines(line, line + positions); + if region.start == Line(0) && region.end == self.num_lines() { + // Full rotation + for _ in 0..positions.0 { + let item = self.raw.pop_front().unwrap(); + self.raw.push_back(item); + } + } else { + // Subregion rotation + for line in IndexRange(region.start..(region.end - positions)) { + self.swap_lines(line, line + positions); + } } } @@ -182,24 +351,7 @@ impl Grid { /// better error messages by doing the bounds checking ourselves. #[inline] pub fn swap_lines(&mut self, src: index::Line, dst: index::Line) { - use util::unlikely; - - unsafe { - // check that src/dst are in bounds. Since index::Line newtypes usize, - // we can assume values are positive. - if unlikely(src >= self.lines) { - panic!("swap_lines src out of bounds; len={}, src={}", self.raw.len(), src); - } - - if unlikely(dst >= self.lines) { - panic!("swap_lines dst out of bounds; len={}, dst={}", self.raw.len(), dst); - } - - let src: *mut _ = self.raw.get_unchecked_mut(src.0); - let dst: *mut _ = self.raw.get_unchecked_mut(dst.0); - - ::std::ptr::swap(src, dst); - } + self.raw.swap(*src, *dst); } #[inline] @@ -210,7 +362,7 @@ impl Grid { fn shrink_lines(&mut self, lines: index::Line) { while index::Line(self.raw.len()) != lines { - self.raw.pop(); + self.raw.pop_back(); } self.lines = lines; @@ -324,22 +476,22 @@ impl Row { } #[inline] - pub fn cells(&self) -> Iter { + pub fn cells(&self) -> slice::Iter { self.0.iter() } #[inline] - pub fn cells_mut(&mut self) -> IterMut { + pub fn cells_mut(&mut self) -> slice::IterMut { self.0.iter_mut() } } impl<'a, T> IntoIterator for &'a Grid { type Item = &'a Row; - type IntoIter = slice::Iter<'a, Row>; + type IntoIter = vec_deque::Iter<'a, Row>; #[inline] - fn into_iter(self) -> slice::Iter<'a, Row> { + fn into_iter(self) -> vec_deque::Iter<'a, Row> { self.raw.iter() } } @@ -421,58 +573,6 @@ row_index_range!(RangeTo); row_index_range!(RangeFrom); row_index_range!(RangeFull); -// ----------------------------------------------------------------------------- -// Row ranges for Grid -// ----------------------------------------------------------------------------- - -impl Index> for Grid { - type Output = [Row]; - - #[inline] - fn index(&self, index: Range) -> &[Row] { - &self.raw[(index.start.0)..(index.end.0)] - } -} - -impl IndexMut> for Grid { - #[inline] - fn index_mut(&mut self, index: Range) -> &mut [Row] { - &mut self.raw[(index.start.0)..(index.end.0)] - } -} - -impl Index> for Grid { - type Output = [Row]; - - #[inline] - fn index(&self, index: RangeTo) -> &[Row] { - &self.raw[..(index.end.0)] - } -} - -impl IndexMut> for Grid { - #[inline] - fn index_mut(&mut self, index: RangeTo) -> &mut [Row] { - &mut self.raw[..(index.end.0)] - } -} - -impl Index> for Grid { - type Output = [Row]; - - #[inline] - fn index(&self, index: RangeFrom) -> &[Row] { - &self.raw[(index.start.0)..] - } -} - -impl IndexMut> for Grid { - #[inline] - fn index_mut(&mut self, index: RangeFrom) -> &mut [Row] { - &mut self.raw[(index.start.0)..] - } -} - // ----------------------------------------------------------------------------- // Column ranges for Row // ----------------------------------------------------------------------------- @@ -533,7 +633,7 @@ macro_rules! clear_region_impl { ($range:ty) => { impl ClearRegion<$range, T> for Grid { fn clear_region(&mut self, region: $range, func: F) { - for row in self[region].iter_mut() { + for row in self.region_mut(region) { for cell in row { func(cell); } -- cgit v1.2.3-54-g00ecf From 277425956f361677deb1de92b25aeca9cbcd1cd1 Mon Sep 17 00:00:00 2001 From: Joe Wilm Date: Thu, 12 Oct 2017 20:01:28 -0700 Subject: Move grid Row and tests into submodules This is part of some cleanup for the grid module as a whole. --- src/grid.rs | 824 ------------------------------------------------------ src/grid/mod.rs | 495 ++++++++++++++++++++++++++++++++ src/grid/row.rs | 186 ++++++++++++ src/grid/tests.rs | 188 +++++++++++++ 4 files changed, 869 insertions(+), 824 deletions(-) delete mode 100644 src/grid.rs create mode 100644 src/grid/mod.rs create mode 100644 src/grid/row.rs create mode 100644 src/grid/tests.rs (limited to 'src/grid.rs') diff --git a/src/grid.rs b/src/grid.rs deleted file mode 100644 index 1b4236f7..00000000 --- a/src/grid.rs +++ /dev/null @@ -1,824 +0,0 @@ -// Copyright 2016 Joe Wilm, The Alacritty Project Contributors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -//! A generic 2d grid implementation optimized for use in a terminal. -//! -//! The current implementation uses a vector of vectors to store cell data. -//! Reimplementing the store as a single contiguous vector may be desirable in -//! the future. Rotation and indexing would need to be reconsidered at that -//! time; rotation currently reorganize Vecs in the lines Vec, and indexing with -//! ranges is currently supported. - -use std::borrow::ToOwned; -use std::cmp::Ordering; -use std::collections::{VecDeque, vec_deque}; -use std::iter::IntoIterator; -use std::ops::{Deref, DerefMut, Range, RangeTo, RangeFrom, RangeFull, Index, IndexMut}; -use std::slice; - -use index::{self, Point, Line, Column, IndexRange, RangeInclusive}; - -/// Convert a type to a linear index range. -pub trait ToRange { - fn to_range(&self) -> RangeInclusive; -} - -/// Bidirection iterator -pub trait BidirectionalIterator: Iterator { - fn prev(&mut self) -> Option; -} - -pub struct Indexed { - pub line: Line, - pub column: Column, - pub inner: T -} - -impl Deref for Indexed { - type Target = T; - - #[inline] - fn deref(&self) -> &T { - &self.inner - } -} - -/// Represents the terminal display contents -#[derive(Clone, Debug, Deserialize, Serialize, Eq, PartialEq)] -pub struct Grid { - /// Lines in the grid. Each row holds a list of cells corresponding to the - /// columns in that row. - raw: VecDeque>, - - /// Number of columns - cols: index::Column, - - /// Number of lines. - /// - /// Invariant: lines is equivalent to raw.len() - lines: index::Line, -} - -pub struct GridIterator<'a, T: 'a> { - grid: &'a Grid, - pub cur: Point, -} - -impl Grid { - pub fn new(lines: index::Line, cols: index::Column, template: &T) -> Grid { - let mut raw = VecDeque::with_capacity(*lines); - for _ in IndexRange(index::Line(0)..lines) { - raw.push_back(Row::new(cols, template)); - } - - Grid { - raw, - cols, - lines, - } - } - - pub fn resize(&mut self, lines: index::Line, cols: index::Column, template: &T) { - // Check that there's actually work to do and return early if not - if lines == self.lines && cols == self.cols { - return; - } - - match self.lines.cmp(&lines) { - Ordering::Less => self.grow_lines(lines, template), - Ordering::Greater => self.shrink_lines(lines), - Ordering::Equal => (), - } - - match self.cols.cmp(&cols) { - Ordering::Less => self.grow_cols(cols, template), - Ordering::Greater => self.shrink_cols(cols), - Ordering::Equal => (), - } - } - - fn grow_lines(&mut self, lines: index::Line, template: &T) { - for _ in IndexRange(self.num_lines()..lines) { - self.raw.push_back(Row::new(self.cols, template)); - } - - self.lines = lines; - } - - fn grow_cols(&mut self, cols: index::Column, template: &T) { - for row in self.lines_mut() { - row.grow(cols, template); - } - - self.cols = cols; - } - -} - - -/// A subset of lines in the grid -/// -/// May be constructed using Grid::region(..) -pub struct Region<'a, T: 'a> { - start: Line, - end: Line, - raw: &'a VecDeque>, -} - -/// A mutable subset of lines in the grid -/// -/// May be constructed using Grid::region_mut(..) -pub struct RegionMut<'a, T: 'a> { - start: Line, - end: Line, - raw: &'a mut VecDeque>, -} - -pub trait IndexRegion { - /// Get an immutable region of Self - fn region<'a>(&'a self, _: I) -> Region<'a, T>; - - /// Get a mutable region of Self - fn region_mut<'a>(&'a mut self, _: I) -> RegionMut<'a, T>; -} - -impl IndexRegion, T> for Grid { - fn region(&self, index: Range) -> Region { - assert!(index.start < self.num_lines()); - assert!(index.end <= self.num_lines()); - assert!(index.start <= index.end); - Region { - start: index.start, - end: index.end, - raw: &self.raw - } - } - fn region_mut(&mut self, index: Range) -> RegionMut { - assert!(index.start < self.num_lines()); - assert!(index.end <= self.num_lines()); - assert!(index.start <= index.end); - RegionMut { - start: index.start, - end: index.end, - raw: &mut self.raw - } - } -} - -impl IndexRegion, T> for Grid { - fn region(&self, index: RangeTo) -> Region { - assert!(index.end <= self.num_lines()); - Region { - start: Line(0), - end: index.end, - raw: &self.raw - } - } - fn region_mut(&mut self, index: RangeTo) -> RegionMut { - assert!(index.end <= self.num_lines()); - RegionMut { - start: Line(0), - end: index.end, - raw: &mut self.raw - } - } -} - -impl IndexRegion, T> for Grid { - fn region(&self, index: RangeFrom) -> Region { - assert!(index.start < self.num_lines()); - Region { - start: index.start, - end: self.num_lines(), - raw: &self.raw - } - } - fn region_mut(&mut self, index: RangeFrom) -> RegionMut { - assert!(index.start < self.num_lines()); - RegionMut { - start: index.start, - end: self.num_lines(), - raw: &mut self.raw - } - } -} - -pub struct RegionIter<'a, T: 'a> { - end: Line, - cur: Line, - raw: &'a VecDeque>, -} - -pub struct RegionIterMut<'a, T: 'a> { - end: Line, - cur: Line, - raw: &'a mut VecDeque>, -} - -impl<'a, T> IntoIterator for Region<'a, T> { - type Item = &'a Row; - type IntoIter = RegionIter<'a, T>; - - fn into_iter(self) -> Self::IntoIter { - RegionIter { - end: self.end, - cur: self.start, - raw: self.raw - } - } -} - -impl<'a, T> IntoIterator for RegionMut<'a, T> { - type Item = &'a mut Row; - type IntoIter = RegionIterMut<'a, T>; - - fn into_iter(self) -> Self::IntoIter { - RegionIterMut { - end: self.end, - cur: self.start, - raw: self.raw - } - } -} - -impl<'a, T> Iterator for RegionIter<'a, T> { - type Item = &'a Row; - fn next(&mut self) -> Option { - if self.cur < self.end { - let index = self.cur; - self.cur += 1; - Some(&self.raw[*index]) - } else { - None - } - } -} - -impl<'a, T> Iterator for RegionIterMut<'a, T> { - type Item = &'a mut Row; - fn next(&mut self) -> Option { - if self.cur < self.end { - let index = self.cur; - self.cur += 1; - unsafe { - Some(&mut *(&mut self.raw[index.0] as *mut _)) - } - } else { - None - } - } -} - -impl Grid { - #[inline] - pub fn lines(&self) -> vec_deque::Iter> { - self.raw.iter() - } - - #[inline] - pub fn lines_mut(&mut self) -> vec_deque::IterMut> { - self.raw.iter_mut() - } - - #[inline] - pub fn num_lines(&self) -> index::Line { - self.lines - } - - #[inline] - pub fn num_cols(&self) -> index::Column { - self.cols - } - - #[inline] - pub fn scroll_down(&mut self, region: &Range, positions: index::Line) { - if region.start == Line(0) && region.end == self.num_lines() { - // Full rotation - for _ in 0..positions.0 { - let item = self.raw.pop_back().unwrap(); - self.raw.push_front(item); - } - } else { - // Subregion rotation - for line in IndexRange((region.start + positions)..region.end).rev() { - self.swap_lines(line, line - positions); - } - } - } - - #[inline] - pub fn scroll_up(&mut self, region: &Range, positions: index::Line) { - if region.start == Line(0) && region.end == self.num_lines() { - // Full rotation - for _ in 0..positions.0 { - let item = self.raw.pop_front().unwrap(); - self.raw.push_back(item); - } - } else { - // Subregion rotation - for line in IndexRange(region.start..(region.end - positions)) { - self.swap_lines(line, line + positions); - } - } - } - - pub fn iter_from(&self, point: Point) -> GridIterator { - GridIterator { - grid: self, - cur: point, - } - } - - #[inline] - pub fn contains(&self, point: &Point) -> bool { - self.lines > point.line && self.cols > point.col - } - - /// Swap two lines in the grid - /// - /// This could have used slice::swap internally, but we are able to have - /// better error messages by doing the bounds checking ourselves. - #[inline] - pub fn swap_lines(&mut self, src: index::Line, dst: index::Line) { - self.raw.swap(*src, *dst); - } - - #[inline] - pub fn clear(&mut self, func: F) { - let region = index::Line(0)..self.num_lines(); - self.clear_region(region, func); - } - - fn shrink_lines(&mut self, lines: index::Line) { - while index::Line(self.raw.len()) != lines { - self.raw.pop_back(); - } - - self.lines = lines; - } - - fn shrink_cols(&mut self, cols: index::Column) { - for row in self.lines_mut() { - row.shrink(cols); - } - - self.cols = cols; - } -} - -impl<'a, T> Iterator for GridIterator<'a, T> { - type Item = &'a T; - - fn next(&mut self) -> Option { - let last_line = self.grid.num_lines() - Line(1); - let last_col = self.grid.num_cols() - Column(1); - match self.cur { - Point { line, col } if - (line == last_line) && - (col == last_col) => None, - Point { col, .. } if - (col == last_col) => { - self.cur.line += Line(1); - self.cur.col = Column(0); - Some(&self.grid[self.cur.line][self.cur.col]) - }, - _ => { - self.cur.col += Column(1); - Some(&self.grid[self.cur.line][self.cur.col]) - } - } - } -} - -impl<'a, T> BidirectionalIterator for GridIterator<'a, T> { - fn prev(&mut self) -> Option { - let num_cols = self.grid.num_cols(); - - match self.cur { - Point { line: Line(0), col: Column(0) } => None, - Point { col: Column(0), .. } => { - self.cur.line -= Line(1); - self.cur.col = num_cols - Column(1); - Some(&self.grid[self.cur.line][self.cur.col]) - }, - _ => { - self.cur.col -= Column(1); - Some(&self.grid[self.cur.line][self.cur.col]) - } - } - } -} - -impl Index for Grid { - type Output = Row; - - #[inline] - fn index(&self, index: index::Line) -> &Row { - &self.raw[index.0] - } -} - -impl IndexMut for Grid { - #[inline] - fn index_mut(&mut self, index: index::Line) -> &mut Row { - &mut self.raw[index.0] - } -} - -impl<'point, T> Index<&'point Point> for Grid { - type Output = T; - - #[inline] - fn index<'a>(&'a self, point: &Point) -> &'a T { - &self.raw[point.line.0][point.col] - } -} - -impl<'point, T> IndexMut<&'point Point> for Grid { - #[inline] - fn index_mut<'a, 'b>(&'a mut self, point: &'b Point) -> &'a mut T { - &mut self.raw[point.line.0][point.col] - } -} - -/// A row in the grid -#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)] -pub struct Row(Vec); - -impl Row { - pub fn new(columns: index::Column, template: &T) -> Row { - Row(vec![template.to_owned(); *columns]) - } - - pub fn grow(&mut self, cols: index::Column, template: &T) { - while self.len() != *cols { - self.push(template.to_owned()); - } - } -} - -impl Row { - pub fn shrink(&mut self, cols: index::Column) { - while self.len() != *cols { - self.pop(); - } - } - - #[inline] - pub fn cells(&self) -> slice::Iter { - self.0.iter() - } - - #[inline] - pub fn cells_mut(&mut self) -> slice::IterMut { - self.0.iter_mut() - } -} - -impl<'a, T> IntoIterator for &'a Grid { - type Item = &'a Row; - type IntoIter = vec_deque::Iter<'a, Row>; - - #[inline] - fn into_iter(self) -> vec_deque::Iter<'a, Row> { - self.raw.iter() - } -} - -impl<'a, T> IntoIterator for &'a Row { - type Item = &'a T; - type IntoIter = slice::Iter<'a, T>; - - #[inline] - fn into_iter(self) -> slice::Iter<'a, T> { - self.iter() - } -} - -impl<'a, T> IntoIterator for &'a mut Row { - type Item = &'a mut T; - type IntoIter = slice::IterMut<'a, T>; - - #[inline] - fn into_iter(self) -> slice::IterMut<'a, T> { - self.iter_mut() - } -} - -impl Deref for Row { - type Target = Vec; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for Row { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl Index for Row { - type Output = T; - - #[inline] - fn index(&self, index: index::Column) -> &T { - &self.0[index.0] - } -} - -impl IndexMut for Row { - #[inline] - fn index_mut(&mut self, index: index::Column) -> &mut T { - &mut self.0[index.0] - } -} - -macro_rules! row_index_range { - ($range:ty) => { - impl Index<$range> for Row { - type Output = [T]; - - #[inline] - fn index(&self, index: $range) -> &[T] { - &self.0[index] - } - } - - impl IndexMut<$range> for Row { - #[inline] - fn index_mut(&mut self, index: $range) -> &mut [T] { - &mut self.0[index] - } - } - } -} - -row_index_range!(Range); -row_index_range!(RangeTo); -row_index_range!(RangeFrom); -row_index_range!(RangeFull); - -// ----------------------------------------------------------------------------- -// Column ranges for Row -// ----------------------------------------------------------------------------- - -impl Index> for Row { - type Output = [T]; - - #[inline] - fn index(&self, index: Range) -> &[T] { - &self.0[(index.start.0)..(index.end.0)] - } -} - -impl IndexMut> for Row { - #[inline] - fn index_mut(&mut self, index: Range) -> &mut [T] { - &mut self.0[(index.start.0)..(index.end.0)] - } -} - -impl Index> for Row { - type Output = [T]; - - #[inline] - fn index(&self, index: RangeTo) -> &[T] { - &self.0[..(index.end.0)] - } -} - -impl IndexMut> for Row { - #[inline] - fn index_mut(&mut self, index: RangeTo) -> &mut [T] { - &mut self.0[..(index.end.0)] - } -} - -impl Index> for Row { - type Output = [T]; - - #[inline] - fn index(&self, index: RangeFrom) -> &[T] { - &self.0[(index.start.0)..] - } -} - -impl IndexMut> for Row { - #[inline] - fn index_mut(&mut self, index: RangeFrom) -> &mut [T] { - &mut self.0[(index.start.0)..] - } -} - -pub trait ClearRegion { - fn clear_region(&mut self, region: R, func: F); -} - -macro_rules! clear_region_impl { - ($range:ty) => { - impl ClearRegion<$range, T> for Grid { - fn clear_region(&mut self, region: $range, func: F) { - for row in self.region_mut(region) { - for cell in row { - func(cell); - } - } - } - } - } -} - -clear_region_impl!(Range); -clear_region_impl!(RangeTo); -clear_region_impl!(RangeFrom); - -#[cfg(test)] -mod tests { - use super::{Grid, BidirectionalIterator}; - use index::{Point, Line, Column}; - #[test] - fn grid_swap_lines_ok() { - let mut grid = Grid::new(Line(10), Column(1), &0); - info!(""); - - // swap test ends - grid[Line(0)][Column(0)] = 1; - grid[Line(9)][Column(0)] = 2; - - assert_eq!(grid[Line(0)][Column(0)], 1); - assert_eq!(grid[Line(9)][Column(0)], 2); - - grid.swap_lines(Line(0), Line(9)); - - assert_eq!(grid[Line(0)][Column(0)], 2); - assert_eq!(grid[Line(9)][Column(0)], 1); - - // swap test mid - grid[Line(4)][Column(0)] = 1; - grid[Line(5)][Column(0)] = 2; - - info!("grid: {:?}", grid); - - assert_eq!(grid[Line(4)][Column(0)], 1); - assert_eq!(grid[Line(5)][Column(0)], 2); - - grid.swap_lines(Line(4), Line(5)); - - info!("grid: {:?}", grid); - - assert_eq!(grid[Line(4)][Column(0)], 2); - assert_eq!(grid[Line(5)][Column(0)], 1); - } - - #[test] - #[should_panic] - fn grid_swap_lines_oob1() { - let mut grid = Grid::new(Line(10), Column(1), &0); - grid.swap_lines(Line(0), Line(10)); - } - - #[test] - #[should_panic] - fn grid_swap_lines_oob2() { - let mut grid = Grid::new(Line(10), Column(1), &0); - grid.swap_lines(Line(10), Line(0)); - } - - #[test] - #[should_panic] - fn grid_swap_lines_oob3() { - let mut grid = Grid::new(Line(10), Column(1), &0); - grid.swap_lines(Line(10), Line(10)); - } - - // Scroll up moves lines upwards - #[test] - fn scroll_up() { - info!(""); - - let mut grid = Grid::new(Line(10), Column(1), &0); - for i in 0..10 { - grid[Line(i)][Column(0)] = i; - } - - info!("grid: {:?}", grid); - - grid.scroll_up(&(Line(0)..Line(10)), Line(2)); - - info!("grid: {:?}", grid); - - let mut other = Grid::new(Line(10), Column(1), &9); - - other[Line(0)][Column(0)] = 2; - other[Line(1)][Column(0)] = 3; - other[Line(2)][Column(0)] = 4; - other[Line(3)][Column(0)] = 5; - other[Line(4)][Column(0)] = 6; - other[Line(5)][Column(0)] = 7; - other[Line(6)][Column(0)] = 8; - other[Line(7)][Column(0)] = 9; - other[Line(8)][Column(0)] = 0; - other[Line(9)][Column(0)] = 1; - - for i in 0..10 { - assert_eq!(grid[Line(i)][Column(0)], other[Line(i)][Column(0)]); - } - } - - // Scroll down moves lines downwards - #[test] - fn scroll_down() { - info!(""); - - let mut grid = Grid::new(Line(10), Column(1), &0); - for i in 0..10 { - grid[Line(i)][Column(0)] = i; - } - - info!("grid: {:?}", grid); - - grid.scroll_down(&(Line(0)..Line(10)), Line(2)); - - info!("grid: {:?}", grid); - - let mut other = Grid::new(Line(10), Column(1), &9); - - other[Line(0)][Column(0)] = 8; - other[Line(1)][Column(0)] = 9; - other[Line(2)][Column(0)] = 0; - other[Line(3)][Column(0)] = 1; - other[Line(4)][Column(0)] = 2; - other[Line(5)][Column(0)] = 3; - other[Line(6)][Column(0)] = 4; - other[Line(7)][Column(0)] = 5; - other[Line(8)][Column(0)] = 6; - other[Line(9)][Column(0)] = 7; - - for i in 0..10 { - assert_eq!(grid[Line(i)][Column(0)], other[Line(i)][Column(0)]); - } - } - - // Test that GridIterator works - #[test] - fn test_iter() { - info!(""); - - let mut grid = Grid::new(Line(5), Column(5), &0); - for i in 0..5 { - for j in 0..5 { - grid[Line(i)][Column(j)] = i*5 + j; - } - } - - info!("grid: {:?}", grid); - - let mut iter = grid.iter_from(Point { - line: Line(0), - col: Column(0), - }); - - assert_eq!(None, iter.prev()); - assert_eq!(Some(&1), iter.next()); - assert_eq!(Column(1), iter.cur.col); - assert_eq!(Line(0), iter.cur.line); - - assert_eq!(Some(&2), iter.next()); - assert_eq!(Some(&3), iter.next()); - assert_eq!(Some(&4), iter.next()); - - // test linewrapping - assert_eq!(Some(&5), iter.next()); - assert_eq!(Column(0), iter.cur.col); - assert_eq!(Line(1), iter.cur.line); - - assert_eq!(Some(&4), iter.prev()); - assert_eq!(Column(4), iter.cur.col); - assert_eq!(Line(0), iter.cur.line); - - - // test that iter ends at end of grid - let mut final_iter = grid.iter_from(Point { - line: Line(4), - col: Column(4), - }); - assert_eq!(None, final_iter.next()); - assert_eq!(Some(&23), final_iter.prev()); - } - -} diff --git a/src/grid/mod.rs b/src/grid/mod.rs new file mode 100644 index 00000000..123e13fa --- /dev/null +++ b/src/grid/mod.rs @@ -0,0 +1,495 @@ +// Copyright 2016 Joe Wilm, The Alacritty Project Contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! A generic 2d grid implementation optimized for use in a terminal. +//! +//! The current implementation uses a vector of vectors to store cell data. +//! Reimplementing the store as a single contiguous vector may be desirable in +//! the future. Rotation and indexing would need to be reconsidered at that +//! time; rotation currently reorganize Vecs in the lines Vec, and indexing with +//! ranges is currently supported. + +use std::cmp::Ordering; +use std::collections::{VecDeque, vec_deque}; +use std::iter::IntoIterator; +use std::ops::{Deref, Range, RangeTo, RangeFrom, Index, IndexMut}; + +use index::{self, Point, Line, Column, IndexRange, RangeInclusive}; + +mod row; +pub use self::row::Row; + +#[cfg(test)] +mod tests; + +/// Convert a type to a linear index range. +pub trait ToRange { + fn to_range(&self) -> RangeInclusive; +} + +/// Bidirection iterator +pub trait BidirectionalIterator: Iterator { + fn prev(&mut self) -> Option; +} + +/// An item in the grid along with its Line and Column. +pub struct Indexed { + pub inner: T, + pub line: Line, + pub column: Column, +} + +impl Deref for Indexed { + type Target = T; + + #[inline] + fn deref(&self) -> &T { + &self.inner + } +} + +/// Represents the terminal display contents +#[derive(Clone, Debug, Deserialize, Serialize, Eq, PartialEq)] +pub struct Grid { + /// Lines in the grid. Each row holds a list of cells corresponding to the + /// columns in that row. + raw: VecDeque>, + + /// Number of columns + cols: index::Column, + + /// Number of lines. + /// + /// Invariant: lines is equivalent to raw.len() + lines: index::Line, +} + +pub struct GridIterator<'a, T: 'a> { + grid: &'a Grid, + pub cur: Point, +} + +impl Grid { + pub fn new(lines: index::Line, cols: index::Column, template: &T) -> Grid { + let mut raw = VecDeque::with_capacity(*lines); + for _ in IndexRange(index::Line(0)..lines) { + raw.push_back(Row::new(cols, template)); + } + + Grid { + raw, + cols, + lines, + } + } + + pub fn resize(&mut self, lines: index::Line, cols: index::Column, template: &T) { + // Check that there's actually work to do and return early if not + if lines == self.lines && cols == self.cols { + return; + } + + match self.lines.cmp(&lines) { + Ordering::Less => self.grow_lines(lines, template), + Ordering::Greater => self.shrink_lines(lines), + Ordering::Equal => (), + } + + match self.cols.cmp(&cols) { + Ordering::Less => self.grow_cols(cols, template), + Ordering::Greater => self.shrink_cols(cols), + Ordering::Equal => (), + } + } + + fn grow_lines(&mut self, lines: index::Line, template: &T) { + for _ in IndexRange(self.num_lines()..lines) { + self.raw.push_back(Row::new(self.cols, template)); + } + + self.lines = lines; + } + + fn grow_cols(&mut self, cols: index::Column, template: &T) { + for row in self.lines_mut() { + row.grow(cols, template); + } + + self.cols = cols; + } + +} + + + +impl Grid { + #[inline] + pub fn lines(&self) -> vec_deque::Iter> { + self.raw.iter() + } + + #[inline] + pub fn lines_mut(&mut self) -> vec_deque::IterMut> { + self.raw.iter_mut() + } + + #[inline] + pub fn num_lines(&self) -> index::Line { + self.lines + } + + #[inline] + pub fn num_cols(&self) -> index::Column { + self.cols + } + + #[inline] + pub fn scroll_down(&mut self, region: &Range, positions: index::Line) { + if region.start == Line(0) && region.end == self.num_lines() { + // Full rotation + for _ in 0..positions.0 { + let item = self.raw.pop_back().unwrap(); + self.raw.push_front(item); + } + } else { + // Subregion rotation + for line in IndexRange((region.start + positions)..region.end).rev() { + self.swap_lines(line, line - positions); + } + } + } + + #[inline] + pub fn scroll_up(&mut self, region: &Range, positions: index::Line) { + if region.start == Line(0) && region.end == self.num_lines() { + // Full rotation + for _ in 0..positions.0 { + let item = self.raw.pop_front().unwrap(); + self.raw.push_back(item); + } + } else { + // Subregion rotation + for line in IndexRange(region.start..(region.end - positions)) { + self.swap_lines(line, line + positions); + } + } + } + + pub fn iter_from(&self, point: Point) -> GridIterator { + GridIterator { + grid: self, + cur: point, + } + } + + #[inline] + pub fn contains(&self, point: &Point) -> bool { + self.lines > point.line && self.cols > point.col + } + + /// Swap two lines in the grid + /// + /// This could have used slice::swap internally, but we are able to have + /// better error messages by doing the bounds checking ourselves. + #[inline] + pub fn swap_lines(&mut self, src: index::Line, dst: index::Line) { + self.raw.swap(*src, *dst); + } + + #[inline] + pub fn clear(&mut self, func: F) { + let region = index::Line(0)..self.num_lines(); + self.clear_region(region, func); + } + + fn shrink_lines(&mut self, lines: index::Line) { + while index::Line(self.raw.len()) != lines { + self.raw.pop_back(); + } + + self.lines = lines; + } + + fn shrink_cols(&mut self, cols: index::Column) { + for row in self.lines_mut() { + row.shrink(cols); + } + + self.cols = cols; + } +} + +impl<'a, T> Iterator for GridIterator<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option { + let last_line = self.grid.num_lines() - Line(1); + let last_col = self.grid.num_cols() - Column(1); + match self.cur { + Point { line, col } if + (line == last_line) && + (col == last_col) => None, + Point { col, .. } if + (col == last_col) => { + self.cur.line += Line(1); + self.cur.col = Column(0); + Some(&self.grid[self.cur.line][self.cur.col]) + }, + _ => { + self.cur.col += Column(1); + Some(&self.grid[self.cur.line][self.cur.col]) + } + } + } +} + +impl<'a, T> BidirectionalIterator for GridIterator<'a, T> { + fn prev(&mut self) -> Option { + let num_cols = self.grid.num_cols(); + + match self.cur { + Point { line: Line(0), col: Column(0) } => None, + Point { col: Column(0), .. } => { + self.cur.line -= Line(1); + self.cur.col = num_cols - Column(1); + Some(&self.grid[self.cur.line][self.cur.col]) + }, + _ => { + self.cur.col -= Column(1); + Some(&self.grid[self.cur.line][self.cur.col]) + } + } + } +} + +impl Index for Grid { + type Output = Row; + + #[inline] + fn index(&self, index: index::Line) -> &Row { + &self.raw[index.0] + } +} + +impl IndexMut for Grid { + #[inline] + fn index_mut(&mut self, index: index::Line) -> &mut Row { + &mut self.raw[index.0] + } +} + +impl<'point, T> Index<&'point Point> for Grid { + type Output = T; + + #[inline] + fn index<'a>(&'a self, point: &Point) -> &'a T { + &self.raw[point.line.0][point.col] + } +} + +impl<'point, T> IndexMut<&'point Point> for Grid { + #[inline] + fn index_mut<'a, 'b>(&'a mut self, point: &'b Point) -> &'a mut T { + &mut self.raw[point.line.0][point.col] + } +} + +impl<'a, T> IntoIterator for &'a Grid { + type Item = &'a Row; + type IntoIter = vec_deque::Iter<'a, Row>; + + #[inline] + fn into_iter(self) -> vec_deque::Iter<'a, Row> { + self.raw.iter() + } +} + +pub trait ClearRegion { + fn clear_region(&mut self, region: R, func: F); +} + +macro_rules! clear_region_impl { + ($range:ty) => { + impl ClearRegion<$range, T> for Grid { + fn clear_region(&mut self, region: $range, func: F) { + for row in self.region_mut(region) { + for cell in row { + func(cell); + } + } + } + } + } +} + +clear_region_impl!(Range); +clear_region_impl!(RangeTo); +clear_region_impl!(RangeFrom); + +// ================================================================================================= +// Regions ========================================================================================= +// ================================================================================================= + +/// A subset of lines in the grid +/// +/// May be constructed using Grid::region(..) +pub struct Region<'a, T: 'a> { + start: Line, + end: Line, + raw: &'a VecDeque>, +} + +/// A mutable subset of lines in the grid +/// +/// May be constructed using Grid::region_mut(..) +pub struct RegionMut<'a, T: 'a> { + start: Line, + end: Line, + raw: &'a mut VecDeque>, +} + +pub trait IndexRegion { + /// Get an immutable region of Self + fn region<'a>(&'a self, _: I) -> Region<'a, T>; + + /// Get a mutable region of Self + fn region_mut<'a>(&'a mut self, _: I) -> RegionMut<'a, T>; +} + +impl IndexRegion, T> for Grid { + fn region(&self, index: Range) -> Region { + assert!(index.start < self.num_lines()); + assert!(index.end <= self.num_lines()); + assert!(index.start <= index.end); + Region { + start: index.start, + end: index.end, + raw: &self.raw + } + } + fn region_mut(&mut self, index: Range) -> RegionMut { + assert!(index.start < self.num_lines()); + assert!(index.end <= self.num_lines()); + assert!(index.start <= index.end); + RegionMut { + start: index.start, + end: index.end, + raw: &mut self.raw + } + } +} + +impl IndexRegion, T> for Grid { + fn region(&self, index: RangeTo) -> Region { + assert!(index.end <= self.num_lines()); + Region { + start: Line(0), + end: index.end, + raw: &self.raw + } + } + fn region_mut(&mut self, index: RangeTo) -> RegionMut { + assert!(index.end <= self.num_lines()); + RegionMut { + start: Line(0), + end: index.end, + raw: &mut self.raw + } + } +} + +impl IndexRegion, T> for Grid { + fn region(&self, index: RangeFrom) -> Region { + assert!(index.start < self.num_lines()); + Region { + start: index.start, + end: self.num_lines(), + raw: &self.raw + } + } + fn region_mut(&mut self, index: RangeFrom) -> RegionMut { + assert!(index.start < self.num_lines()); + RegionMut { + start: index.start, + end: self.num_lines(), + raw: &mut self.raw + } + } +} + +pub struct RegionIter<'a, T: 'a> { + end: Line, + cur: Line, + raw: &'a VecDeque>, +} + +pub struct RegionIterMut<'a, T: 'a> { + end: Line, + cur: Line, + raw: &'a mut VecDeque>, +} + +impl<'a, T> IntoIterator for Region<'a, T> { + type Item = &'a Row; + type IntoIter = RegionIter<'a, T>; + + fn into_iter(self) -> Self::IntoIter { + RegionIter { + end: self.end, + cur: self.start, + raw: self.raw + } + } +} + +impl<'a, T> IntoIterator for RegionMut<'a, T> { + type Item = &'a mut Row; + type IntoIter = RegionIterMut<'a, T>; + + fn into_iter(self) -> Self::IntoIter { + RegionIterMut { + end: self.end, + cur: self.start, + raw: self.raw + } + } +} + +impl<'a, T> Iterator for RegionIter<'a, T> { + type Item = &'a Row; + fn next(&mut self) -> Option { + if self.cur < self.end { + let index = self.cur; + self.cur += 1; + Some(&self.raw[*index]) + } else { + None + } + } +} + +impl<'a, T> Iterator for RegionIterMut<'a, T> { + type Item = &'a mut Row; + fn next(&mut self) -> Option { + if self.cur < self.end { + let index = self.cur; + self.cur += 1; + unsafe { + Some(&mut *(&mut self.raw[index.0] as *mut _)) + } + } else { + None + } + } +} diff --git a/src/grid/row.rs b/src/grid/row.rs new file mode 100644 index 00000000..8711d04f --- /dev/null +++ b/src/grid/row.rs @@ -0,0 +1,186 @@ +// Copyright 2016 Joe Wilm, The Alacritty Project Contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Defines the Row type which makes up lines in the grid + +use std::ops::{Deref, DerefMut, Index, IndexMut}; +use std::ops::{Range, RangeTo, RangeFrom, RangeFull}; +use std::slice; + +use index::Column; + +/// A row in the grid +#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)] +pub struct Row(Vec); + +impl Row { + pub fn new(columns: Column, template: &T) -> Row { + Row(vec![template.to_owned(); *columns]) + } + + pub fn grow(&mut self, cols: Column, template: &T) { + while self.len() != *cols { + self.push(template.to_owned()); + } + } +} + +impl Row { + pub fn shrink(&mut self, cols: Column) { + while self.len() != *cols { + self.pop(); + } + } + + #[inline] + pub fn cells(&self) -> slice::Iter { + self.0.iter() + } + + #[inline] + pub fn cells_mut(&mut self) -> slice::IterMut { + self.0.iter_mut() + } +} + + +impl<'a, T> IntoIterator for &'a Row { + type Item = &'a T; + type IntoIter = slice::Iter<'a, T>; + + #[inline] + fn into_iter(self) -> slice::Iter<'a, T> { + self.iter() + } +} + +impl<'a, T> IntoIterator for &'a mut Row { + type Item = &'a mut T; + type IntoIter = slice::IterMut<'a, T>; + + #[inline] + fn into_iter(self) -> slice::IterMut<'a, T> { + self.iter_mut() + } +} + +impl Deref for Row { + type Target = Vec; + + #[inline] + fn deref(&self) -> &Self::Target { + &self.0 + } +} + + +impl DerefMut for Row { + #[inline] + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl Index for Row { + type Output = T; + + #[inline] + fn index(&self, index: Column) -> &T { + &self.0[index.0] + } +} + +impl IndexMut for Row { + #[inline] + fn index_mut(&mut self, index: Column) -> &mut T { + &mut self.0[index.0] + } +} + +macro_rules! row_index_range { + ($range:ty) => { + impl Index<$range> for Row { + type Output = [T]; + + #[inline] + fn index(&self, index: $range) -> &[T] { + &self.0[index] + } + } + + impl IndexMut<$range> for Row { + #[inline] + fn index_mut(&mut self, index: $range) -> &mut [T] { + &mut self.0[index] + } + } + } +} + +row_index_range!(Range); +row_index_range!(RangeTo); +row_index_range!(RangeFrom); +row_index_range!(RangeFull); + +// ----------------------------------------------------------------------------- +// Column ranges for Row +// ----------------------------------------------------------------------------- + +impl Index> for Row { + type Output = [T]; + + #[inline] + fn index(&self, index: Range) -> &[T] { + &self.0[(index.start.0)..(index.end.0)] + } +} + +impl IndexMut> for Row { + #[inline] + fn index_mut(&mut self, index: Range) -> &mut [T] { + &mut self.0[(index.start.0)..(index.end.0)] + } +} + +impl Index> for Row { + type Output = [T]; + + #[inline] + fn index(&self, index: RangeTo) -> &[T] { + &self.0[..(index.end.0)] + } +} + +impl IndexMut> for Row { + #[inline] + fn index_mut(&mut self, index: RangeTo) -> &mut [T] { + &mut self.0[..(index.end.0)] + } +} + +impl Index> for Row { + type Output = [T]; + + #[inline] + fn index(&self, index: RangeFrom) -> &[T] { + &self.0[(index.start.0)..] + } +} + +impl IndexMut> for Row { + #[inline] + fn index_mut(&mut self, index: RangeFrom) -> &mut [T] { + &mut self.0[(index.start.0)..] + } +} diff --git a/src/grid/tests.rs b/src/grid/tests.rs new file mode 100644 index 00000000..169cefa0 --- /dev/null +++ b/src/grid/tests.rs @@ -0,0 +1,188 @@ +// Copyright 2016 Joe Wilm, The Alacritty Project Contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests for the Gird + +use super::{Grid, BidirectionalIterator}; +use index::{Point, Line, Column}; + +#[test] +fn grid_swap_lines_ok() { + let mut grid = Grid::new(Line(10), Column(1), &0); + info!(""); + + // swap test ends + grid[Line(0)][Column(0)] = 1; + grid[Line(9)][Column(0)] = 2; + + assert_eq!(grid[Line(0)][Column(0)], 1); + assert_eq!(grid[Line(9)][Column(0)], 2); + + grid.swap_lines(Line(0), Line(9)); + + assert_eq!(grid[Line(0)][Column(0)], 2); + assert_eq!(grid[Line(9)][Column(0)], 1); + + // swap test mid + grid[Line(4)][Column(0)] = 1; + grid[Line(5)][Column(0)] = 2; + + info!("grid: {:?}", grid); + + assert_eq!(grid[Line(4)][Column(0)], 1); + assert_eq!(grid[Line(5)][Column(0)], 2); + + grid.swap_lines(Line(4), Line(5)); + + info!("grid: {:?}", grid); + + assert_eq!(grid[Line(4)][Column(0)], 2); + assert_eq!(grid[Line(5)][Column(0)], 1); +} + +#[test] +#[should_panic] +fn grid_swap_lines_oob1() { + let mut grid = Grid::new(Line(10), Column(1), &0); + grid.swap_lines(Line(0), Line(10)); +} + +#[test] +#[should_panic] +fn grid_swap_lines_oob2() { + let mut grid = Grid::new(Line(10), Column(1), &0); + grid.swap_lines(Line(10), Line(0)); +} + +#[test] +#[should_panic] +fn grid_swap_lines_oob3() { + let mut grid = Grid::new(Line(10), Column(1), &0); + grid.swap_lines(Line(10), Line(10)); +} + +// Scroll up moves lines upwards +#[test] +fn scroll_up() { + info!(""); + + let mut grid = Grid::new(Line(10), Column(1), &0); + for i in 0..10 { + grid[Line(i)][Column(0)] = i; + } + + info!("grid: {:?}", grid); + + grid.scroll_up(Line(0)..Line(10), Line(2)); + + info!("grid: {:?}", grid); + + let mut other = Grid::new(Line(10), Column(1), &9); + + other[Line(0)][Column(0)] = 2; + other[Line(1)][Column(0)] = 3; + other[Line(2)][Column(0)] = 4; + other[Line(3)][Column(0)] = 5; + other[Line(4)][Column(0)] = 6; + other[Line(5)][Column(0)] = 7; + other[Line(6)][Column(0)] = 8; + other[Line(7)][Column(0)] = 9; + other[Line(8)][Column(0)] = 0; + other[Line(9)][Column(0)] = 1; + + for i in 0..10 { + assert_eq!(grid[Line(i)][Column(0)], other[Line(i)][Column(0)]); + } +} + +// Scroll down moves lines downwards +#[test] +fn scroll_down() { + info!(""); + + let mut grid = Grid::new(Line(10), Column(1), &0); + for i in 0..10 { + grid[Line(i)][Column(0)] = i; + } + + info!("grid: {:?}", grid); + + grid.scroll_down(Line(0)..Line(10), Line(2)); + + info!("grid: {:?}", grid); + + let mut other = Grid::new(Line(10), Column(1), &9); + + other[Line(0)][Column(0)] = 8; + other[Line(1)][Column(0)] = 9; + other[Line(2)][Column(0)] = 0; + other[Line(3)][Column(0)] = 1; + other[Line(4)][Column(0)] = 2; + other[Line(5)][Column(0)] = 3; + other[Line(6)][Column(0)] = 4; + other[Line(7)][Column(0)] = 5; + other[Line(8)][Column(0)] = 6; + other[Line(9)][Column(0)] = 7; + + for i in 0..10 { + assert_eq!(grid[Line(i)][Column(0)], other[Line(i)][Column(0)]); + } +} + +// Test that GridIterator works +#[test] +fn test_iter() { + info!(""); + + let mut grid = Grid::new(Line(5), Column(5), &0); + for i in 0..5 { + for j in 0..5 { + grid[Line(i)][Column(j)] = i*5 + j; + } + } + + info!("grid: {:?}", grid); + + let mut iter = grid.iter_from(Point { + line: Line(0), + col: Column(0), + }); + + assert_eq!(None, iter.prev()); + assert_eq!(Some(&1), iter.next()); + assert_eq!(Column(1), iter.cur.col); + assert_eq!(Line(0), iter.cur.line); + + assert_eq!(Some(&2), iter.next()); + assert_eq!(Some(&3), iter.next()); + assert_eq!(Some(&4), iter.next()); + + // test linewrapping + assert_eq!(Some(&5), iter.next()); + assert_eq!(Column(0), iter.cur.col); + assert_eq!(Line(1), iter.cur.line); + + assert_eq!(Some(&4), iter.prev()); + assert_eq!(Column(4), iter.cur.col); + assert_eq!(Line(0), iter.cur.line); + + + // test that iter ends at end of grid + let mut final_iter = grid.iter_from(Point { + line: Line(4), + col: Column(4), + }); + assert_eq!(None, final_iter.next()); + assert_eq!(Some(&23), final_iter.prev()); +} -- cgit v1.2.3-54-g00ecf