2016-07-04 04:05:28 +00:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
//! Line and Column newtypes for strongly typed tty/grid/terminal APIs
|
|
|
|
|
|
|
|
/// Indexing types and implementations for Grid and Line
|
2016-12-22 18:43:06 +00:00
|
|
|
use std::cmp::{Ord, Ordering};
|
2016-07-04 04:05:28 +00:00
|
|
|
use std::fmt;
|
2019-03-19 19:14:17 +00:00
|
|
|
use std::ops::{self, Deref, Range, RangeInclusive, Add, Sub, AddAssign, SubAssign};
|
|
|
|
|
|
|
|
use crate::grid::BidirectionalIterator;
|
2016-07-04 04:05:28 +00:00
|
|
|
|
2016-12-22 18:43:06 +00:00
|
|
|
/// The side of a cell
|
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
|
|
pub enum Side {
|
|
|
|
Left,
|
|
|
|
Right
|
|
|
|
}
|
|
|
|
|
2016-07-04 04:05:28 +00:00
|
|
|
/// Index in the grid using row, column notation
|
2016-12-22 18:43:06 +00:00
|
|
|
#[derive(Debug, Clone, Copy, Default, Eq, PartialEq, Serialize, Deserialize, PartialOrd)]
|
2018-03-07 04:57:40 +00:00
|
|
|
pub struct Point<L=Line> {
|
|
|
|
pub line: L,
|
2016-12-22 18:43:06 +00:00
|
|
|
pub col: Column,
|
|
|
|
}
|
|
|
|
|
2018-03-07 04:57:40 +00:00
|
|
|
impl<L> Point<L> {
|
|
|
|
pub fn new(line: L, col: Column) -> Point<L> {
|
2018-03-04 22:40:15 +00:00
|
|
|
Point { line, col }
|
2016-12-22 18:43:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-29 16:09:29 +00:00
|
|
|
impl Ord for Point {
|
|
|
|
fn cmp(&self, other: &Point) -> Ordering {
|
2016-12-22 18:43:06 +00:00
|
|
|
use std::cmp::Ordering::*;
|
|
|
|
match (self.line.cmp(&other.line), self.col.cmp(&other.col)) {
|
|
|
|
(Equal, Equal) => Equal,
|
2017-01-07 04:44:51 +00:00
|
|
|
(Equal, ord) |
|
2016-12-22 18:43:06 +00:00
|
|
|
(ord, Equal) => ord,
|
|
|
|
(Less, _) => Less,
|
|
|
|
(Greater, _) => Greater,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-20 22:30:59 +00:00
|
|
|
impl From<Point<usize>> for Point<isize> {
|
|
|
|
fn from(point: Point<usize>) -> Self {
|
|
|
|
Point::new(point.line as isize, point.col)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<Point<isize>> for Point<usize> {
|
|
|
|
fn from(point: Point<isize>) -> Self {
|
|
|
|
Point::new(point.line as usize, point.col)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-22 19:39:26 +00:00
|
|
|
impl From<Point> for Point<usize> {
|
|
|
|
fn from(point: Point) -> Self {
|
|
|
|
Point::new(point.line.0, point.col)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-19 19:14:17 +00:00
|
|
|
impl<T> Point<T>
|
|
|
|
where
|
|
|
|
T: Copy + Default + SubAssign<usize> + PartialEq,
|
|
|
|
{
|
|
|
|
pub fn iter(&self, last_col: Column, last_line: T) -> PointIterator<T> {
|
|
|
|
PointIterator {
|
|
|
|
cur: *self,
|
|
|
|
last_col,
|
|
|
|
last_line,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct PointIterator<T> {
|
|
|
|
pub cur: Point<T>,
|
|
|
|
last_col: Column,
|
|
|
|
last_line: T,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> Iterator for PointIterator<T>
|
|
|
|
where
|
|
|
|
T: Copy + Default + SubAssign<usize> + PartialEq,
|
|
|
|
{
|
|
|
|
type Item = Point<T>;
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
|
|
match self.cur {
|
|
|
|
Point { line, col } if line == Default::default() && col == self.last_col => None,
|
|
|
|
Point { col, .. } if col == self.last_col => {
|
|
|
|
self.cur.line -= 1;
|
|
|
|
self.cur.col = Column(0);
|
|
|
|
Some(self.cur)
|
|
|
|
},
|
|
|
|
_ => {
|
|
|
|
self.cur.col += Column(1);
|
|
|
|
Some(self.cur)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> BidirectionalIterator for PointIterator<T>
|
|
|
|
where
|
|
|
|
T: Copy + Default + AddAssign<usize> + SubAssign<usize> + PartialEq,
|
|
|
|
{
|
|
|
|
fn prev(&mut self) -> Option<Self::Item> {
|
|
|
|
match self.cur {
|
|
|
|
Point { line, col: Column(0) } if line == self.last_line => None,
|
|
|
|
Point { col: Column(0), .. } => {
|
|
|
|
self.cur.line += 1;
|
|
|
|
self.cur.col = self.last_col;
|
|
|
|
Some(self.cur)
|
|
|
|
},
|
|
|
|
_ => {
|
|
|
|
self.cur.col -= Column(1);
|
|
|
|
Some(self.cur)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-04 04:05:28 +00:00
|
|
|
/// A line
|
|
|
|
///
|
|
|
|
/// Newtype to avoid passing values incorrectly
|
2016-11-20 00:16:20 +00:00
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd, Serialize, Deserialize)]
|
2016-07-04 04:05:28 +00:00
|
|
|
pub struct Line(pub usize);
|
|
|
|
|
|
|
|
impl fmt::Display for Line {
|
2018-12-10 17:53:56 +00:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
2017-01-02 02:28:49 +00:00
|
|
|
write!(f, "{}", self.0)
|
2016-07-04 04:05:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// A column
|
|
|
|
///
|
|
|
|
/// Newtype to avoid passing values incorrectly
|
2016-11-20 00:16:20 +00:00
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd, Serialize, Deserialize)]
|
2016-07-04 04:05:28 +00:00
|
|
|
pub struct Column(pub usize);
|
|
|
|
|
|
|
|
impl fmt::Display for Column {
|
2018-12-10 17:53:56 +00:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
2017-01-02 02:28:49 +00:00
|
|
|
write!(f, "{}", self.0)
|
2016-07-04 04:05:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-22 18:43:06 +00:00
|
|
|
/// A linear index
|
|
|
|
///
|
|
|
|
/// Newtype to avoid passing values incorrectly
|
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd, Serialize, Deserialize)]
|
|
|
|
pub struct Linear(pub usize);
|
|
|
|
|
|
|
|
impl fmt::Display for Linear {
|
2018-12-10 17:53:56 +00:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
2016-12-22 18:43:06 +00:00
|
|
|
write!(f, "Linear({})", self.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-06 01:42:55 +00:00
|
|
|
// 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
|
2016-07-04 04:05:28 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
2016-08-22 15:37:50 +00:00
|
|
|
|
|
|
|
impl<'a> ops::Sub<$ty> for &'a $ty {
|
|
|
|
type Output = $ty;
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn sub(self, rhs: $ty) -> $ty {
|
|
|
|
$construct(self.0 - rhs.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> ops::Sub<&'a $ty> for $ty {
|
|
|
|
type Output = $ty;
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn sub(self, rhs: &'a $ty) -> $ty {
|
|
|
|
$construct(self.0 - rhs.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, 'b> ops::Sub<&'a $ty> for &'b $ty {
|
|
|
|
type Output = $ty;
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn sub(self, rhs: &'a $ty) -> $ty {
|
|
|
|
$construct(self.0 - rhs.0)
|
|
|
|
}
|
|
|
|
}
|
2016-07-04 04:05:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-06 23:25:04 +00:00
|
|
|
/// 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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-07 00:26:31 +00:00
|
|
|
// can be removed if range_contains is stabilized
|
2017-01-06 23:48:23 +00:00
|
|
|
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 {
|
2019-03-17 21:09:27 +00:00
|
|
|
(self.start() <= &item) && (&item <= self.end())
|
2017-01-06 23:48:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-04 04:05:28 +00:00
|
|
|
macro_rules! ops {
|
|
|
|
($ty:ty, $construct:expr) => {
|
|
|
|
add!($ty, $construct);
|
|
|
|
sub!($ty, $construct);
|
|
|
|
deref!($ty, usize);
|
|
|
|
forward_ref_binop!(impl Add, add for $ty, $ty);
|
|
|
|
|
2017-01-06 23:25:04 +00:00
|
|
|
impl $ty {
|
2016-07-04 04:05:28 +00:00
|
|
|
#[inline]
|
2018-07-21 17:17:41 +00:00
|
|
|
fn steps_between(start: $ty, end: $ty, by: $ty) -> Option<usize> {
|
|
|
|
if by == $construct(0) { return None; }
|
|
|
|
if start < end {
|
2016-07-04 04:05:28 +00:00
|
|
|
// Note: We assume $t <= usize here
|
2018-07-21 17:17:41 +00:00
|
|
|
let diff = (end - start).0;
|
2016-07-04 04:05:28 +00:00
|
|
|
let by = by.0;
|
|
|
|
if diff % by > 0 {
|
|
|
|
Some(diff / by + 1)
|
|
|
|
} else {
|
|
|
|
Some(diff / by)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Some(0)
|
|
|
|
}
|
|
|
|
}
|
2016-07-15 14:55:44 +00:00
|
|
|
|
|
|
|
#[inline]
|
2018-07-21 17:17:41 +00:00
|
|
|
fn steps_between_by_one(start: $ty, end: $ty) -> Option<usize> {
|
|
|
|
Self::steps_between(start, end, $construct(1))
|
2016-07-15 14:55:44 +00:00
|
|
|
}
|
2017-01-06 23:25:04 +00:00
|
|
|
}
|
2016-07-15 14:55:44 +00:00
|
|
|
|
2017-01-06 23:25:04 +00:00
|
|
|
impl Iterator for IndexRange<$ty> {
|
|
|
|
type Item = $ty;
|
2016-07-15 14:55:44 +00:00
|
|
|
#[inline]
|
2017-01-06 23:25:04 +00:00
|
|
|
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
|
|
|
|
}
|
2016-07-15 14:55:44 +00:00
|
|
|
}
|
|
|
|
#[inline]
|
2017-01-06 23:25:04 +00:00
|
|
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
2018-07-21 17:17:41 +00:00
|
|
|
match Self::Item::steps_between_by_one(self.0.start, self.0.end) {
|
2017-01-06 23:25:04 +00:00
|
|
|
Some(hint) => (hint, Some(hint)),
|
|
|
|
None => (0, None)
|
|
|
|
}
|
2016-07-15 14:55:44 +00:00
|
|
|
}
|
2017-01-06 23:25:04 +00:00
|
|
|
}
|
2016-07-15 14:55:44 +00:00
|
|
|
|
2017-01-06 23:25:04 +00:00
|
|
|
impl DoubleEndedIterator for IndexRange<$ty> {
|
2016-07-15 14:55:44 +00:00
|
|
|
#[inline]
|
2017-01-06 23:25:04 +00:00
|
|
|
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
|
|
|
|
}
|
2016-07-15 14:55:44 +00:00
|
|
|
}
|
2016-07-04 04:05:28 +00:00
|
|
|
}
|
2019-03-19 19:14:17 +00:00
|
|
|
impl AddAssign<$ty> for $ty {
|
2016-07-04 04:05:28 +00:00
|
|
|
#[inline]
|
|
|
|
fn add_assign(&mut self, rhs: $ty) {
|
|
|
|
self.0 += rhs.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-19 19:14:17 +00:00
|
|
|
impl SubAssign<$ty> for $ty {
|
2016-07-04 04:05:28 +00:00
|
|
|
#[inline]
|
|
|
|
fn sub_assign(&mut self, rhs: $ty) {
|
|
|
|
self.0 -= rhs.0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-19 19:14:17 +00:00
|
|
|
impl AddAssign<usize> for $ty {
|
2016-07-04 04:05:28 +00:00
|
|
|
#[inline]
|
|
|
|
fn add_assign(&mut self, rhs: usize) {
|
|
|
|
self.0 += rhs
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-19 19:14:17 +00:00
|
|
|
impl SubAssign<usize> for $ty {
|
2016-07-04 04:05:28 +00:00
|
|
|
#[inline]
|
|
|
|
fn sub_assign(&mut self, rhs: usize) {
|
|
|
|
self.0 -= rhs
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<usize> for $ty {
|
|
|
|
#[inline]
|
|
|
|
fn from(val: usize) -> $ty {
|
|
|
|
$construct(val)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-19 19:14:17 +00:00
|
|
|
impl Add<usize> for $ty {
|
2016-07-04 04:05:28 +00:00
|
|
|
type Output = $ty;
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn add(self, rhs: usize) -> $ty {
|
|
|
|
$construct(self.0 + rhs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-19 19:14:17 +00:00
|
|
|
impl Sub<usize> for $ty {
|
2016-07-04 04:05:28 +00:00
|
|
|
type Output = $ty;
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn sub(self, rhs: usize) -> $ty {
|
|
|
|
$construct(self.0 - rhs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ops!(Line, Line);
|
|
|
|
ops!(Column, Column);
|
2016-12-22 18:43:06 +00:00
|
|
|
ops!(Linear, Linear);
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2016-12-29 16:09:29 +00:00
|
|
|
use super::{Line, Column, Point};
|
2016-12-22 18:43:06 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn location_ordering() {
|
2016-12-29 16:09:29 +00:00
|
|
|
assert!(Point::new(Line(0), Column(0)) == Point::new(Line(0), Column(0)));
|
|
|
|
assert!(Point::new(Line(1), Column(0)) > Point::new(Line(0), Column(0)));
|
|
|
|
assert!(Point::new(Line(0), Column(1)) > Point::new(Line(0), Column(0)));
|
|
|
|
assert!(Point::new(Line(1), Column(1)) > Point::new(Line(0), Column(0)));
|
|
|
|
assert!(Point::new(Line(1), Column(1)) > Point::new(Line(0), Column(1)));
|
|
|
|
assert!(Point::new(Line(1), Column(1)) > Point::new(Line(1), Column(0)));
|
2016-12-22 18:43:06 +00:00
|
|
|
}
|
|
|
|
}
|