From 6639e6f24fab269f23392b11e566ef0a29ca163b Mon Sep 17 00:00:00 2001 From: Joe Wilm Date: Sun, 3 Jul 2016 21:05:28 -0700 Subject: Move ::grid::index to ::index The grid and term modules already rely on the index types, and ansi is about to be updated with strongly typed APIs. Since Cursor, Line, and Column are fundamental to the code in several modules, namespacing them under one of them seems less correct than a module that stands by itself. --- src/grid.rs | 230 +----------------------------------------------------------- 1 file changed, 1 insertion(+), 229 deletions(-) (limited to 'src/grid.rs') diff --git a/src/grid.rs b/src/grid.rs index 37c9dee6..b47be7ca 100644 --- a/src/grid.rs +++ b/src/grid.rs @@ -28,235 +28,7 @@ use std::borrow::ToOwned; use util::Rotate; -/// Indexing types and implementations for Grid and Line -pub mod index { - use std::fmt; - use std::iter::Step; - use std::num::{One, Zero}; - use std::ops::{self, Deref, Add}; - - /// Index in the grid using row, column notation - #[derive(Debug, Clone, Default, Eq, PartialEq)] - pub struct Cursor { - pub line: Line, - pub col: Column, - } - - /// A line - /// - /// Newtype to avoid passing values incorrectly - #[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd)] - pub struct Line(pub usize); - - impl fmt::Display for Line { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Line({})", self.0) - } - } - - /// A column - /// - /// Newtype to avoid passing values incorrectly - #[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd)] - pub struct Column(pub usize); - - impl fmt::Display for Column { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Column({})", self.0) - } - } - - /// Copyright 2015 The Rust Project Developers. See the COPYRIGHT - /// file at the top-level directory of this distribution and at - /// http://rust-lang.org/COPYRIGHT. - /// - /// Licensed under the Apache License, Version 2.0 or the MIT license - /// , at your - /// option. This file may not be copied, modified, or distributed - /// except according to those terms. - /// - /// implements binary operators "&T op U", "T op &U", "&T op &U" - /// based on "T op U" where T and U are expected to be `Copy`able - macro_rules! forward_ref_binop { - (impl $imp:ident, $method:ident for $t:ty, $u:ty) => { - impl<'a> $imp<$u> for &'a $t { - type Output = <$t as $imp<$u>>::Output; - - #[inline] - fn $method(self, other: $u) -> <$t as $imp<$u>>::Output { - $imp::$method(*self, other) - } - } - - impl<'a> $imp<&'a $u> for $t { - type Output = <$t as $imp<$u>>::Output; - - #[inline] - fn $method(self, other: &'a $u) -> <$t as $imp<$u>>::Output { - $imp::$method(self, *other) - } - } - - impl<'a, 'b> $imp<&'a $u> for &'b $t { - type Output = <$t as $imp<$u>>::Output; - - #[inline] - fn $method(self, other: &'a $u) -> <$t as $imp<$u>>::Output { - $imp::$method(*self, *other) - } - } - } - } - - /// Macro for deriving deref - macro_rules! deref { - ($ty:ty, $target:ty) => { - impl Deref for $ty { - type Target = $target; - - #[inline] - fn deref(&self) -> &$target { - &self.0 - } - } - } - } - - macro_rules! add { - ($ty:ty, $construct:expr) => { - impl ops::Add<$ty> for $ty { - type Output = $ty; - - #[inline] - fn add(self, rhs: $ty) -> $ty { - $construct(self.0 + rhs.0) - } - } - } - } - - macro_rules! sub { - ($ty:ty, $construct:expr) => { - impl ops::Sub<$ty> for $ty { - type Output = $ty; - - #[inline] - fn sub(self, rhs: $ty) -> $ty { - $construct(self.0 - rhs.0) - } - } - } - } - - macro_rules! zero_one { - ($ty:ty, $construct:expr) => { - impl One for $ty { - fn one() -> $ty { - $construct(1) - } - } - - impl Zero for $ty { - fn zero() -> $ty { - $construct(0) - } - } - } - } - - macro_rules! ops { - ($ty:ty, $construct:expr) => { - add!($ty, $construct); - sub!($ty, $construct); - zero_one!($ty, $construct); - deref!($ty, usize); - forward_ref_binop!(impl Add, add for $ty, $ty); - - impl Step for $ty { - fn step(&self, by: &$ty) -> Option<$ty> { - Some(*self + *by) - } - - #[inline] - #[allow(trivial_numeric_casts)] - fn steps_between(start: &$ty, end: &$ty, by: &$ty) -> Option { - if *by == $construct(0) { return None; } - if *start < *end { - // Note: We assume $t <= usize here - let diff = (*end - *start).0; - let by = by.0; - if diff % by > 0 { - Some(diff / by + 1) - } else { - Some(diff / by) - } - } else { - Some(0) - } - } - } - - impl ops::AddAssign<$ty> for $ty { - #[inline] - fn add_assign(&mut self, rhs: $ty) { - self.0 += rhs.0 - } - } - - impl ops::SubAssign<$ty> for $ty { - #[inline] - fn sub_assign(&mut self, rhs: $ty) { - self.0 -= rhs.0 - } - } - - impl ops::AddAssign for $ty { - #[inline] - fn add_assign(&mut self, rhs: usize) { - self.0 += rhs - } - } - - impl ops::SubAssign for $ty { - #[inline] - fn sub_assign(&mut self, rhs: usize) { - self.0 -= rhs - } - } - - impl From for $ty { - #[inline] - fn from(val: usize) -> $ty { - $construct(val) - } - } - - impl ops::Add for $ty { - type Output = $ty; - - #[inline] - fn add(self, rhs: usize) -> $ty { - $construct(self.0 + rhs) - } - } - - impl ops::Sub for $ty { - type Output = $ty; - - #[inline] - fn sub(self, rhs: usize) -> $ty { - $construct(self.0 - rhs) - } - } - } - } - - ops!(Line, Line); - ops!(Column, Column); -} - -use self::index::Cursor; +use index::{self, Cursor}; /// Represents the terminal display contents #[derive(Clone)] -- cgit