Struct Cell 

pub struct Cell { /* private fields */ }

Represent a table cell containing a string.

Once created, a cell’s content cannot be modified. The cell would have to be replaced by another one

Implementations

impl Cell

pub fn new_align(string: &str, align: Alignment) -> Cell

Create a new Cell initialized with content from string. Text alignment in cell is configurable with the align argument

Examples found in repository

examples/span.rs (lines 28-31)

fn main() {
  /*
      The following code will output

      +---------------+---------------+--------------+
      |         A table with horizontal span         |
      +===============+===============+==============+
      | This is a cell with span of 2 | span of 1    |
      +---------------+---------------+--------------+
      | span of 1     | span of 1     | span of 1    |
      +---------------+---------------+--------------+
      |    This cell with a span of 3 is centered    |
      +---------------+---------------+--------------+
  */

  let mut table: prettytable::Table = table![
  [H2 -> "This is a cell with span of 2", "span of 1"],
  ["span of 1", "span of 1", "span of 1"],
  [H03c -> "This cell with a span of 3 is centered"]
  ];
  table.set_titles(Row::new(vec![Cell::new_align(
    "A table with horizontal span",
    Alignment::CENTER,
  )
  .with_hspan(3)]));
  table.printstd();
}

pub fn new(string: &str) -> Cell

Create a new Cell initialized with content from string. By default, content is align to LEFT

Examples found in repository

examples/basic.rs (line 33)

fn main() {
  let mut table = Table::new();
  table.add_row(row!["ABC", "DEFG", "HIJKLMN"]);
  table.add_row(row!["foobar", "bar", "foo"]);
  table.add_row(Row::new(vec![
    Cell::new("foobar2"),
    Cell::new("bar2"),
    Cell::new("foo2"),
  ]));
  table.printstd();
  println!("Modified : ");
  table.set_element("new_foo", 2, 1).unwrap();
  table.printstd();

  // The same table can be built the following way :
  let _table = table!(
    ["ABC", "DEFG", "HIJKLMN"],
    ["foobar", "bar", "foo"],
    ["foobar2", "bar2", "foo2"]
  );

  // Or directly print it like this
  let _table = ptable!(
    ["ABC", "DEFG", "HIJKLMN"],
    ["foobar", "bar", "foo"],
    ["foobar2", "bar2", "foo2"]
  );
}

examples/style.rs (line 22)

fn main() {
  let _ = table!();
  let mut table = Table::new();
  // Add style to a cell
  table.add_row(row![FrByb->"ABC", "DEFG", "HIJKLMN"]);
  // Add style to a full row
  table.add_row(row![FY => "styled", "bar", "foo"]);
  table.add_row(Row::new(vec![
    Cell::new("foobar2"),
    // Create a cell with a red foreground color
    Cell::new("bar2").with_style(Attr::ForegroundColor(color::RED)),
    // Create a cell with red foreground color, yellow background color, with bold characters
    Cell::new("foo2").style_spec("FrByb"),
    // Using the cell! macro
    cell!(Fr->"red"),
  ]));

  table.printstd();

  // Print a table with some styles on it :
  // FrBybl means : Foregound red, Background yellow, bold, left align
  ptable!([FrBybl->"A", "B", FrBybr->"C"], [123, 234, 345, 456], [Fg => 1, 2, 3]);

  // You can also apply style to full rows :
  let mut table = table!([Frb => "A", "B", "C"], [1, 2, 3, 4], ["A\nBCCZZZ\nDDD", 2, table]);
  // Set a title line, with all text centered in the cell
  table.set_titles(row![c => "Title 1", "Title 2"]);
  table.printstd();
}

pub fn align(&mut self, align: Alignment)

Set text alignment in the cell

pub fn style(&mut self, attr: Attr)

Add a style attribute to the cell

pub fn with_style(self, attr: Attr) -> Cell

Add a style attribute to the cell. Can be chained

Examples found in repository

examples/style.rs (line 24)

fn main() {
  let _ = table!();
  let mut table = Table::new();
  // Add style to a cell
  table.add_row(row![FrByb->"ABC", "DEFG", "HIJKLMN"]);
  // Add style to a full row
  table.add_row(row![FY => "styled", "bar", "foo"]);
  table.add_row(Row::new(vec![
    Cell::new("foobar2"),
    // Create a cell with a red foreground color
    Cell::new("bar2").with_style(Attr::ForegroundColor(color::RED)),
    // Create a cell with red foreground color, yellow background color, with bold characters
    Cell::new("foo2").style_spec("FrByb"),
    // Using the cell! macro
    cell!(Fr->"red"),
  ]));

  table.printstd();

  // Print a table with some styles on it :
  // FrBybl means : Foregound red, Background yellow, bold, left align
  ptable!([FrBybl->"A", "B", FrBybr->"C"], [123, 234, 345, 456], [Fg => 1, 2, 3]);

  // You can also apply style to full rows :
  let mut table = table!([Frb => "A", "B", "C"], [1, 2, 3, 4], ["A\nBCCZZZ\nDDD", 2, table]);
  // Set a title line, with all text centered in the cell
  table.set_titles(row![c => "Title 1", "Title 2"]);
  table.printstd();
}

pub fn with_hspan(self, hspan: usize) -> Cell

Add horizontal spanning to the cell

Examples found in repository

examples/span.rs (line 32)

fn main() {
  /*
      The following code will output

      +---------------+---------------+--------------+
      |         A table with horizontal span         |
      +===============+===============+==============+
      | This is a cell with span of 2 | span of 1    |
      +---------------+---------------+--------------+
      | span of 1     | span of 1     | span of 1    |
      +---------------+---------------+--------------+
      |    This cell with a span of 3 is centered    |
      +---------------+---------------+--------------+
  */

  let mut table: prettytable::Table = table![
  [H2 -> "This is a cell with span of 2", "span of 1"],
  ["span of 1", "span of 1", "span of 1"],
  [H03c -> "This cell with a span of 3 is centered"]
  ];
  table.set_titles(Row::new(vec![Cell::new_align(
    "A table with horizontal span",
    Alignment::CENTER,
  )
  .with_hspan(3)]));
  table.printstd();
}

pub fn reset_style(&mut self)

Remove all style attributes and reset alignment to default (LEFT)

pub fn style_spec(self, spec: &str) -> Cell

Set the cell’s style by applying the given specifier string

Style spec syntax

The syntax for the style specifier looks like this : FrBybl which means Foreground red Background yellow bold left

List of supported specifiers :

• F : Foreground (must be followed by a color specifier)
• B : Background (must be followed by a color specifier)
• H : Horizontal span (must be followed by a number)
• b : bold
• i : italic
• u : underline
• c : Align center
• l : Align left
• r : Align right
• d : default style

List of color specifiers :

• r : Red
• b : Blue
• g : Green
• y : Yellow
• c : Cyan
• m : Magenta
• w : White
• d : Black

And capital letters are for bright colors. Eg :

• R : Bright Red
• B : Bright Blue
• … and so on …

Examples found in repository

examples/style.rs (line 26)

fn main() {
  let _ = table!();
  let mut table = Table::new();
  // Add style to a cell
  table.add_row(row![FrByb->"ABC", "DEFG", "HIJKLMN"]);
  // Add style to a full row
  table.add_row(row![FY => "styled", "bar", "foo"]);
  table.add_row(Row::new(vec![
    Cell::new("foobar2"),
    // Create a cell with a red foreground color
    Cell::new("bar2").with_style(Attr::ForegroundColor(color::RED)),
    // Create a cell with red foreground color, yellow background color, with bold characters
    Cell::new("foo2").style_spec("FrByb"),
    // Using the cell! macro
    cell!(Fr->"red"),
  ]));

  table.printstd();

  // Print a table with some styles on it :
  // FrBybl means : Foregound red, Background yellow, bold, left align
  ptable!([FrBybl->"A", "B", FrBybr->"C"], [123, 234, 345, 456], [Fg => 1, 2, 3]);

  // You can also apply style to full rows :
  let mut table = table!([Frb => "A", "B", "C"], [1, 2, 3, 4], ["A\nBCCZZZ\nDDD", 2, table]);
  // Set a title line, with all text centered in the cell
  table.set_titles(row![c => "Title 1", "Title 2"]);
  table.printstd();
}

pub fn set_hspan(&mut self, hspan: usize)

Set horizontal span for this cell (must be > 0)

pub fn get_hspan(&self) -> usize

Get horizontal span of this cell (> 0)

pub fn get_content(&self) -> String

Return a copy of the full string contained in the cell

pub fn print_html<T: Write + ?Sized>(&self, out: &mut T) -> Result<usize, Error>

Print the cell in HTML format to out.

Trait Implementations

impl Clone for Cell

fn clone(&self) -> Cell

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cell

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

Formats the value using the given formatter.

impl Default for Cell

fn default() -> Cell

Return a cell initialized with a single empty String, with LEFT alignment

impl<T: ToString> From<&T> for Cell

fn from(f: &T) -> Cell

Converts to this type from the input type.

impl Hash for Cell

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 PartialEq for Cell

fn eq(&self, other: &Cell) -> 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 ToString for Cell

fn to_string(&self) -> String

Converts the given value to a String.

impl Eq for Cell

impl StructuralPartialEq for Cell