Struct Style 

pub struct Style(/* private fields */);

A combinatorial style such as bold, italics, dimmed, etc.

Creation

Style::default() returns a Style with no style switches activated and is the default method of creating a plain Style.

Style from a set of Styless / Styles iterator

Style implements FromIter<Styles> which means that it is possible to do the following:

let style = Style::from_iter([Styles::Bold, Styles::Italic, Styles::Strikethrough]);
for styles in [Styles::Bold, Styles::Italic, Styles::Strikethrough] {
    assert!(style.contains(styles));
}

As you can see, this is a good thing to keep in mind, although for most cases, where you’re not setting styles dynamically and are simply creating a pre-defined set of styles, using Default and then using the builder-style methods is likely prettier.

let many_styles = Style::default()
    .bold()
    .underline()
    .italic()
    .blink();

Implementation of logical bitwise operators

Style implements bitwise logical operations that operate on the held style switches collectively. By far the most common and useful is the bitwise ‘or’ operator | which combines two styles, merging their combined styles into one. Example:

let only_bold = Style::from(Styles::Bold);
// This line is actually an example of `Styles`'s bitwise logic impls but still.
let underline_and_italic = Styles::Underline | Styles::Italic;
let all_three = only_bold | underline_and_italic;

assert!(all_three.contains(Styles::Bold)
    && all_three.contains(Styles::Underline)
    && all_three.contains(Styles::Italic));

This functionality also allows for easily turning off styles of one Styles using another by combining the & and ! operators.

let mut very_loud_style = Style::default()
    .bold()
    .underline()
    .italic()
    .strikethrough()
    .hidden();

// Oops! Some of those should not be in there!
// This Style now has all styles _except_ the two we don't want
// (hidden and strikethough).
let remove_mask =
    !Style::from_iter([Styles::Hidden, Styles::Strikethrough]);
very_loud_style &= remove_mask;

// `very_loud_style` no longer contains the undesired style
// switches...
assert!(!very_loud_style.contains(Styles::Hidden)
    && !very_loud_style.contains(Styles::Strikethrough));
// ...but it retains everything else!
assert!(very_loud_style.contains(Styles::Bold));

Implementations

impl Style

pub fn contains(self, style: Styles) -> bool

Check if the current style has one of Styles switched on.

let colored = "".bold().italic();
assert_eq!(colored.style.contains(Styles::Bold), true);
assert_eq!(colored.style.contains(Styles::Italic), true);
assert_eq!(colored.style.contains(Styles::Dimmed), false);

pub fn add(&mut self, two: Styles)

Adds the two style switch to this Style.

let cstr = "".red().bold();
let mut style = cstr.style;
style.add(Styles::Italic);
let mut cstr2 = "".blue();
cstr2.style = style;

assert!(cstr2.style.contains(Styles::Bold));
assert!(cstr2.style.contains(Styles::Italic));
assert_eq!(cstr2.fgcolor, Some(Color::Blue));

pub fn remove(&mut self, two: Styles)

Turns off a style switch.

use colored::*;
let cstr = "".red().bold().italic();
let mut style = cstr.style;
style.remove(Styles::Italic);
let mut cstr2 = "".blue();
cstr2.style = style;
assert!(cstr2.style.contains(Styles::Bold));
assert!(!cstr2.style.contains(Styles::Italic));
assert_eq!(cstr2.fgcolor, Some(Color::Blue));

pub fn bold(self) -> Style

Makes this Style include Bold.

pub fn dimmed(self) -> Style

Makes this Style include Dimmed.

pub fn underline(self) -> Style

Makes this Style include Underline.

pub fn reversed(self) -> Style

Makes this Style include Reversed.

pub fn italic(self) -> Style

Makes this Style include Italic.

pub fn blink(self) -> Style

Makes this Style include Blink.

pub fn hidden(self) -> Style

Makes this Style include Hidden.

pub fn strikethrough(self) -> Style

Makes this Style include Strikethrough.

Trait Implementations

impl BitAnd<&Style> for &Style

type Output = <Style as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Style) -> <&Style as BitAnd<&Style>>::Output

Performs the & operation.

impl BitAnd<&Style> for &Styles

type Output = <Styles as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Style) -> <&Styles as BitAnd<&Style>>::Output

Performs the & operation.

impl BitAnd<&Style> for Style

type Output = <Style as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Style) -> <Style as BitAnd<&Style>>::Output

Performs the & operation.

impl BitAnd<&Style> for Styles

type Output = <Styles as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Style) -> <Styles as BitAnd<&Style>>::Output

Performs the & operation.

impl BitAnd<&Styles> for &Style

type Output = <Style as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Styles) -> <&Style as BitAnd<&Styles>>::Output

Performs the & operation.

impl BitAnd<&Styles> for Style

type Output = <Style as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Styles) -> <Style as BitAnd<&Styles>>::Output

Performs the & operation.

impl BitAnd<Style> for &Style

type Output = <Style as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Style) -> <&Style as BitAnd<Style>>::Output

Performs the & operation.

impl BitAnd<Style> for &Styles

type Output = <Styles as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Style) -> <&Styles as BitAnd<Style>>::Output

Performs the & operation.

impl BitAnd<Style> for Styles

type Output = Style

The resulting type after applying the & operator.

fn bitand(self, rhs: Style) -> <Styles as BitAnd<Style>>::Output

Performs the & operation.

impl BitAnd<Styles> for &Style

type Output = <Style as BitAnd>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Styles) -> <&Style as BitAnd<Styles>>::Output

Performs the & operation.

impl BitAnd<Styles> for Style

type Output = Style

The resulting type after applying the & operator.

fn bitand(self, rhs: Styles) -> <Style as BitAnd<Styles>>::Output

Performs the & operation.

impl BitAnd for Style

type Output = Style

The resulting type after applying the & operator.

fn bitand(self, rhs: Style) -> <Style as BitAnd>::Output

Performs the & operation.

impl BitAndAssign<&Style> for Style

fn bitand_assign(&mut self, other: &Style)

Performs the &= operation.

impl BitAndAssign<&Styles> for Style

fn bitand_assign(&mut self, other: &Styles)

Performs the &= operation.

impl BitAndAssign<Styles> for Style

fn bitand_assign(&mut self, other: Styles)

Performs the &= operation.

impl BitAndAssign for Style

fn bitand_assign(&mut self, other: Style)

Performs the &= operation.

impl BitOr<&Style> for &Style

type Output = <Style as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Style) -> <&Style as BitOr<&Style>>::Output

Performs the | operation.

impl BitOr<&Style> for &Styles

type Output = <Styles as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Style) -> <&Styles as BitOr<&Style>>::Output

Performs the | operation.

impl BitOr<&Style> for Style

type Output = <Style as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Style) -> <Style as BitOr<&Style>>::Output

Performs the | operation.

impl BitOr<&Style> for Styles

type Output = <Styles as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Style) -> <Styles as BitOr<&Style>>::Output

Performs the | operation.

impl BitOr<&Styles> for &Style

type Output = <Style as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Styles) -> <&Style as BitOr<&Styles>>::Output

Performs the | operation.

impl BitOr<&Styles> for Style

type Output = <Style as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Styles) -> <Style as BitOr<&Styles>>::Output

Performs the | operation.

impl BitOr<Style> for &Style

type Output = <Style as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Style) -> <&Style as BitOr<Style>>::Output

Performs the | operation.

impl BitOr<Style> for &Styles

type Output = <Styles as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Style) -> <&Styles as BitOr<Style>>::Output

Performs the | operation.

impl BitOr<Style> for Styles

type Output = Style

The resulting type after applying the | operator.

fn bitor(self, rhs: Style) -> <Styles as BitOr<Style>>::Output

Performs the | operation.

impl BitOr<Styles> for &Style

type Output = <Style as BitOr>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Styles) -> <&Style as BitOr<Styles>>::Output

Performs the | operation.

impl BitOr<Styles> for Style

type Output = Style

The resulting type after applying the | operator.

fn bitor(self, rhs: Styles) -> <Style as BitOr<Styles>>::Output

Performs the | operation.

impl BitOr for Style

type Output = Style

The resulting type after applying the | operator.

fn bitor(self, rhs: Style) -> <Style as BitOr>::Output

Performs the | operation.

impl BitOrAssign<&Style> for Style

fn bitor_assign(&mut self, other: &Style)

Performs the |= operation.

impl BitOrAssign<&Styles> for Style

fn bitor_assign(&mut self, other: &Styles)

Performs the |= operation.

impl BitOrAssign<Styles> for Style

fn bitor_assign(&mut self, other: Styles)

Performs the |= operation.

impl BitOrAssign for Style

fn bitor_assign(&mut self, other: Style)

Performs the |= operation.

impl BitXor<&Style> for &Style

type Output = <Style as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Style) -> <&Style as BitXor<&Style>>::Output

Performs the ^ operation.

impl BitXor<&Style> for &Styles

type Output = <Styles as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Style) -> <&Styles as BitXor<&Style>>::Output

Performs the ^ operation.

impl BitXor<&Style> for Style

type Output = <Style as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Style) -> <Style as BitXor<&Style>>::Output

Performs the ^ operation.

impl BitXor<&Style> for Styles

type Output = <Styles as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Style) -> <Styles as BitXor<&Style>>::Output

Performs the ^ operation.

impl BitXor<&Styles> for &Style

type Output = <Style as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Styles) -> <&Style as BitXor<&Styles>>::Output

Performs the ^ operation.

impl BitXor<&Styles> for Style

type Output = <Style as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Styles) -> <Style as BitXor<&Styles>>::Output

Performs the ^ operation.

impl BitXor<Style> for &Style

type Output = <Style as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Style) -> <&Style as BitXor<Style>>::Output

Performs the ^ operation.

impl BitXor<Style> for &Styles

type Output = <Styles as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Style) -> <&Styles as BitXor<Style>>::Output

Performs the ^ operation.

impl BitXor<Style> for Styles

type Output = Style

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Style) -> <Styles as BitXor<Style>>::Output

Performs the ^ operation.

impl BitXor<Styles> for &Style

type Output = <Style as BitXor>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Styles) -> <&Style as BitXor<Styles>>::Output

Performs the ^ operation.

impl BitXor<Styles> for Style

type Output = Style

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Styles) -> <Style as BitXor<Styles>>::Output

Performs the ^ operation.

impl BitXor for Style

type Output = Style

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Style) -> <Style as BitXor>::Output

Performs the ^ operation.

impl BitXorAssign<&Style> for Style

fn bitxor_assign(&mut self, other: &Style)

Performs the ^= operation.

impl BitXorAssign<&Styles> for Style

fn bitxor_assign(&mut self, other: &Styles)

Performs the ^= operation.

impl BitXorAssign<Styles> for Style

fn bitxor_assign(&mut self, other: Styles)

Performs the ^= operation.

impl BitXorAssign for Style

fn bitxor_assign(&mut self, other: Style)

Performs the ^= operation.

impl Clone for Style

fn clone(&self) -> Style

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Style

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

Formats the value using the given formatter.

impl Default for Style

fn default() -> Style

Returns the “default value” for a type.

impl From<&Styles> for Style

fn from(value: &Styles) -> Style

Converts to this type from the input type.

impl From<Styles> for Style

fn from(value: Styles) -> Style

Converts to this type from the input type.

impl FromIterator<Styles> for Style

fn from_iter<T>(iter: T) -> Style

where T: IntoIterator<Item = Styles>,

Creates a value from an iterator.

impl Not for &Style

type Output = Style

The resulting type after applying the ! operator.

fn not(self) -> <&Style as Not>::Output

Performs the unary ! operation.

impl Not for Style

type Output = Style

The resulting type after applying the ! operator.

fn not(self) -> <Style as Not>::Output

Performs the unary ! operation.

impl PartialEq for Style

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

impl Eq for Style

impl StructuralPartialEq for Style