tenant.openagents/omega

1use std::{
2    cmp::Ordering,
3    fmt::{self, Debug},
4    ops::{Add, AddAssign, Range, Sub},
5};
6
7/// A zero-indexed point in a text buffer consisting of a row and column.
8#[derive(Clone, Copy, Default, Eq, PartialEq, Hash)]
9pub struct Point {
10    pub row: u32,
11    pub column: u32,
12}
13
14impl Debug for Point {
15    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16        write!(f, "Point({}:{})", self.row, self.column)
17    }
18}
19
20impl Point {
21    pub const MAX: Self = Self {
22        row: u32::MAX,
23        column: u32::MAX,
24    };
25
26    pub fn new(row: u32, column: u32) -> Self {
27        Point { row, column }
28    }
29
30    pub fn row_range(range: Range<u32>) -> Range<Self> {
31        Point {
32            row: range.start,
33            column: 0,
34        }..Point {
35            row: range.end,
36            column: 0,
37        }
38    }
39
40    pub fn zero() -> Self {
41        Point::new(0, 0)
42    }
43
44    pub fn parse_str(s: &str) -> Self {
45        let mut point = Self::zero();
46        for (row, line) in s.split('\n').enumerate() {
47            point.row = row as u32;
48            point.column = line.len() as u32;
49        }
50        point
51    }
52
53    pub fn is_zero(&self) -> bool {
54        self.row == 0 && self.column == 0
55    }
56
57    pub fn saturating_sub(self, other: Self) -> Self {
58        if self < other {
59            Self::zero()
60        } else {
61            self - other
62        }
63    }
64}
65
66impl<'a> Add<&'a Self> for Point {
67    type Output = Point;
68
69    fn add(self, other: &'a Self) -> Self::Output {
70        self + *other
71    }
72}
73
74impl Add for Point {
75    type Output = Point;
76
77    fn add(self, other: Self) -> Self::Output {
78        if other.row == 0 {
79            Point::new(self.row, self.column + other.column)
80        } else {
81            Point::new(self.row + other.row, other.column)
82        }
83    }
84}
85
86impl<'a> Sub<&'a Self> for Point {
87    type Output = Point;
88
89    fn sub(self, other: &'a Self) -> Self::Output {
90        self - *other
91    }
92}
93
94impl Sub for Point {
95    type Output = Point;
96
97    fn sub(self, other: Self) -> Self::Output {
98        debug_assert!(other <= self);
99
100        if self.row == other.row {
101            Point::new(0, self.column - other.column)
102        } else {
103            Point::new(self.row - other.row, self.column)
104        }
105    }
106}
107
108impl<'a> AddAssign<&'a Self> for Point {
109    fn add_assign(&mut self, other: &'a Self) {
110        *self += *other;
111    }
112}
113
114impl AddAssign<Self> for Point {
115    fn add_assign(&mut self, other: Self) {
116        if other.row == 0 {
117            self.column += other.column;
118        } else {
119            self.row += other.row;
120            self.column = other.column;
121        }
122    }
123}
124
125impl PartialOrd for Point {
126    fn partial_cmp(&self, other: &Point) -> Option<Ordering> {
127        Some(self.cmp(other))
128    }
129}
130
131impl Ord for Point {
132    #[cfg(target_pointer_width = "64")]
133    fn cmp(&self, other: &Point) -> Ordering {
134        let a = ((self.row as usize) << 32) | self.column as usize;
135        let b = ((other.row as usize) << 32) | other.column as usize;
136        a.cmp(&b)
137    }
138
139    #[cfg(target_pointer_width = "32")]
140    fn cmp(&self, other: &Point) -> Ordering {
141        match self.row.cmp(&other.row) {
142            Ordering::Equal => self.column.cmp(&other.column),
143            comparison @ _ => comparison,
144        }
145    }
146}
147