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
|
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
#[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())),
_ => 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(()),
_ => {
self.inner.insert(name, values);
Ok(())
}
}
}
pub fn push(&mut self, name: char, value: String) -> Result<()> {
match name {
'_' => Ok(()),
_ => {
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>")].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 {}
|
