1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
use std::{borrow::Cow, collections::HashMap, iter};
use anyhow::Result;
use crate::Editor;
/// A key-value store for saving sets of values.
///
/// Each register corresponds to a `char`. Most chars can be used to store any set of
/// values but a few chars are "special registers". Special registers have unique
/// behaviors when read or written to:
///
/// * Black hole (`_`): all values read and written are discarded
/// * Selection indices (`#`): index number of each selection starting at 1
/// * Selection contents (`.`)
#[derive(Debug, Default)]
pub struct Registers {
inner: HashMap<char, Vec<String>>,
}
impl Registers {
pub fn read<'a>(&'a self, name: char, editor: &'a Editor) -> Option<RegisterValues<'a>> {
match name {
'_' => Some(RegisterValues::new(iter::empty())),
'#' => {
let (view, doc) = current_ref!(editor);
let selections = doc.selection(view.id).len();
// ExactSizeIterator is implemented for Range<usize> but
// not RangeInclusive<usize>.
Some(RegisterValues::new(
(0..selections).map(|i| (i + 1).to_string().into()),
))
}
'.' => {
let (view, doc) = current_ref!(editor);
let text = doc.text().slice(..);
Some(RegisterValues::new(doc.selection(view.id).fragments(text)))
}
_ => self
.inner
.get(&name)
.map(|values| RegisterValues::new(values.iter().map(Cow::from))),
}
}
pub fn write(&mut self, name: char, values: Vec<String>) -> Result<()> {
match name {
'_' => Ok(()),
'#' | '.' => Err(anyhow::anyhow!("Register {name} does not support writing")),
_ => {
self.inner.insert(name, values);
Ok(())
}
}
}
pub fn push(&mut self, name: char, value: String) -> Result<()> {
match name {
'_' => Ok(()),
'#' | '.' => Err(anyhow::anyhow!("Register {name} does not support pushing")),
_ => {
self.inner.entry(name).or_insert_with(Vec::new).push(value);
Ok(())
}
}
}
pub fn first<'a>(&'a self, name: char, editor: &'a Editor) -> Option<Cow<'a, str>> {
self.read(name, editor).and_then(|mut values| values.next())
}
pub fn last<'a>(&'a self, name: char, editor: &'a Editor) -> Option<Cow<'a, str>> {
self.read(name, editor).and_then(|values| values.last())
}
pub fn iter_preview(&self) -> impl Iterator<Item = (char, &str)> {
self.inner
.iter()
.map(|(name, values)| {
let preview = values
.first()
.and_then(|s| s.lines().next())
.unwrap_or("<empty>");
(*name, preview)
})
.chain(
[
('_', "<empty>"),
('#', "<selection indices>"),
('.', "<selection contents>"),
]
.iter()
.copied(),
)
}
pub fn clear(&mut self) {
self.inner.clear()
}
pub fn remove(&mut self, name: char) -> bool {
match name {
'_' | '#' | '.' => false,
_ => self.inner.remove(&name).is_some(),
}
}
}
// This is a wrapper of an iterator that is both double ended and exact size,
// and can return either owned or borrowed values. Regular registers can
// return borrowed values while some special registers need to return owned
// values.
pub struct RegisterValues<'a> {
iter: Box<dyn DoubleEndedExactSizeIterator<Item = Cow<'a, str>> + 'a>,
}
impl<'a> RegisterValues<'a> {
fn new(
iter: impl DoubleEndedIterator<Item = Cow<'a, str>>
+ ExactSizeIterator<Item = Cow<'a, str>>
+ 'a,
) -> Self {
Self {
iter: Box::new(iter),
}
}
}
impl<'a> Iterator for RegisterValues<'a> {
type Item = Cow<'a, str>;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a> DoubleEndedIterator for RegisterValues<'a> {
fn next_back(&mut self) -> Option<Self::Item> {
self.iter.next_back()
}
}
impl<'a> ExactSizeIterator for RegisterValues<'a> {
fn len(&self) -> usize {
self.iter.len()
}
}
// Each RegisterValues iterator is both double ended and exact size. We can't
// type RegisterValues as `Box<dyn DoubleEndedIterator + ExactSizeIterator>`
// because only one non-auto trait is allowed in trait objects. So we need to
// create a new trait that covers both. `RegisterValues` wraps that type so that
// trait only needs to live in this module and not be imported for all register
// callsites.
trait DoubleEndedExactSizeIterator: DoubleEndedIterator + ExactSizeIterator {}
impl<I: DoubleEndedIterator + ExactSizeIterator> DoubleEndedExactSizeIterator for I {}
|
