1use crate::{
2 BufferId, BufferSnapshot, Point, PointUtf16, TextDimension, ToOffset, ToPoint, ToPointUtf16,
3 locator::Locator,
4};
5use std::{cmp::Ordering, fmt::Debug, ops::Range};
6use sum_tree::{Bias, Dimensions};
7
8/// A timestamped position in a buffer.
9#[doc(alias = "TextAnchor")]
10#[derive(Copy, Clone, Eq, PartialEq, Hash)]
11pub struct Anchor {
12 // /// The timestamp of the operation that inserted the text
13 // /// in which this anchor is located.
14 // pub(crate) timestamp: clock::Lamport,
15 // we store the replica id and sequence number of the timestamp inline
16 // to avoid the alignment of our fields from increasing the size of this struct
17 // This saves 8 bytes, by allowing replica id, value and bias to occupy the padding
18 pub(crate) timestamp_replica_id: clock::ReplicaId,
19 pub(crate) timestamp_value: clock::Seq,
20
21 /// The byte offset into the text inserted in the operation
22 /// at `timestamp`.
23 pub offset: u32,
24 /// Whether this anchor stays attached to the character *before* or *after*
25 /// the offset.
26 pub bias: Bias,
27 pub buffer_id: BufferId,
28}
29
30impl Debug for Anchor {
31 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
32 if self.is_min() {
33 return write!(f, "Anchor::min({:?})", self.buffer_id);
34 }
35 if self.is_max() {
36 return write!(f, "Anchor::max({:?})", self.buffer_id);
37 }
38
39 f.debug_struct("Anchor")
40 .field("timestamp", &self.timestamp())
41 .field("offset", &self.offset)
42 .field("bias", &self.bias)
43 .field("buffer_id", &self.buffer_id)
44 .finish()
45 }
46}
47
48impl Anchor {
49 pub fn new(timestamp: clock::Lamport, offset: u32, bias: Bias, buffer_id: BufferId) -> Self {
50 Self {
51 timestamp_replica_id: timestamp.replica_id,
52 timestamp_value: timestamp.value,
53 offset,
54 bias,
55 buffer_id,
56 }
57 }
58
59 pub fn min_for_buffer(buffer_id: BufferId) -> Self {
60 Self {
61 timestamp_replica_id: clock::Lamport::MIN.replica_id,
62 timestamp_value: clock::Lamport::MIN.value,
63 offset: u32::MIN,
64 bias: Bias::Left,
65 buffer_id,
66 }
67 }
68
69 pub fn max_for_buffer(buffer_id: BufferId) -> Self {
70 Self {
71 timestamp_replica_id: clock::Lamport::MAX.replica_id,
72 timestamp_value: clock::Lamport::MAX.value,
73 offset: u32::MAX,
74 bias: Bias::Right,
75 buffer_id,
76 }
77 }
78
79 pub fn min_min_range_for_buffer(buffer_id: BufferId) -> std::ops::Range<Self> {
80 let min = Self::min_for_buffer(buffer_id);
81 min..min
82 }
83 pub fn max_max_range_for_buffer(buffer_id: BufferId) -> std::ops::Range<Self> {
84 let max = Self::max_for_buffer(buffer_id);
85 max..max
86 }
87 pub fn min_max_range_for_buffer(buffer_id: BufferId) -> std::ops::Range<Self> {
88 Self::min_for_buffer(buffer_id)..Self::max_for_buffer(buffer_id)
89 }
90
91 pub fn cmp(&self, other: &Anchor, buffer: &BufferSnapshot) -> Ordering {
92 let fragment_id_comparison = if self.timestamp() == other.timestamp() {
93 Ordering::Equal
94 } else {
95 buffer
96 .fragment_id_for_anchor(self)
97 .cmp(buffer.fragment_id_for_anchor(other))
98 };
99
100 fragment_id_comparison
101 .then_with(|| self.offset.cmp(&other.offset))
102 .then_with(|| self.bias.cmp(&other.bias))
103 }
104
105 pub fn min<'a>(&'a self, other: &'a Self, buffer: &BufferSnapshot) -> &'a Self {
106 if self.cmp(other, buffer).is_le() {
107 self
108 } else {
109 other
110 }
111 }
112
113 pub fn max<'a>(&'a self, other: &'a Self, buffer: &BufferSnapshot) -> &'a Self {
114 if self.cmp(other, buffer).is_ge() {
115 self
116 } else {
117 other
118 }
119 }
120
121 pub fn bias(&self, bias: Bias, buffer: &BufferSnapshot) -> Anchor {
122 match bias {
123 Bias::Left => self.bias_left(buffer),
124 Bias::Right => self.bias_right(buffer),
125 }
126 }
127
128 pub fn bias_left(&self, buffer: &BufferSnapshot) -> Anchor {
129 match self.bias {
130 Bias::Left => *self,
131 Bias::Right => buffer.anchor_before(self),
132 }
133 }
134
135 pub fn bias_right(&self, buffer: &BufferSnapshot) -> Anchor {
136 match self.bias {
137 Bias::Left => buffer.anchor_after(self),
138 Bias::Right => *self,
139 }
140 }
141
142 pub fn summary<D>(&self, content: &BufferSnapshot) -> D
143 where
144 D: TextDimension,
145 {
146 content.summary_for_anchor(self)
147 }
148
149 /// Returns true when the [`Anchor`] is located inside a visible fragment.
150 pub fn is_valid(&self, buffer: &BufferSnapshot) -> bool {
151 if self.is_min() || self.is_max() {
152 true
153 } else if self.buffer_id != buffer.remote_id {
154 false
155 } else {
156 let Some(fragment_id) = buffer.try_fragment_id_for_anchor(self) else {
157 return false;
158 };
159 let (.., item) = buffer
160 .fragments
161 .find::<Dimensions<Option<&Locator>, usize>, _>(
162 &None,
163 &Some(fragment_id),
164 Bias::Left,
165 );
166 item.is_some_and(|fragment| fragment.visible)
167 }
168 }
169
170 pub fn is_min(&self) -> bool {
171 self.timestamp() == clock::Lamport::MIN
172 && self.offset == u32::MIN
173 && self.bias == Bias::Left
174 }
175
176 pub fn is_max(&self) -> bool {
177 self.timestamp() == clock::Lamport::MAX
178 && self.offset == u32::MAX
179 && self.bias == Bias::Right
180 }
181
182 #[inline]
183 pub fn timestamp(&self) -> clock::Lamport {
184 clock::Lamport {
185 replica_id: self.timestamp_replica_id,
186 value: self.timestamp_value,
187 }
188 }
189
190 pub fn opaque_id(&self) -> [u8; 20] {
191 let mut bytes = [0u8; 20];
192 let buffer_id: u64 = self.buffer_id.into();
193 bytes[0..8].copy_from_slice(&buffer_id.to_le_bytes());
194 bytes[8..12].copy_from_slice(&self.offset.to_le_bytes());
195 bytes[12..16].copy_from_slice(&self.timestamp_value.to_le_bytes());
196 let replica_id = self.timestamp_replica_id.as_u16();
197 bytes[16..18].copy_from_slice(&replica_id.to_le_bytes());
198 bytes[18] = self.bias as u8;
199 bytes
200 }
201}
202
203pub trait OffsetRangeExt {
204 fn to_offset(&self, snapshot: &BufferSnapshot) -> Range<usize>;
205 fn to_point(&self, snapshot: &BufferSnapshot) -> Range<Point>;
206 fn to_point_utf16(&self, snapshot: &BufferSnapshot) -> Range<PointUtf16>;
207}
208
209impl<T> OffsetRangeExt for Range<T>
210where
211 T: ToOffset,
212{
213 fn to_offset(&self, snapshot: &BufferSnapshot) -> Range<usize> {
214 self.start.to_offset(snapshot)..self.end.to_offset(snapshot)
215 }
216
217 fn to_point(&self, snapshot: &BufferSnapshot) -> Range<Point> {
218 self.start.to_offset(snapshot).to_point(snapshot)
219 ..self.end.to_offset(snapshot).to_point(snapshot)
220 }
221
222 fn to_point_utf16(&self, snapshot: &BufferSnapshot) -> Range<PointUtf16> {
223 self.start.to_offset(snapshot).to_point_utf16(snapshot)
224 ..self.end.to_offset(snapshot).to_point_utf16(snapshot)
225 }
226}
227
228pub trait AnchorRangeExt {
229 fn cmp(&self, b: &Range<Anchor>, buffer: &BufferSnapshot) -> Ordering;
230 fn overlaps(&self, b: &Range<Anchor>, buffer: &BufferSnapshot) -> bool;
231 fn contains_anchor(&self, b: Anchor, buffer: &BufferSnapshot) -> bool;
232}
233
234impl AnchorRangeExt for Range<Anchor> {
235 fn cmp(&self, other: &Range<Anchor>, buffer: &BufferSnapshot) -> Ordering {
236 match self.start.cmp(&other.start, buffer) {
237 Ordering::Equal => other.end.cmp(&self.end, buffer),
238 ord => ord,
239 }
240 }
241
242 fn overlaps(&self, other: &Range<Anchor>, buffer: &BufferSnapshot) -> bool {
243 self.start.cmp(&other.end, buffer).is_lt() && other.start.cmp(&self.end, buffer).is_lt()
244 }
245
246 fn contains_anchor(&self, other: Anchor, buffer: &BufferSnapshot) -> bool {
247 self.start.cmp(&other, buffer).is_le() && self.end.cmp(&other, buffer).is_ge()
248 }
249}