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
|
use super::{StyleChain, StyleVec, StyleVecBuilder};
/// A wrapper around a [`StyleVecBuilder`] that allows to collapse items.
pub struct CollapsingBuilder<'a, T> {
builder: StyleVecBuilder<'a, T>,
staged: Vec<(T, StyleChain<'a>, bool)>,
last: Last,
}
/// What the last non-ignorant item was.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Last {
Weak,
Destructive,
Supportive,
}
impl<'a, T: Merge> CollapsingBuilder<'a, T> {
/// Create a new style-vec builder.
pub fn new() -> Self {
Self {
builder: StyleVecBuilder::new(),
staged: vec![],
last: Last::Destructive,
}
}
/// Can only exist when there is at least one supportive item to its left
/// and to its right, with no destructive items or weak items in between to
/// its left and no destructive items in between to its right. There may be
/// ignorant items in between in both directions.
pub fn weak(&mut self, item: T, styles: StyleChain<'a>) {
if self.last == Last::Supportive {
self.staged.push((item, styles, true));
self.last = Last::Weak;
}
}
/// Forces nearby weak items to collapse.
pub fn destructive(&mut self, item: T, styles: StyleChain<'a>) {
self.flush(false);
self.push(item, styles);
self.last = Last::Destructive;
}
/// Allows nearby weak items to exist.
pub fn supportive(&mut self, item: T, styles: StyleChain<'a>) {
self.flush(true);
self.push(item, styles);
self.last = Last::Supportive;
}
/// Has no influence on other items.
pub fn ignorant(&mut self, item: T, styles: StyleChain<'a>) {
self.staged.push((item, styles, false));
}
/// Return the finish style vec and the common prefix chain.
pub fn finish(mut self) -> (StyleVec<T>, StyleChain<'a>) {
self.flush(false);
self.builder.finish()
}
/// Push the staged items, filtering out weak items if `supportive` is false.
fn flush(&mut self, supportive: bool) {
for (item, styles, weak) in self.staged.drain(..) {
if !weak || supportive {
push_merging(&mut self.builder, item, styles);
}
}
}
/// Push a new item into the style vector.
fn push(&mut self, item: T, styles: StyleChain<'a>) {
push_merging(&mut self.builder, item, styles);
}
}
/// Push an item into a style-vec builder, trying to merging it with the
/// previous item.
fn push_merging<'a, T: Merge>(
builder: &mut StyleVecBuilder<'a, T>,
item: T,
styles: StyleChain<'a>,
) {
if let Some((prev_item, prev_styles)) = builder.last_mut() {
if styles == prev_styles {
if prev_item.merge(&item) {
return;
}
}
}
builder.push(item, styles);
}
impl<'a, T: Merge> Default for CollapsingBuilder<'a, T> {
fn default() -> Self {
Self::new()
}
}
/// Defines if and how to merge two adjacent items in a [`CollapsingBuilder`].
pub trait Merge {
/// Try to merge the items, returning whether they were merged.
///
/// Defaults to not merging.
fn merge(&mut self, next: &Self) -> bool;
}
|
