127 lines
3.8 KiB
Rust
127 lines
3.8 KiB
Rust
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>, Option<u8>)>,
|
|
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, strength: u8, styles: StyleChain<'a>) {
|
|
if self.last != Last::Destructive {
|
|
if self.last == Last::Weak {
|
|
if let Some(i) = self
|
|
.staged
|
|
.iter()
|
|
.position(|(.., prev)| prev.map_or(false, |p| p < strength))
|
|
{
|
|
self.staged.remove(i);
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
self.staged.push((item, styles, Some(strength)));
|
|
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, None));
|
|
}
|
|
|
|
/// Iterate over the contained items.
|
|
pub fn items(&self) -> impl DoubleEndedIterator<Item = &T> {
|
|
self.builder.items().chain(self.staged.iter().map(|(item, ..)| item))
|
|
}
|
|
|
|
/// 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, strength) in self.staged.drain(..) {
|
|
if supportive || strength.is_none() {
|
|
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;
|
|
}
|