1use core::ops::{Add, AddAssign, Sub, SubAssign};
2
3// Similar to machine_index_t in harfbuzz, but Rust specific.
4#[derive(Debug)]
5pub struct MachineCursor<'a, T, F> {
6 data: &'a [T],
7 pred: F,
8 pos: usize,
9}
10
11impl<'a, T, F> MachineCursor<'a, T, F>
12where
13 F: Fn(&[T], usize) -> bool,
14{
15 pub fn new(data: &'a [T], pred: F) -> Self {
16 let pos = (0..data.len())
17 .find(|i| pred(data, *i))
18 .unwrap_or(data.len());
19 Self { data, pred, pos }
20 }
21
22 fn advance1(&mut self) {
23 self.pos = (self.pos + 1..self.data.len())
24 .find(|q| (self.pred)(self.data, *q))
25 .unwrap_or(self.data.len());
26 }
27
28 fn recede1(&mut self) {
29 self.pos = (0..self.pos)
30 .rev()
31 .find(|q| (self.pred)(self.data, *q))
32 .unwrap_or(0);
33 }
34
35 pub fn index(&self) -> usize {
36 self.pos
37 }
38
39 pub fn end(&self) -> Self
40 where
41 F: Clone,
42 {
43 Self {
44 data: self.data,
45 pred: self.pred.clone(),
46 pos: self.data.len(),
47 }
48 }
49}
50
51impl<'a, T, F> Add<usize> for MachineCursor<'a, T, F>
52where
53 F: Fn(&[T], usize) -> bool,
54{
55 type Output = Self;
56
57 fn add(mut self, rhs: usize) -> Self::Output {
58 for _ in 0..rhs {
59 self.advance1();
60 }
61 self
62 }
63}
64
65impl<'a, T, F> Sub<usize> for MachineCursor<'a, T, F>
66where
67 F: Fn(&[T], usize) -> bool,
68{
69 type Output = Self;
70
71 fn sub(mut self, rhs: usize) -> Self::Output {
72 for _ in 0..rhs {
73 self.recede1();
74 }
75 self
76 }
77}
78
79impl<'a, T, F> AddAssign<usize> for MachineCursor<'a, T, F>
80where
81 F: Fn(&[T], usize) -> bool,
82{
83 fn add_assign(&mut self, rhs: usize) {
84 for _ in 0..rhs {
85 self.advance1();
86 }
87 }
88}
89
90impl<'a, T, F> SubAssign<usize> for MachineCursor<'a, T, F>
91where
92 F: Fn(&[T], usize) -> bool,
93{
94 fn sub_assign(&mut self, rhs: usize) {
95 for _ in 0..rhs {
96 self.recede1();
97 }
98 }
99}
100
101impl<'a, T, F> PartialEq for MachineCursor<'a, T, F> {
102 fn eq(&self, other: &Self) -> bool {
103 self.pos == other.pos
104 }
105}
106
107impl<'a, T, F> Clone for MachineCursor<'a, T, F>
108where
109 F: Clone,
110{
111 fn clone(&self) -> Self {
112 Self {
113 data: self.data,
114 pred: self.pred.clone(),
115 pos: self.pos,
116 }
117 }
118}
119
120impl<'a, T, F> Copy for MachineCursor<'a, T, F> where F: Copy {}
121