Struct BoxChars 

pub struct BoxChars {
    pub top_left: char,
    pub top: char,
    pub top_right: char,
    pub right: char,
    pub bottom_right: char,
    pub bottom: char,
    pub bottom_left: char,
    pub left: char,
}

A collection of Unicode characters used for drawing boxes in CLI applications.

This struct contains all the necessary characters to draw a complete box: corners, horizontal lines, and vertical lines. Each field represents a specific position in the box structure.

Box Structure

top_left ──── top ──── top_right
   │                      │
  left                  right
   │                      │
bottom_left ── bottom ── bottom_right

Memory Layout

BoxChars is a compact struct containing 8 char values (32 bytes total on most platforms). All predefined constants are evaluated at compile time for zero runtime cost.

Thread Safety

BoxChars implements Send and Sync, making it safe to use across threads. All operations are immutable after construction.

Examples

Using Predefined Styles

use cli_boxes::BoxChars;

// Use predefined single-line box characters
let single = BoxChars::SINGLE;
assert_eq!(single.top_left, '┌');
assert_eq!(single.top, '─');
assert_eq!(single.top_right, '┐');

// Double-line for emphasis
let double = BoxChars::DOUBLE;
assert_eq!(double.top_left, '╔');

Custom Box Creation

use cli_boxes::BoxChars;

// Direct constructor
let custom = BoxChars::new('*', '-', '*', '|', '*', '-', '*', '|');

// Builder pattern (recommended for readability)
let builder_box = BoxChars::builder()
    .corners('*')
    .horizontal('-')
    .vertical('|')
    .build();

assert_eq!(custom, builder_box);

Drawing a Complete Box

use cli_boxes::BoxChars;

fn draw_box(chars: &BoxChars, width: usize, height: usize) -> String {
    let mut result = String::new();
     
    // Top border
    result.push(chars.top_left);
    result.push_str(&chars.top.to_string().repeat(width.saturating_sub(2)));
    result.push(chars.top_right);
    result.push('\n');
     
    // Side borders
    for _ in 0..height.saturating_sub(2) {
        result.push(chars.left);
        result.push_str(&" ".repeat(width.saturating_sub(2)));
        result.push(chars.right);
        result.push('\n');
    }
     
    // Bottom border
    result.push(chars.bottom_left);
    result.push_str(&chars.bottom.to_string().repeat(width.saturating_sub(2)));
    result.push(chars.bottom_right);
     
    result
}

let box_str = draw_box(&BoxChars::SINGLE, 5, 3);
println!("{}", box_str);
// Output:
// ┌───┐
// │   │
// └───┘

Fields

top_left: char

Top-left corner character

top: char

Top border character (repeated horizontally)

top_right: char

Top-right corner character

right: char

Right border character (repeated vertically)

bottom_right: char

Bottom-right corner character

bottom: char

Bottom border character (repeated horizontally)

bottom_left: char

Bottom-left corner character

left: char

Left border character (repeated vertically)

Implementations

impl BoxChars

pub const NONE: Self

Creates a box with no visible characters (all spaces).

This is useful when you want to maintain box structure without visible borders, or as a fallback when no box styling is desired.

pub const SINGLE: Self

Creates a box using single-line Unicode box-drawing characters.

This is the most commonly used box style, providing clean and professional-looking borders that work well in most terminal environments.

Characters used: ┌─┐│┘─└│

pub const DOUBLE: Self

Creates a box using double-line Unicode box-drawing characters.

This style provides a bold, prominent appearance that’s excellent for highlighting important content or creating emphasis in CLI applications.

Characters used: ╔═╗║╝═╚║

pub const ROUND: Self

Creates a box using rounded corner Unicode box-drawing characters.

This style provides a softer, more modern appearance with curved corners that’s aesthetically pleasing and less harsh than sharp corners.

Characters used: ╭─╮│╯─╰│

pub const BOLD: Self

Creates a box using bold/thick line Unicode box-drawing characters.

This style provides maximum visual impact with thick, bold lines that command attention and create strong visual separation.

Characters used: ┏━┓┃┛━┗┃

pub const SINGLE_DOUBLE: Self

Creates a box using single horizontal, double vertical box-drawing characters.

This mixed style combines single-line horizontal borders with double-line vertical borders, creating a unique visual effect.

Characters used: ╓─╖║╜─╙║

pub const DOUBLE_SINGLE: Self

Creates a box using double horizontal, single vertical box-drawing characters.

This mixed style combines double-line horizontal borders with single-line vertical borders, creating an alternative visual effect to SINGLE_DOUBLE.

Characters used: ╒═╕│╛═╘│

pub const CLASSIC: Self

Creates a box using classic ASCII characters for maximum compatibility.

This style uses only basic ASCII characters, ensuring compatibility with all terminal environments, including those that don’t support Unicode.

Characters used: +-+|+-+|

pub const ARROW: Self

Creates a decorative box using arrow Unicode characters.

This unique style uses directional arrows to create an unconventional but eye-catching border effect. Best used for special emphasis or creative CLI applications.

Characters used: ↘↓↙←↖↑↗→

pub const fn new( top_left: char, top: char, top_right: char, right: char, bottom_right: char, bottom: char, bottom_left: char, left: char, ) -> Self

Creates a new BoxChars with the specified characters.

Arguments

• top_left - Top-left corner character
• top - Top border character
• top_right - Top-right corner character
• right - Right border character
• bottom_right - Bottom-right corner character
• bottom - Bottom border character
• bottom_left - Bottom-left corner character
• left - Left border character

Examples

use cli_boxes::BoxChars;

let custom = BoxChars::new('*', '-', '*', '|', '*', '-', '*', '|');
assert_eq!(custom.top_left, '*');
assert_eq!(custom.top, '-');

pub fn builder() -> BoxCharsBuilder

Creates a builder for constructing custom box characters.

Examples

use cli_boxes::BoxChars;

let custom = BoxChars::builder()
    .corners('*')
    .horizontal('-')
    .vertical('|')
    .build();

Trait Implementations

impl Clone for BoxChars

fn clone(&self) -> BoxChars

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoxChars

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

Formats the value using the given formatter.

impl Default for BoxChars

fn default() -> Self

Returns the default box characters (single-line style).

Examples

use cli_boxes::BoxChars;

let default_box = BoxChars::default();
assert_eq!(default_box, BoxChars::SINGLE);

impl<'de> Deserialize<'de> for BoxChars

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BoxChars

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

Formats the box characters as a string showing all 8 characters in order.

The format is: top_left, top, top_right, right, bottom_right, bottom, bottom_left, left

Examples

use cli_boxes::BoxChars;

let single = BoxChars::SINGLE;
println!("{}", single); // Outputs: ┌─┐│┘─└│

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 Hash for BoxChars

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 BoxChars

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BoxChars

impl Eq for BoxChars

impl StructuralPartialEq for BoxChars