Struct Locator

pub struct Locator;

An abstract factory for locations, to be used to find different things on the table.

Implementations

impl Locator

pub fn content<S>(text: S) -> ByContent<S>

where S: AsRef<str>,

Constructs a new location searcher for a cells with a given content.

Example

use tabled::{
    settings::location::Locator,
    assert::assert_table,
    Table, Tabled,
};

#[derive(Tabled)]
struct Reading {
    link: &'static str,
    comment: &'static str,
}

let data = [
    Reading { link: "https://www.gnu.org/software/grub/manual/multiboot/multiboot.html", comment: "todo" },
    Reading { link: "https://wiki.debian.org/initramfs", comment: "todo" },
    Reading { link: "http://jdebp.uk/FGA/efi-boot-process.html", comment: "..." },
    Reading { link: "https://wiki.debian.org/UEFI", comment: "" },
];

let mut table = Table::new(data);
table.modify(Locator::content("todo"), "todo-soon");

assert_table!(
    table,
    "+-------------------------------------------------------------------+-----------+"
    "| link                                                              | comment   |"
    "+-------------------------------------------------------------------+-----------+"
    "| https://www.gnu.org/software/grub/manual/multiboot/multiboot.html | todo-soon |"
    "+-------------------------------------------------------------------+-----------+"
    "| https://wiki.debian.org/initramfs                                 | todo-soon |"
    "+-------------------------------------------------------------------+-----------+"
    "| http://jdebp.uk/FGA/efi-boot-process.html                         | ...       |"
    "+-------------------------------------------------------------------+-----------+"
    "| https://wiki.debian.org/UEFI                                      |           |"
    "+-------------------------------------------------------------------+-----------+"
);

pub fn column<S>(text: S) -> ByColumnName<S>

where S: AsRef<str>,

Constructs a new location searcher for a column by its header.

Example

use tabled::{
    settings::{location::Locator, Width},
    assert::assert_table,
    Table, Tabled,
};

#[derive(Tabled)]
struct Reading {
    link: &'static str,
    comment: &'static str,
}

let data = [
    Reading { link: "https://www.gnu.org/software/grub/manual/multiboot/multiboot.html", comment: "todo" },
    Reading { link: "https://wiki.debian.org/initramfs", comment: "todo" },
    Reading { link: "http://jdebp.uk/FGA/efi-boot-process.html", comment: "..." },
    Reading { link: "https://wiki.debian.org/UEFI", comment: "" },
];

let mut table = Table::new(data);
table.modify(Locator::column("link"), Width::truncate(10));

assert_table!(
    table,
    "+------------+---------+"
    "| link       | comment |"
    "+------------+---------+"
    "| https://ww | todo    |"
    "+------------+---------+"
    "| https://wi | todo    |"
    "+------------+---------+"
    "| http://jde | ...     |"
    "+------------+---------+"
    "| https://wi |         |"
    "+------------+---------+"
);

pub fn by<F>(condition: F) -> ByCondition<F>

where F: Fn(&str) -> bool,

Constructs a new location searcher with a specified condition closure.

Return true if it shall be included in output. Otherwise return false.

Example

use tabled::{
    settings::{location::Locator, Width},
    assert::assert_table,
    Table, Tabled,
};

#[derive(Tabled)]
struct Reading {
    link: &'static str,
    comment: &'static str,
}

let data = [
    Reading { link: "https://www.gnu.org/software/grub/manual/multiboot/multiboot.html", comment: "todo" },
    Reading { link: "https://wiki.debian.org/initramfs", comment: "todo" },
    Reading { link: "http://jdebp.uk/FGA/efi-boot-process.html", comment: "..." },
    Reading { link: "https://wiki.debian.org/UEFI", comment: "" },
];

let mut table = Table::new(data);
table.modify(Locator::by(|text| text.len() > 33), Width::truncate(33));

assert_table!(
    table,
    "+-----------------------------------+---------+"
    "| link                              | comment |"
    "+-----------------------------------+---------+"
    "| https://www.gnu.org/software/grub | todo    |"
    "+-----------------------------------+---------+"
    "| https://wiki.debian.org/initramfs | todo    |"
    "+-----------------------------------+---------+"
    "| http://jdebp.uk/FGA/efi-boot-proc | ...     |"
    "+-----------------------------------+---------+"
    "| https://wiki.debian.org/UEFI      |         |"
    "+-----------------------------------+---------+"
);

pub fn value<O, F>(search: O, condition: F) -> ByValue<O, F>

where F: Fn(&str, &str) -> bool,

Constructs a new location searcher which finds only all values equal to the top.

Return true if it shall be counted. Otherwise return false.

Example

use tabled::{
    settings::{location::Locator, Width, Format},
    assert::assert_table,
    Table, Tabled,
};

#[derive(Tabled)]
struct Reading {
    link: &'static str,
    comment: &'static str,
}

let data = [
    Reading { link: "https://www.gnu.org/software/grub/manual/multiboot/multiboot.html", comment: "todo" },
    Reading { link: "https://wiki.debian.org/initramfs", comment: "todo" },
    Reading { link: "http://jdebp.uk/FGA/efi-boot-process.html", comment: "..." },
    Reading { link: "https://wiki.debian.org/UEFI", comment: "" },
];

let mut table = Table::new(data);
table.modify(
    Locator::value(Locator::column("link"), |link1, link2| link1.len() > link2.len()),
    Format::content(|s| format!("[ {s} ]")),
);

assert_table!(
    table,
    "+-----------------------------------------------------------------------+---------+"
    "| link                                                                  | comment |"
    "+-----------------------------------------------------------------------+---------+"
    "| [ https://www.gnu.org/software/grub/manual/multiboot/multiboot.html ] | todo    |"
    "+-----------------------------------------------------------------------+---------+"
    "| https://wiki.debian.org/initramfs                                     | todo    |"
    "+-----------------------------------------------------------------------+---------+"
    "| http://jdebp.uk/FGA/efi-boot-process.html                             | ...     |"
    "+-----------------------------------------------------------------------+---------+"
    "| https://wiki.debian.org/UEFI                                          |         |"
    "+-----------------------------------------------------------------------+---------+"
);

Trait Implementations

impl Clone for Locator

fn clone(&self) -> Locator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Locator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Locator

fn default() -> Locator

Returns the “default value” for a type.

impl Hash for Locator

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Locator

fn cmp(&self, other: &Locator) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Locator

fn eq(&self, other: &Locator) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Locator

fn partial_cmp(&self, other: &Locator) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Locator

impl Eq for Locator

impl StructuralPartialEq for Locator