Struct colorz::StyledValue

#[non_exhaustive]
pub struct StyledValue<T, F = NoColor, B = NoColor, U = NoColor> {
    pub value: T,
    pub style: Style<F, B, U>,
    pub stream: Option<Stream>,
}

A styled value, created from Colorize or StyledValue::new

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

value: T

The value to style

style: Style<F, B, U>

The style to use

stream: Option<Stream>

The stream to use

Implementations

impl<T, F, B, U> StyledValue<T, F, B, U>

pub const fn new( value: T, style: Style<F, B, U>, stream: Option<Stream> ) -> Self

Create a new styled value

impl<T, F: OptionalColor, B: OptionalColor, U: OptionalColor> StyledValue<T, F, B, U>

pub const fn style(&self) -> StyledValue<&Self>

Wrap this styled value in another one (this allows setting conditional formatting differently for each layer)

pub const fn into_style(self) -> StyledValue<Self>

Wrap this styled value in another one (this allows setting conditional formatting differently for each layer)

pub fn fg<C>(self, color: C) -> StyledValue<T, C, B, U>

Change the foreground color

pub fn bg<C>(self, color: C) -> StyledValue<T, F, C, U>

Change the background color

pub fn underline_color<C>(self, color: C) -> StyledValue<T, F, B, C>

Change the underline color

pub fn black(self) -> StyledValue<T, Black, B, U>

Changes the foreground to black

pub fn red(self) -> StyledValue<T, Red, B, U>

Changes the foreground to red

pub fn green(self) -> StyledValue<T, Green, B, U>

Changes the foreground to green

pub fn yellow(self) -> StyledValue<T, Yellow, B, U>

Changes the foreground to yellow

pub fn blue(self) -> StyledValue<T, Blue, B, U>

Changes the foreground to blue

pub fn magenta(self) -> StyledValue<T, Magenta, B, U>

Changes the foreground to magenta

pub fn cyan(self) -> StyledValue<T, Cyan, B, U>

Changes the foreground to cyan

pub fn white(self) -> StyledValue<T, White, B, U>

Changes the foreground to white

pub fn bright_black(self) -> StyledValue<T, BrightBlack, B, U>

Changes the foreground to bright black

pub fn bright_red(self) -> StyledValue<T, BrightRed, B, U>

Changes the foreground to bright red

pub fn bright_green(self) -> StyledValue<T, BrightGreen, B, U>

Changes the foreground to bright green

pub fn bright_yellow(self) -> StyledValue<T, BrightYellow, B, U>

Changes the foreground to bright yellow

pub fn bright_blue(self) -> StyledValue<T, BrightBlue, B, U>

Changes the foreground to bright blue

pub fn bright_magenta(self) -> StyledValue<T, BrightMagenta, B, U>

Changes the foreground to bright magenta

pub fn bright_cyan(self) -> StyledValue<T, BrightCyan, B, U>

Changes the foreground to bright cyan

pub fn bright_white(self) -> StyledValue<T, BrightWhite, B, U>

Changes the foreground to bright white

pub fn on_black(self) -> StyledValue<T, F, Black, U>

Changes the background to black

pub fn on_red(self) -> StyledValue<T, F, Red, U>

Changes the background to red

pub fn on_green(self) -> StyledValue<T, F, Green, U>

Changes the background to green

pub fn on_yellow(self) -> StyledValue<T, F, Yellow, U>

Changes the background to yellow

pub fn on_blue(self) -> StyledValue<T, F, Blue, U>

Changes the background to blue

pub fn on_magenta(self) -> StyledValue<T, F, Magenta, U>

Changes the background to magenta

pub fn on_cyan(self) -> StyledValue<T, F, Cyan, U>

Changes the background to cyan

pub fn on_white(self) -> StyledValue<T, F, White, U>

Changes the background to white

Examples found in repository

examples/colors.rs (line 37)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

pub fn on_bright_black(self) -> StyledValue<T, F, BrightBlack, U>

Changes the background to bright black

pub fn on_bright_red(self) -> StyledValue<T, F, BrightRed, U>

Changes the background to bright red

pub fn on_bright_green(self) -> StyledValue<T, F, BrightGreen, U>

Changes the background to bright green

pub fn on_bright_yellow(self) -> StyledValue<T, F, BrightYellow, U>

Changes the background to bright yellow

pub fn on_bright_blue(self) -> StyledValue<T, F, BrightBlue, U>

Changes the background to bright blue

pub fn on_bright_magenta(self) -> StyledValue<T, F, BrightMagenta, U>

Changes the background to bright magenta

pub fn on_bright_cyan(self) -> StyledValue<T, F, BrightCyan, U>

Changes the background to bright cyan

pub fn on_bright_white(self) -> StyledValue<T, F, BrightWhite, U>

Changes the background to bright white

pub fn bold(self) -> StyledValue<T, F, B, U>

Applies the bold effect

pub fn dimmed(self) -> StyledValue<T, F, B, U>

Applies the dimmed effect

pub fn italics(self) -> StyledValue<T, F, B, U>

Applies the italics effect

pub fn underline(self) -> StyledValue<T, F, B, U>

Applies the underline effect

pub fn double_underline(self) -> StyledValue<T, F, B, U>

Applies the double underline effect

pub fn blink(self) -> StyledValue<T, F, B, U>

Applies the blink effect

pub fn blink_fast(self) -> StyledValue<T, F, B, U>

Applies the blink fast effect

pub fn reverse(self) -> StyledValue<T, F, B, U>

Applies the reverse effect

pub fn hide(self) -> StyledValue<T, F, B, U>

Applies the hide effect

pub fn strikethrough(self) -> StyledValue<T, F, B, U>

Applies the strikethrough effect

pub fn overline(self) -> StyledValue<T, F, B, U>

Applies the overline effect

pub fn superscript(self) -> StyledValue<T, F, B, U>

Applies the superscript effect

pub fn subscript(self) -> StyledValue<T, F, B, U>

Applies the subscript effect

pub const fn stream(self, stream: Stream) -> Self

Sets the stream for the given value

Examples found in repository

examples/mode.rs (line 35)

fn main() {
    // NOTE: this example uses `stream(Stderr)` even though it's writing
    // to stdout to make it easier to see how `mode::Mode::Detect` works
    // try running this command wihtout redirecting stderr and while
    // redirecting stderr to `/dev/null` (or some file) to see how it
    // colors things differently
    //
    // ```
    // cargo run --example mode
    // cargo run --example mode 2> /dev/null
    //
    // cargo run --example mode --features strip-colors
    // cargo run --example mode --features strip-colors 2> /dev/null
    // ```
    //
    // NOTE: that colorz currently uses `std::io::IsTerminal` to detect
    // if stdin/stderr/stdout have been redirected

    assert_eq!(mode::get_default_stream(), AlwaysColor);

    mode::set_default_stream(Stderr);

    assert_eq!(mode::get_default_stream(), Stderr);

    #[cfg(feature = "std")]
    {
        mode::set_coloring_mode_from_env();
        println!("{}", "blue stderr".blue());
        println!("{}", "blue stdout".blue().stream(Stdout));
        println!("{}", "blue always".blue().stream(AlwaysColor));
        println!("{}", "blue never".blue().stream(NeverColor));
    }

    println!("color mode=always");
    mode::set_coloring_mode(mode::Mode::Always);
    println!("{}", "blue stderr".blue());
    println!("{}", "blue stdout".blue().stream(Stdout));
    println!("{}", "blue always".blue().stream(AlwaysColor));
    println!("{}", "blue never".blue().stream(NeverColor));

    println!("color mode=detect");
    mode::set_coloring_mode(mode::Mode::Detect);
    println!("{}", "blue stderr".blue());
    println!("{}", "blue stdout".blue().stream(Stdout));
    println!("{}", "blue always".blue().stream(AlwaysColor));
    println!("{}", "blue never".blue().stream(NeverColor));

    println!("color mode=never");
    mode::set_coloring_mode(mode::Mode::Never);
    println!("{}", "blue stderr".blue());
    println!("{}", "blue stdout".blue().stream(Stdout));
    println!("{}", "blue always".blue().stream(AlwaysColor));
    println!("{}", "blue never".blue().stream(NeverColor));
}

pub const fn stream_opt(self, stream: Option<Stream>) -> Self

Sets the stream for the given value

impl<T, F: OptionalColor, B: OptionalColor, U: OptionalColor> StyledValue<T, F, B, U>

pub fn fmt_with( &self, fmt: &mut Formatter<'_>, f: impl FnOnce(&T, &mut Formatter<'_>) -> Result ) -> Result

Writes a styled value with the given value formatter

Trait Implementations

impl<T: Binary, F: OptionalColor, B: OptionalColor, U: OptionalColor> Binary for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: Clone, F: Clone, B: Clone, U: Clone> Clone for StyledValue<T, F, B, U>

fn clone(&self) -> StyledValue<T, F, B, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, F: OptionalColor, B: OptionalColor, U: OptionalColor> Debug for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: Display, F: OptionalColor, B: OptionalColor, U: OptionalColor> Display for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: LowerExp, F: OptionalColor, B: OptionalColor, U: OptionalColor> LowerExp for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: LowerHex, F: OptionalColor, B: OptionalColor, U: OptionalColor> LowerHex for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: Octal, F: OptionalColor, B: OptionalColor, U: OptionalColor> Octal for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: Pointer, F: OptionalColor, B: OptionalColor, U: OptionalColor> Pointer for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: UpperExp, F: OptionalColor, B: OptionalColor, U: OptionalColor> UpperExp for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: UpperHex, F: OptionalColor, B: OptionalColor, U: OptionalColor> UpperHex for StyledValue<T, F, B, U>

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

Formats the value using the given formatter.

impl<T: Copy, F: Copy, B: Copy, U: Copy> Copy for StyledValue<T, F, B, U>