diff options
Diffstat (limited to 'src/index.rs')
| -rw-r--r-- | src/index.rs | 182 |
1 files changed, 153 insertions, 29 deletions
diff --git a/src/index.rs b/src/index.rs index c80589da..25d5eaff 100644 --- a/src/index.rs +++ b/src/index.rs @@ -17,9 +17,7 @@ /// Indexing types and implementations for Grid and Line use std::cmp::{Ord, Ordering}; use std::fmt; -use std::iter::Step; -use std::mem; -use std::ops::{self, Deref, Add}; +use std::ops::{self, Deref, Add, Range}; /// The side of a cell #[derive(Debug, Copy, Clone, Eq, PartialEq)] @@ -46,7 +44,7 @@ impl Ord for Point { use std::cmp::Ordering::*; match (self.line.cmp(&other.line), self.col.cmp(&other.col)) { (Equal, Equal) => Equal, - (Equal, ord) => ord, + (Equal, ord) | (ord, Equal) => ord, (Less, _) => Less, (Greater, _) => Greater, @@ -200,6 +198,128 @@ macro_rules! sub { } } +/// This exists because we can't implement Iterator on Range +/// and the existing impl needs the unstable Step trait +/// This should be removed and replaced with a Step impl +/// in the ops macro when `step_by` is stabilized +pub struct IndexRange<T>(pub Range<T>); + +impl<T> From<Range<T>> for IndexRange<T> { + fn from(from: Range<T>) -> Self { + IndexRange(from) + } +} + +pub enum RangeInclusive<Idx> { + Empty { + at: Idx, + }, + NonEmpty { + start: Idx, + end: Idx, + }, +} + +impl<Idx> RangeInclusive<Idx> { + pub fn new(from: Idx, to: Idx) -> Self { + RangeInclusive::NonEmpty { + start: from, + end: to + } + } +} + +macro_rules! inclusive { + ($ty:ty, $steps_add_one:expr) => { + // impl copied from stdlib, can be removed when inclusive_range is stabilized + impl Iterator for RangeInclusive<$ty> { + type Item = $ty; + + #[inline] + fn next(&mut self) -> Option<$ty> { + use index::RangeInclusive::*; + + // this function has a sort of odd structure due to borrowck issues + // we may need to replace self.range, so borrows of start and end need to end early + + let at_end; + match *self { + Empty { .. } => return None, // empty iterators yield no values + + NonEmpty { ref mut start, ref mut end } => { + + // march start towards (maybe past!) end and yield the old value + if start <= end { + let old = *start; + *start = old + 1; + return Some(old); + } + at_end = *end; + } + }; + + // got this far; the range is empty, replace it + *self = Empty { at: at_end }; + None + } + + #[inline] + fn size_hint(&self) -> (usize, Option<usize>) { + use index::RangeInclusive::*; + + match *self { + Empty { .. } => (0, Some(0)), + + NonEmpty { ref start, ref end } => { + let added = $steps_add_one(start, end); + match added { + Some(hint) => (hint.saturating_add(1), hint.checked_add(1)), + None => (0, None) + } + } + } + } + } + } +} + +fn steps_add_one_u8(start: &u8, end: &u8) -> Option<usize> { + if *start < *end { + Some((*end - *start) as usize) + } else { + None + } +} +inclusive!(u8, steps_add_one_u8); + +#[test] +fn test_range() { + assert_eq!(RangeInclusive::new(1,10).collect::<Vec<_>>(), + vec![1,2,3,4,5,6,7,8,9,10]); +} + +// can be removed if range_contains is stabilized +pub trait Contains { + type Content; + fn contains_(&self, item: Self::Content) -> bool; +} + +impl<T: PartialOrd<T>> Contains for Range<T> { + type Content = T; + fn contains_(&self, item: Self::Content) -> bool { + (self.start <= item) && (item < self.end) + } +} + +impl<T: PartialOrd<T>> Contains for RangeInclusive<T> { + type Content = T; + fn contains_(&self, item: Self::Content) -> bool { + if let RangeInclusive::NonEmpty{ref start, ref end} = *self { + (*start <= item) && (item <= *end) + } else { false } + } +} + macro_rules! ops { ($ty:ty, $construct:expr) => { add!($ty, $construct); @@ -207,12 +327,7 @@ macro_rules! ops { deref!($ty, usize); forward_ref_binop!(impl Add, add for $ty, $ty); - impl Step for $ty { - #[inline] - fn step(&self, by: &$ty) -> Option<$ty> { - Some(*self + *by) - } - + impl $ty { #[inline] #[allow(trivial_numeric_casts)] fn steps_between(start: &$ty, end: &$ty, by: &$ty) -> Option<usize> { @@ -233,36 +348,45 @@ macro_rules! ops { #[inline] fn steps_between_by_one(start: &$ty, end: &$ty) -> Option<usize> { - Step::steps_between(start, end, &$construct(1)) - } - - #[inline] - #[allow(unused_comparisons)] - fn is_negative(&self) -> bool { - self.0 < 0 + Self::steps_between(start, end, &$construct(1)) } + } + impl Iterator for IndexRange<$ty> { + type Item = $ty; #[inline] - fn replace_one(&mut self) -> Self { - mem::replace(self, $construct(0)) + fn next(&mut self) -> Option<$ty> { + if self.0.start < self.0.end { + let old = self.0.start; + self.0.start = old + 1; + Some(old) + } else { + None + } } - #[inline] - fn replace_zero(&mut self) -> Self { - mem::replace(self, $construct(1)) + fn size_hint(&self) -> (usize, Option<usize>) { + match Self::Item::steps_between_by_one(&self.0.start, &self.0.end) { + Some(hint) => (hint, Some(hint)), + None => (0, None) + } } + } - #[inline] - fn add_one(&self) -> Self { - *self + 1 - } + inclusive!($ty, <$ty>::steps_between_by_one); + impl DoubleEndedIterator for IndexRange<$ty> { #[inline] - fn sub_one(&self) -> Self { - *self - 1 + fn next_back(&mut self) -> Option<$ty> { + if self.0.start < self.0.end { + let new = self.0.end - 1; + self.0.end = new; + Some(new) + } else { + None + } } } - impl ops::AddAssign<$ty> for $ty { #[inline] fn add_assign(&mut self, rhs: $ty) { |