diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-06-07 05:48:48 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-06-07 05:48:48 +0000 |
commit | ef24de24a82fe681581cc130f342363c47c0969a (patch) | |
tree | 0d494f7e1a38b95c92426f58fe6eaa877303a86c /vendor/papergrid/src/dimension/spanned.rs | |
parent | Releasing progress-linux version 1.74.1+dfsg1-1~progress7.99u1. (diff) | |
download | rustc-ef24de24a82fe681581cc130f342363c47c0969a.tar.xz rustc-ef24de24a82fe681581cc130f342363c47c0969a.zip |
Merging upstream version 1.75.0+dfsg1.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/papergrid/src/dimension/spanned.rs')
-rw-r--r-- | vendor/papergrid/src/dimension/spanned.rs | 329 |
1 files changed, 329 insertions, 0 deletions
diff --git a/vendor/papergrid/src/dimension/spanned.rs b/vendor/papergrid/src/dimension/spanned.rs new file mode 100644 index 000000000..6597ba176 --- /dev/null +++ b/vendor/papergrid/src/dimension/spanned.rs @@ -0,0 +1,329 @@ +//! The module contains a [`SpannedGridDimension`] for [`Grid`] height/width estimation. +//! +//! [`Grid`]: crate::grid::iterable::Grid + +use std::{ + cmp::{max, Ordering}, + collections::HashMap, +}; + +use crate::{ + config::Position, + dimension::{Dimension, Estimate}, + records::Records, + util::string::{count_lines, string_dimension, string_width_multiline}, +}; + +use crate::config::spanned::SpannedConfig; + +/// A [`Dimension`] implementation which calculates exact column/row width/height. +/// +/// [`Grid`]: crate::grid::iterable::Grid +#[derive(Debug, Default, Clone, PartialEq, Eq)] +pub struct SpannedGridDimension { + height: Vec<usize>, + width: Vec<usize>, +} + +impl SpannedGridDimension { + /// Calculates height of rows. + pub fn height<R: Records>(records: R, cfg: &SpannedConfig) -> Vec<usize> { + build_height(records, cfg) + } + + /// Calculates width of columns. + pub fn width<R: Records>(records: R, cfg: &SpannedConfig) -> Vec<usize> { + build_width(records, cfg) + } + + /// Return width and height lists. + pub fn get_values(self) -> (Vec<usize>, Vec<usize>) { + (self.width, self.height) + } +} + +impl Dimension for SpannedGridDimension { + fn get_width(&self, column: usize) -> usize { + self.width[column] + } + + fn get_height(&self, row: usize) -> usize { + self.height[row] + } +} + +impl<R> Estimate<R, SpannedConfig> for SpannedGridDimension +where + R: Records, +{ + fn estimate(&mut self, records: R, cfg: &SpannedConfig) { + let (width, height) = build_dimensions(records, cfg); + self.width = width; + self.height = height; + } +} + +fn build_dimensions<R: Records>(records: R, cfg: &SpannedConfig) -> (Vec<usize>, Vec<usize>) { + let count_columns = records.count_columns(); + + let mut widths = vec![0; count_columns]; + let mut heights = vec![]; + + let mut vspans = HashMap::new(); + let mut hspans = HashMap::new(); + + for (row, columns) in records.iter_rows().into_iter().enumerate() { + let mut row_height = 0; + for (col, cell) in columns.into_iter().enumerate() { + let pos = (row, col); + if !cfg.is_cell_visible(pos) { + continue; + } + + let text = cell.as_ref(); + let (height, width) = string_dimension(text); + let pad = cfg.get_padding(pos.into()); + let width = width + pad.left.size + pad.right.size; + let height = height + pad.top.size + pad.bottom.size; + + match cfg.get_column_span(pos) { + Some(n) if n > 1 => { + vspans.insert(pos, (n, width)); + } + _ => widths[col] = max(widths[col], width), + } + + match cfg.get_row_span(pos) { + Some(n) if n > 1 => { + hspans.insert(pos, (n, height)); + } + _ => row_height = max(row_height, height), + } + } + + heights.push(row_height); + } + + let count_rows = heights.len(); + + adjust_vspans(cfg, count_columns, &vspans, &mut widths); + adjust_hspans(cfg, count_rows, &hspans, &mut heights); + + (widths, heights) +} + +fn adjust_hspans( + cfg: &SpannedConfig, + len: usize, + spans: &HashMap<Position, (usize, usize)>, + heights: &mut [usize], +) { + if spans.is_empty() { + return; + } + + let mut spans_ordered = spans + .iter() + .map(|(k, v)| ((k.0, k.1), *v)) + .collect::<Vec<_>>(); + spans_ordered.sort_unstable_by(|(arow, acol), (brow, bcol)| match arow.cmp(brow) { + Ordering::Equal => acol.cmp(bcol), + ord => ord, + }); + + for ((row, _), (span, height)) in spans_ordered { + adjust_row_range(cfg, height, len, row, row + span, heights); + } +} + +fn adjust_row_range( + cfg: &SpannedConfig, + max_span_height: usize, + len: usize, + start: usize, + end: usize, + heights: &mut [usize], +) { + let range_height = range_height(cfg, len, start, end, heights); + if range_height >= max_span_height { + return; + } + + inc_range(heights, max_span_height - range_height, start, end); +} + +fn range_height( + cfg: &SpannedConfig, + len: usize, + start: usize, + end: usize, + heights: &[usize], +) -> usize { + let count_borders = count_horizontal_borders(cfg, len, start, end); + let range_height = heights[start..end].iter().sum::<usize>(); + count_borders + range_height +} + +fn count_horizontal_borders(cfg: &SpannedConfig, len: usize, start: usize, end: usize) -> usize { + (start..end) + .skip(1) + .filter(|&i| cfg.has_horizontal(i, len)) + .count() +} + +fn get_cell_height(cell: &str, cfg: &SpannedConfig, pos: Position) -> usize { + let count_lines = max(1, count_lines(cell)); + let padding = cfg.get_padding(pos.into()); + count_lines + padding.top.size + padding.bottom.size +} + +fn inc_range(list: &mut [usize], size: usize, start: usize, end: usize) { + if list.is_empty() { + return; + } + + let span = end - start; + let one = size / span; + let rest = size - span * one; + + let mut i = start; + while i < end { + if i == start { + list[i] += one + rest; + } else { + list[i] += one; + } + + i += 1; + } +} + +fn adjust_vspans( + cfg: &SpannedConfig, + len: usize, + spans: &HashMap<Position, (usize, usize)>, + widths: &mut [usize], +) { + if spans.is_empty() { + return; + } + + // The overall width distribution will be different depend on the order. + // + // We sort spans in order to prioritize the smaller spans first. + let mut spans_ordered = spans + .iter() + .map(|(k, v)| ((k.0, k.1), *v)) + .collect::<Vec<_>>(); + spans_ordered.sort_unstable_by(|a, b| match a.1 .0.cmp(&b.1 .0) { + Ordering::Equal => a.0.cmp(&b.0), + o => o, + }); + + for ((_, col), (span, width)) in spans_ordered { + adjust_column_range(cfg, width, len, col, col + span, widths); + } +} + +fn adjust_column_range( + cfg: &SpannedConfig, + max_span_width: usize, + len: usize, + start: usize, + end: usize, + widths: &mut [usize], +) { + let range_width = range_width(cfg, len, start, end, widths); + if range_width >= max_span_width { + return; + } + + inc_range(widths, max_span_width - range_width, start, end); +} + +fn get_cell_width(text: &str, cfg: &SpannedConfig, pos: Position) -> usize { + let padding = get_cell_padding(cfg, pos); + let width = string_width_multiline(text); + width + padding +} + +fn get_cell_padding(cfg: &SpannedConfig, pos: Position) -> usize { + let padding = cfg.get_padding(pos.into()); + padding.left.size + padding.right.size +} + +fn range_width( + cfg: &SpannedConfig, + len: usize, + start: usize, + end: usize, + widths: &[usize], +) -> usize { + let count_borders = count_vertical_borders(cfg, len, start, end); + let range_width = widths[start..end].iter().sum::<usize>(); + count_borders + range_width +} + +fn count_vertical_borders(cfg: &SpannedConfig, len: usize, start: usize, end: usize) -> usize { + (start..end) + .skip(1) + .filter(|&i| cfg.has_vertical(i, len)) + .count() +} + +fn build_height<R: Records>(records: R, cfg: &SpannedConfig) -> Vec<usize> { + let mut heights = vec![]; + let mut hspans = HashMap::new(); + + for (row, columns) in records.iter_rows().into_iter().enumerate() { + let mut row_height = 0; + for (col, cell) in columns.into_iter().enumerate() { + let pos = (row, col); + if !cfg.is_cell_visible(pos) { + continue; + } + + let height = get_cell_height(cell.as_ref(), cfg, pos); + match cfg.get_row_span(pos) { + Some(n) if n > 1 => { + hspans.insert(pos, (n, height)); + } + _ => row_height = max(row_height, height), + } + } + + heights.push(row_height); + } + + adjust_hspans(cfg, heights.len(), &hspans, &mut heights); + + heights +} + +fn build_width<R: Records>(records: R, cfg: &SpannedConfig) -> Vec<usize> { + let count_columns = records.count_columns(); + + let mut widths = vec![0; count_columns]; + let mut vspans = HashMap::new(); + + for (row, columns) in records.iter_rows().into_iter().enumerate() { + for (col, cell) in columns.into_iter().enumerate() { + let pos = (row, col); + if !cfg.is_cell_visible(pos) { + continue; + } + + let width = get_cell_width(cell.as_ref(), cfg, pos); + match cfg.get_column_span(pos) { + Some(n) if n > 1 => { + vspans.insert(pos, (n, width)); + } + _ => widths[col] = max(widths[col], width), + } + } + } + + adjust_vspans(cfg, count_columns, &vspans, &mut widths); + + widths +} |