Struct Row 

pub struct Row { /* private fields */ }

Represent a table row made of cells

Implementations

impl Row

pub fn new(cells: Vec<Cell>) -> Row

Create a new Row backed with cells vector

Examples found in repository

examples/basic.rs (lines 32-36)

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/span.rs (lines 28-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();
}

examples/style.rs (lines 21-29)

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 empty() -> Row

Create an row of length size, with empty strings stored

pub fn len(&self) -> usize

Get the number of cells in this row

pub fn is_empty(&self) -> bool

Check if the row is empty (has no cell)

pub fn get_cell(&self, idx: usize) -> Option<&Cell>

Get the cell at index idx

Examples found in repository

examples/tictactoe.rs (line 49)

fn main() {
  let mut table = table![
    [EMPTY, EMPTY, EMPTY],
    [EMPTY, EMPTY, EMPTY],
    [EMPTY, EMPTY, EMPTY]
  ];
  let mut height = table.print_tty(false).unwrap();
  let stdin = io::stdin();
  let mut stdout = io::stdout();
  let mut current = CROSS;
  let mut terminal = term::stdout().unwrap();
  loop {
    let mut line = String::new();
    print!("{} plays > ", current);
    height += 1;
    stdout.flush().unwrap();
    stdin.read_line(&mut line).expect("Cannot read input");
    let i = match usize::from_str(line.trim()) {
      Ok(i) => i,
      _ => {
        println!("Bad input");
        height += 1;
        continue;
      },
    };
    if !(1..=9).contains(&i) {
      println!("Bad input, should be between 1 and 9");
      height += 1;
      continue;
    }
    let x = (i - 1) % 3;
    let y = (i - 1) / 3;
    {
      let row = table.get_mut_row(y).unwrap();
      if row.get_cell(x).unwrap().to_string() != EMPTY {
        println!("There's already someone there");
        height += 1;
        continue;
      }
      row.set_cell(cell!(current), x).unwrap();
    }
    for _ in 0..height {
      terminal.cursor_up().unwrap();
      terminal.delete_line().unwrap();
    }
    height = table.print_tty(false).unwrap();
    if check(&table) {
      return;
    }
    if current == CROSS {
      current = ROUND;
    } else {
      current = CROSS;
    }
  }
}

fn get(table: &Table, x: usize, y: usize) -> String {
  match table.get_row(y) {
    Some(r) => match r.get_cell(x) {
      Some(c) => c.to_string(),
      _ => EMPTY.to_string(),
    },
    _ => EMPTY.to_string(),
  }
}

pub fn get_mut_cell(&mut self, idx: usize) -> Option<&mut Cell>

Get the mutable cell at index idx

pub fn set_cell(&mut self, cell: Cell, idx: usize) -> Result<(), &str>

Set the cell in the row at the given idx index

Examples found in repository

examples/tictactoe.rs (line 54)

fn main() {
  let mut table = table![
    [EMPTY, EMPTY, EMPTY],
    [EMPTY, EMPTY, EMPTY],
    [EMPTY, EMPTY, EMPTY]
  ];
  let mut height = table.print_tty(false).unwrap();
  let stdin = io::stdin();
  let mut stdout = io::stdout();
  let mut current = CROSS;
  let mut terminal = term::stdout().unwrap();
  loop {
    let mut line = String::new();
    print!("{} plays > ", current);
    height += 1;
    stdout.flush().unwrap();
    stdin.read_line(&mut line).expect("Cannot read input");
    let i = match usize::from_str(line.trim()) {
      Ok(i) => i,
      _ => {
        println!("Bad input");
        height += 1;
        continue;
      },
    };
    if !(1..=9).contains(&i) {
      println!("Bad input, should be between 1 and 9");
      height += 1;
      continue;
    }
    let x = (i - 1) % 3;
    let y = (i - 1) / 3;
    {
      let row = table.get_mut_row(y).unwrap();
      if row.get_cell(x).unwrap().to_string() != EMPTY {
        println!("There's already someone there");
        height += 1;
        continue;
      }
      row.set_cell(cell!(current), x).unwrap();
    }
    for _ in 0..height {
      terminal.cursor_up().unwrap();
      terminal.delete_line().unwrap();
    }
    height = table.print_tty(false).unwrap();
    if check(&table) {
      return;
    }
    if current == CROSS {
      current = ROUND;
    } else {
      current = CROSS;
    }
  }
}

pub fn add_cell(&mut self, cell: Cell)

Append a cell at the end of the row

pub fn insert_cell(&mut self, index: usize, cell: Cell)

Insert cell at position index. If index is higher than the row length, the cell will be appended at the end

pub fn remove_cell(&mut self, index: usize)

Remove the cell at position index. Silently skip if this cell does not exist

pub fn iter(&self) -> Iter<'_, Cell>

Returns an immutable iterator over cells

pub fn iter_mut(&mut self) -> IterMut<'_, Cell>

Returns an mutable iterator over cells

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

Print the row in HTML format to out.

If the row is has fewer columns than col_num, the row is padded with empty cells.

Trait Implementations

impl Clone for Row

fn clone(&self) -> Row

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Row

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

Formats the value using the given formatter.

impl Default for Row

fn default() -> Row

Returns the “default value” for a type.

impl<S: ToString> Extend<S> for Row

fn extend<T: IntoIterator<Item = S>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, A> From<T> for Row

where A: ToString, T: IntoIterator<Item = A>,

fn from(it: T) -> Row

Converts to this type from the input type.

impl<A: ToString> FromIterator<A> for Row

fn from_iter<T>(iterator: T) -> Row

where T: IntoIterator<Item = A>,

Creates a value from an iterator.

impl FromIterator<Row> for Table

fn from_iter<T>(iterator: T) -> Table

where T: IntoIterator<Item = Row>,

Creates a value from an iterator.

impl Hash for Row

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 Index<usize> for Row

type Output = Cell

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Row

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Row

type Item = &'a Cell

The type of the elements being iterated over.

type IntoIter = Iter<'a, Cell>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Row

type Item = &'a mut Cell

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Cell>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Row

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

impl StructuralPartialEq for Row