Enum Alignment 

pub enum Alignment {
    Left,
    Right,
    CenterLeft,
    CenterRight,
}

Where the place the pad blocks.

Variants

Left

Pad to the right, content to the left.

Example:

use zero_copy_pads::{Alignment::Left, PaddedValue, PanicOnExcess};
let padded_value = PaddedValue {
    pad: Left,
    value: "abcdef",
    pad_block: '-',
    total_width: 9,
    handle_excess: PanicOnExcess,
};
assert_eq!(padded_value.to_string(), "abcdef---");

Right

Pad to the left, content to the right.

Example:

use zero_copy_pads::{Alignment::Right, PaddedValue, PanicOnExcess};
let padded_value = PaddedValue {
    pad: Right,
    value: "abcdef",
    pad_block: '-',
    total_width: 9,
    handle_excess: PanicOnExcess,
};
assert_eq!(padded_value.to_string(), "---abcdef");

CenterLeft

Pad to both sides, place content in the middle, but shift to the left one block if it can’t be exactly central.

Example:

use zero_copy_pads::{Alignment::CenterLeft, PaddedColumn, PanicOnExcess};
let values = [
    "Rust", "C", "C++", "C#", "JavaScript",
    "TypeScript", "Java", "Kotlin", "Go",
];
let padded_column = PaddedColumn {
    pad: CenterLeft,
    values: values.iter(),
    pad_block: '-',
};
let padded_values: Vec<_> = padded_column
    .into_iter()
    .map(|x| x.to_string())
    .collect();
let expected = [
    "---Rust---", "----C-----", "---C++----",
    "----C#----", "JavaScript", "TypeScript",
    "---Java---", "--Kotlin--", "----Go----",
];
assert_eq!(padded_values, expected);

CenterRight

Pad to both sides, place content in the middle, but shift to the right one block if it can’t be exactly central.

Example:

use zero_copy_pads::{Alignment::CenterRight, PaddedColumn, PanicOnExcess};
let values = [
    "Rust", "C", "C++", "C#", "JavaScript",
    "TypeScript", "Java", "Kotlin", "Go",
];
let padded_column = PaddedColumn {
    pad: CenterRight,
    values: values.iter(),
    pad_block: '-',
};
let padded_values: Vec<_> = padded_column
    .into_iter()
    .map(|x| x.to_string())
    .collect();
let expected = [
    "---Rust---", "-----C----", "----C++---",
    "----C#----", "JavaScript", "TypeScript",
    "---Java---", "--Kotlin--", "----Go----",
];
assert_eq!(padded_values, expected);

Trait Implementations

impl Clone for Alignment

fn clone(&self) -> Alignment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Alignment

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

Formats the value using the given formatter.

impl<Value: Width, PadBlock: Display> Pad<Value, PadBlock> for Alignment

fn fmt( &self, formatter: &mut Formatter<'_>, value: &Value, pad_block: &PadBlock, pad_width: usize, ) -> Result<(), Error>

Pad a value knowing the number of blocks.

impl PartialEq for Alignment

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

impl Eq for Alignment

impl StructuralPartialEq for Alignment