Enum AlignmentStrategy

pub enum AlignmentStrategy {
    PerCell,
    PerLine,
}

AlignmentStrategy is a responsible for a flow how we apply an alignment. It mostly matters for multiline strings.

Examples

use tabled::{
    Table,
    settings::{
        Style, Modify, Alignment, object::Segment,
        formatting::{AlignmentStrategy, TrimStrategy}
    }
};

// sample_from: https://opensource.adobe.com/Spry/samples/data_region/JSONDataSetSample.html
let json = r#"
{
    "id": "0001",
    "type": "donut",
    "name": "Cake",
    "ppu": 0.55,
    "batters": {
        "batter": [
            { "id": "1001", "type": "Regular" },
            { "id": "1002", "type": "Chocolate" },
        ]
    },
    "topping": [
        { "id": "5001", "type": "None" },
        { "id": "5006", "type": "Chocolate with Sprinkles" },
        { "id": "5003", "type": "Chocolate" },
        { "id": "5004", "type": "Maple" }
    ]
}"#;

let mut table = Table::new(&[json]);
table
    .with(Style::modern())
    .with(Modify::new(Segment::all()).with(Alignment::right()))
    .with(Modify::new(Segment::all()).with(TrimStrategy::None));

println!("{}", table);

assert_eq!(
    format!("\n{}", table),
    r#"
┌───────────────────────────────────────────────────────────────┐
│                                                          &str │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│ {                                                             │
│     "id": "0001",                                             │
│     "type": "donut",                                          │
│     "name": "Cake",                                           │
│     "ppu": 0.55,                                              │
│     "batters": {                                              │
│         "batter": [                                           │
│             { "id": "1001", "type": "Regular" },              │
│             { "id": "1002", "type": "Chocolate" },            │
│         ]                                                     │
│     },                                                        │
│     "topping": [                                              │
│         { "id": "5001", "type": "None" },                     │
│         { "id": "5006", "type": "Chocolate with Sprinkles" }, │
│         { "id": "5003", "type": "Chocolate" },                │
│         { "id": "5004", "type": "Maple" }                     │
│     ]                                                         │
│ }                                                             │
└───────────────────────────────────────────────────────────────┘"#);

table
    .with(Modify::new(Segment::all()).with(AlignmentStrategy::PerCell))
    .with(Modify::new(Segment::all()).with(TrimStrategy::Horizontal));

assert_eq!(
    format!("\n{}", table),
    r#"
┌───────────────────────────────────────────────────────────────┐
│                                                          &str │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│         {                                                     │
│         "id": "0001",                                         │
│         "type": "donut",                                      │
│         "name": "Cake",                                       │
│         "ppu": 0.55,                                          │
│         "batters": {                                          │
│         "batter": [                                           │
│         { "id": "1001", "type": "Regular" },                  │
│         { "id": "1002", "type": "Chocolate" },                │
│         ]                                                     │
│         },                                                    │
│         "topping": [                                          │
│         { "id": "5001", "type": "None" },                     │
│         { "id": "5006", "type": "Chocolate with Sprinkles" }, │
│         { "id": "5003", "type": "Chocolate" },                │
│         { "id": "5004", "type": "Maple" }                     │
│         ]                                                     │
│         }                                                     │
└───────────────────────────────────────────────────────────────┘"#);

table.with(Modify::new(Segment::all()).with(AlignmentStrategy::PerLine));

assert_eq!(
    format!("\n{}", table),
    r#"
┌───────────────────────────────────────────────────────────────┐
│                                                          &str │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│                                                             { │
│                                                 "id": "0001", │
│                                              "type": "donut", │
│                                               "name": "Cake", │
│                                                  "ppu": 0.55, │
│                                                  "batters": { │
│                                                   "batter": [ │
│                          { "id": "1001", "type": "Regular" }, │
│                        { "id": "1002", "type": "Chocolate" }, │
│                                                             ] │
│                                                            }, │
│                                                  "topping": [ │
│                             { "id": "5001", "type": "None" }, │
│         { "id": "5006", "type": "Chocolate with Sprinkles" }, │
│                        { "id": "5003", "type": "Chocolate" }, │
│                             { "id": "5004", "type": "Maple" } │
│                                                             ] │
│                                                             } │
└───────────────────────────────────────────────────────────────┘"#);

Variants

PerCell

Apply alignment for cell content as a whole.

PerLine

Apply alignment for each line of a cell content as a whole.

Trait Implementations

impl<R> CellOption<R, ColoredConfig> for AlignmentStrategy

fn change(self, _: &mut R, cfg: &mut ColoredConfig, entity: Entity)

Modification function of a certail part of a grid targeted by Entity.

fn hint_change(&self) -> Option<Entity>

A hint whether an TableOption is going to change table layout.

impl Clone for AlignmentStrategy

fn clone(&self) -> AlignmentStrategy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlignmentStrategy

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

Formats the value using the given formatter.

impl Ord for AlignmentStrategy

fn cmp(&self, other: &AlignmentStrategy) -> 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 AlignmentStrategy

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

fn partial_cmp(&self, other: &AlignmentStrategy) -> 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<R, D> TableOption<R, ColoredConfig, D> for AlignmentStrategy

fn change(self, records: &mut R, cfg: &mut ColoredConfig, _: &mut D)

The function modificaties of records and a grid configuration.

fn hint_change(&self) -> Option<Entity>

A hint whether an TableOption is going to change table layout.

impl<R, D> TableOption<R, CompactMultilineConfig, D> for AlignmentStrategy

fn change(self, _: &mut R, cfg: &mut CompactMultilineConfig, _: &mut D)

The function modificaties of records and a grid configuration.

fn hint_change(&self) -> Option<Entity>

A hint whether an TableOption is going to change table layout.

impl Copy for AlignmentStrategy

impl Eq for AlignmentStrategy

impl StructuralPartialEq for AlignmentStrategy