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.

1 files changed, 1 insertions, 229 deletions

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 <LICENSE-APACHE or
-    /// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-    /// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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<usize> {
-                    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<usize> for $ty {
-                #[inline]
-                fn add_assign(&mut self, rhs: usize) {
-                    self.0 += rhs
-                }
-            }
-
-            impl ops::SubAssign<usize> for $ty {
-                #[inline]
-                fn sub_assign(&mut self, rhs: usize) {
-                    self.0 -= rhs
-                }
-            }
-
-            impl From<usize> for $ty {
-                #[inline]
-                fn from(val: usize) -> $ty {
-                    $construct(val)
-                }
-            }
-
-            impl ops::Add<usize> for $ty {
-                type Output = $ty;
-
-                #[inline]
-                fn add(self, rhs: usize) -> $ty {
-                    $construct(self.0 + rhs)
-                }
-            }
-
-            impl ops::Sub<usize> 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)]