Merging upstream version 1.75.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 257 insertions, 0 deletions

diff --git a/vendor/tabled/src/settings/extract/mod.rs b/vendor/tabled/src/settings/extract/mod.rs
new file mode 100644
index 000000000..bba90a0db
--- /dev/null
+++ b/vendor/tabled/src/settings/extract/mod.rs
@@ -0,0 +1,257 @@
+//! This module contains an [`Extract`] structure which is used to
+//! obtain an ordinary segment from the [`Table`].
+//!
+//! There's a similar structure [`Highlight`] which does a highlighting a of segments.
+//!
+//! [`Table`]: crate::Table
+//! [`Highlight`]: crate::settings::highlight::Highlight
+
+use core::cmp::min;
+use core::ops::{Bound, RangeBounds, RangeFull};
+
+use crate::{
+    grid::records::{ExactRecords, Records, Resizable},
+    settings::TableOption,
+};
+
+/// Returns a new [`Table`] that reflects a segment of the referenced [`Table`]
+///
+/// # Example
+///
+#[cfg_attr(feature = "std", doc = "```")]
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+/// use tabled::{Table, settings::{Format, object::Rows, Modify, Extract}};
+///
+/// let data = vec![
+///     (0, "Grodno", true),
+///     (1, "Minsk", true),
+///     (2, "Hamburg", false),
+///     (3, "Brest", true),
+/// ];
+///
+/// let table = Table::new(&data)
+///                .with(Modify::new(Rows::new(1..)).with(Format::content(|s| format!(": {} :", s))))
+///                .with(Extract::segment(1..=2, 1..))
+///                .to_string();
+///
+/// assert_eq!(table, "+------------+----------+\n\
+///                    | : Grodno : | : true : |\n\
+///                    +------------+----------+\n\
+///                    | : Minsk :  | : true : |\n\
+///                    +------------+----------+");
+/// ```
+///
+/// [`Table`]: crate::Table
+#[derive(Debug)]
+pub struct Extract<R, C> {
+    rows: R,
+    columns: C,
+}
+
+impl<R, C> Extract<R, C>
+where
+    R: RangeBounds<usize>,
+    C: RangeBounds<usize>,
+{
+    /// Returns a new [`Table`] that reflects a segment of the referenced [`Table`]
+    ///
+    /// ```rust,no_run
+    /// # use tabled::settings::Extract;
+    /// let rows = 1..3;
+    /// let columns = 1..;
+    /// Extract::segment(rows, columns);
+    /// ```
+    ///
+    /// # Range
+    ///
+    /// A [`RangeBounds`] argument can be less than or equal to the shape of a [`Table`]
+    ///
+    /// If a [`RangeBounds`] argument is malformed or too large the thread will panic
+    ///
+    /// ```text
+    /// // Empty                         Full                      Out of bounds
+    ///    Extract::segment(0..0, 0..0)  Extract::segment(.., ..)  Extract::segment(0..1, ..4)
+    ///    [].   .   .                   [O   O   O                [O   O   O  X] //ERROR            
+    ///      .   .   .                    O   O   O                 .   .   .             
+    ///      .   .   .                    O   O   O]                .   .   .          
+    /// ```
+    ///
+    /// [`Table`]: crate::Table
+    pub fn segment(rows: R, columns: C) -> Self {
+        Extract { rows, columns }
+    }
+}
+
+impl<R> Extract<R, RangeFull>
+where
+    R: RangeBounds<usize>,
+{
+    /// Returns a new [`Table`] that reflects a segment of the referenced [`Table`]
+    ///
+    /// The segment is defined by [`RangeBounds`] for Rows
+    ///
+    /// ```rust,no_run
+    /// # use tabled::settings::Extract;
+    /// Extract::rows(1..3);
+    /// ```
+    ///
+    /// # Range
+    ///
+    /// A [`RangeBounds`] argument can be less than or equal to the shape of a [`Table`]
+    ///
+    /// If a [`RangeBounds`] argument is malformed or too large the thread will panic
+    ///
+    /// ```text
+    /// // Empty                Full               Out of bounds
+    ///    Extract::rows(0..0)  Extract::rows(..)  Extract::rows(0..4)
+    ///    [].   .   .          [O   O   O         [O   O   O             
+    ///      .   .   .           O   O   O          O   O   O              
+    ///      .   .   .           O   O   O]         O   O   O
+    ///                                             X   X   X] // ERROR          
+    /// ```
+    ///
+    /// [`Table`]: crate::Table
+    pub fn rows(rows: R) -> Self {
+        Extract { rows, columns: .. }
+    }
+}
+
+impl<C> Extract<RangeFull, C>
+where
+    C: RangeBounds<usize>,
+{
+    /// Returns a new [`Table`] that reflects a segment of the referenced [`Table`]
+    ///
+    /// The segment is defined by [`RangeBounds`] for columns.
+    ///
+    /// ```rust,no_run
+    /// # use tabled::settings::Extract;
+    /// Extract::columns(1..3);
+    /// ```
+    ///
+    /// # Range
+    ///
+    /// A [`RangeBounds`] argument can be less than or equal to the shape of a [`Table`]
+    ///
+    /// If a [`RangeBounds`] argument is malformed or too large the thread will panic
+    ///
+    /// ```text
+    /// // Empty                   Full                  Out of bounds
+    ///    Extract::columns(0..0)  Extract::columns(..)  Extract::columns(0..4)
+    ///    [].   .   .             [O   O   O            [O   O   O   X          
+    ///      .   .   .              O   O   O             O   O   O   X          
+    ///      .   .   .              O   O   O]            O   O   O   X] // ERROR
+    /// ```
+    ///
+    /// [`Table`]: crate::Table
+    pub fn columns(columns: C) -> Self {
+        Extract { rows: .., columns }
+    }
+}
+
+impl<R, C, RR, D, Cfg> TableOption<RR, D, Cfg> for Extract<R, C>
+where
+    R: RangeBounds<usize> + Clone,
+    C: RangeBounds<usize> + Clone,
+    RR: Records + ExactRecords + Resizable,
+{
+    fn change(self, records: &mut RR, _: &mut Cfg, _: &mut D) {
+        let count_rows = records.count_rows();
+        let count_columns = records.count_columns();
+
+        let mut rows = bounds_to_usize(self.rows.start_bound(), self.rows.end_bound(), count_rows);
+        let mut cols = bounds_to_usize(
+            self.columns.start_bound(),
+            self.columns.end_bound(),
+            count_columns,
+        );
+
+        // Cleanup table in case if boundaries are exceeded.
+        //
+        // todo: can be optimized by adding a clear() method to Resizable
+        rows.0 = min(rows.0, count_rows);
+        cols.0 = min(cols.0, count_columns);
+
+        extract(records, (count_rows, count_columns), rows, cols);
+    }
+}
+
+/// Returns a new [`Grid`] that reflects a segment of the referenced [`Grid`].
+///
+/// # Example
+///
+/// ```text
+/// grid
+/// +---+---+---+
+/// |0-0|0-1|0-2|
+/// +---+---+---+
+/// |1-0|1-1|1-2|
+/// +---+---+---+
+/// |2-0|2-1|2-2|
+/// +---+---+---+
+///
+/// let rows = ..;
+/// let columns = ..1;
+/// grid.extract(rows, columns)
+///
+/// grid
+/// +---+
+/// |0-0|
+/// +---+
+/// |1-0|
+/// +---+
+/// |2-0|
+/// +---+
+/// ```
+fn extract<R>(
+    records: &mut R,
+    (count_rows, count_cols): (usize, usize),
+    (start_row, end_row): (usize, usize),
+    (start_col, end_col): (usize, usize),
+) where
+    R: Resizable,
+{
+    for (i, row) in (0..start_row).enumerate() {
+        let row = row - i;
+        records.remove_row(row);
+    }
+
+    let count_rows = count_rows - start_row;
+    let end_row = end_row - start_row;
+    for (i, row) in (end_row..count_rows).enumerate() {
+        let row = row - i;
+        records.remove_row(row);
+    }
+
+    for (i, col) in (0..start_col).enumerate() {
+        let col = col - i;
+        records.remove_column(col);
+    }
+
+    let count_cols = count_cols - start_col;
+    let end_col = end_col - start_col;
+    for (i, col) in (end_col..count_cols).enumerate() {
+        let col = col - i;
+        records.remove_column(col);
+    }
+}
+
+fn bounds_to_usize(
+    left: Bound<&usize>,
+    right: Bound<&usize>,
+    count_elements: usize,
+) -> (usize, usize) {
+    match (left, right) {
+        (Bound::Included(x), Bound::Included(y)) => (*x, y + 1),
+        (Bound::Included(x), Bound::Excluded(y)) => (*x, *y),
+        (Bound::Included(x), Bound::Unbounded) => (*x, count_elements),
+        (Bound::Unbounded, Bound::Unbounded) => (0, count_elements),
+        (Bound::Unbounded, Bound::Included(y)) => (0, y + 1),
+        (Bound::Unbounded, Bound::Excluded(y)) => (0, *y),
+        (Bound::Excluded(_), Bound::Unbounded)
+        | (Bound::Excluded(_), Bound::Included(_))
+        | (Bound::Excluded(_), Bound::Excluded(_)) => {
+            unreachable!("A start bound can't be excluded")
+        }
+    }
+}