Enum BorderStyle 

pub enum BorderStyle {
    None,
    Single,
    Double,
    Round,
    Bold,
    SingleDouble,
    DoubleSingle,
    Classic,
    Arrow,
}

Available box drawing styles with semantic meaning and use cases.

Each style provides a different visual appearance optimized for specific use cases. This enum provides a convenient, type-safe way to select box styles without directly referencing character constants.

Style Guidelines

• Single: Default choice for most applications, clean and readable
• Double: Use for emphasis, headers, or important content sections
• Round: Modern appearance, good for user-friendly interfaces
• Bold: Maximum emphasis, warnings, or critical information
• Mixed Styles: Unique visual effects, decorative purposes
• Classic: ASCII-only environments, legacy system compatibility
• Arrow: Special effects, directional indicators, creative designs
• None: Invisible spacing, layout without visible borders

Performance Notes

All enum variants are zero-cost abstractions that compile to direct character constants. String parsing is optimized for performance with zero heap allocations.

Examples

Basic Usage

use cli_boxes::{BorderStyle, BoxChars};

// Convert enum to box characters
let box_chars = BoxChars::from(BorderStyle::Single);
assert_eq!(box_chars.top_left, '┌');

// Using the convenience method
let double_chars = BorderStyle::Double.chars();
assert_eq!(double_chars.top_left, '╔');

Dynamic Style Selection

use cli_boxes::BorderStyle;

fn get_style_for_severity(level: u8) -> BorderStyle {
    match level {
        0 => BorderStyle::None,
        1 => BorderStyle::Single,
        2 => BorderStyle::Bold,
        3 => BorderStyle::Double,
        _ => BorderStyle::Classic,
    }
}

let style = get_style_for_severity(2);
let chars = style.chars();

Iteration and Discovery

use cli_boxes::BorderStyle;

// Display all available styles
for style in BorderStyle::all() {
    let chars = style.chars();
    println!("{:12} -> {}", style.to_string(), chars);
}

String Parsing with Error Handling

use cli_boxes::BorderStyle;
use std::str::FromStr;

// Parse from configuration files or user input
let styles = ["single", "double", "round", "invalid"];

for style_str in &styles {
    match style_str.parse::<BorderStyle>() {
        Ok(style) => println!("✓ Parsed '{}' as {:?}", style_str, style),
        Err(e) => println!("✗ Error: {}", e),
    }
}

Variants

None

No box characters (all spaces)

Single

Single-line box drawing characters: ┌─┐│┘─└│

Double

Double-line box drawing characters: ╔═╗║╝═╚║

Round

Rounded corner box drawing characters: ╭─╮│╯─╰│

Bold

Bold/thick line box drawing characters: ┏━┓┃┛━┗┃

SingleDouble

Single horizontal, double vertical: ╓─╖║╜─╙║

DoubleSingle

Double horizontal, single vertical: ╒═╕│╛═╘│

Classic

ASCII-compatible classic box characters: +─+|+─+|

Arrow

Arrow-based decorative box characters: ↘↓↙←↖↑↗→

Implementations

impl BorderStyle

pub fn chars(self) -> BoxChars

Returns the BoxChars associated with this border style.

This is a convenience method that’s equivalent to BoxChars::from(style).

Examples

use cli_boxes::BorderStyle;

let style = BorderStyle::Bold;
let chars = style.chars();
assert_eq!(chars.top, '━');

pub fn all() -> impl Iterator<Item = Self>

Returns an iterator over all available border styles.

This is a convenience method that uses the EnumIter trait.

Examples

use cli_boxes::BorderStyle;

for style in BorderStyle::all() {
    println!("Style: {:?}", style);
}

Trait Implementations

impl Clone for BorderStyle

fn clone(&self) -> BorderStyle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BorderStyle

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

Formats the value using the given formatter.

impl Display for BorderStyle

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

Formats the border style as a lowercase string.

Examples

use cli_boxes::BorderStyle;

assert_eq!(BorderStyle::Single.to_string(), "single");
assert_eq!(BorderStyle::DoubleSingle.to_string(), "double_single");
assert_eq!(BorderStyle::Arrow.to_string(), "arrow");

impl From<BorderStyle> for BoxChars

fn from(style: BorderStyle) -> Self

Converts a BorderStyle enum variant to its corresponding BoxChars.

Examples

use cli_boxes::{BorderStyle, BoxChars};

let single_chars = BoxChars::from(BorderStyle::Single);
assert_eq!(single_chars, BoxChars::SINGLE);

let double_chars = BoxChars::from(BorderStyle::Double);
assert_eq!(double_chars, BoxChars::DOUBLE);

impl FromStr for BorderStyle

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string into a BorderStyle.

The parsing is case-insensitive and accepts both snake_case and kebab-case. This implementation is optimized to avoid heap allocations.

Examples

use std::str::FromStr;
use cli_boxes::BorderStyle;

assert_eq!("single".parse::<BorderStyle>().unwrap(), BorderStyle::Single);
assert_eq!("DOUBLE".parse::<BorderStyle>().unwrap(), BorderStyle::Double);
assert_eq!("single-double".parse::<BorderStyle>().unwrap(), BorderStyle::SingleDouble);
assert_eq!("double_single".parse::<BorderStyle>().unwrap(), BorderStyle::DoubleSingle);

// Error case
assert!("invalid".parse::<BorderStyle>().is_err());

type Err = ParseBorderStyleError

The associated error which can be returned from parsing.

impl Hash for BorderStyle

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 IntoEnumIterator for BorderStyle

type Iterator = BorderStyleIter

fn iter() -> BorderStyleIter

impl PartialEq for BorderStyle

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

impl Eq for BorderStyle

impl StructuralPartialEq for BorderStyle