Struct AttributeSet 

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

A set of Attribute values.

AttributeSet values can be combined with bitwise operators and can be iterated over.

Implementations

impl AttributeSet

pub const EMPTY: AttributeSet

A set containing no Attributes

pub const ALL: AttributeSet

A set containing all Attributes

pub fn new() -> AttributeSet

Return a new set containing no Attributes

pub fn is_empty(self) -> bool

Test whether the set is empty

pub fn len(self) -> usize

Returns the number of Attributes in the set

pub fn is_all(self) -> bool

Test whether the set contains all Attributes

pub fn contains(self, attr: Attribute) -> bool

Test whether the set contains the given Attribute

pub fn insert(&mut self, attr: Attribute) -> bool

Adds the given Attribute to the set if not already present.

Returns true if the given Attribute was not already in the set.

Example

use parse_style::{Attribute, AttributeSet};

let mut attrset = AttributeSet::new();
assert!(!attrset.contains(Attribute::Bold));
assert!(attrset.insert(Attribute::Bold));
assert!(attrset.contains(Attribute::Bold));
assert!(!attrset.insert(Attribute::Bold));
assert!(attrset.contains(Attribute::Bold));

pub fn remove(&mut self, attr: Attribute) -> bool

Removes the given Attribute from the set if present.

Returns true if the given Attribute was present in the set.

Example

use parse_style::{Attribute, AttributeSet};

let mut attrset = AttributeSet::from([Attribute::Bold]);
assert!(attrset.contains(Attribute::Bold));
assert!(attrset.remove(Attribute::Bold));
assert!(!attrset.contains(Attribute::Bold));
assert!(!attrset.remove(Attribute::Bold));
assert!(!attrset.contains(Attribute::Bold));

pub fn clear(&mut self)

Removes all Attributes from the set

pub fn is_disjoint(self, other: AttributeSet) -> bool

Returns true if self and other are disjoint, i.e., if there is no Attribute that is in both sets.

Examples

use parse_style::{Attribute, AttributeSet};

let attrset1 = AttributeSet::from([Attribute::Bold,
Attribute::Italic]);
let attrset2 = AttributeSet::from([Attribute::Underline,
Attribute::Blink]);
assert!(attrset1.is_disjoint(attrset2));
assert!(attrset2.is_disjoint(attrset1));

use parse_style::{Attribute, AttributeSet};

let attrset1 = AttributeSet::from([Attribute::Bold,
Attribute::Italic]);
let attrset2 = AttributeSet::from([Attribute::Bold,
Attribute::Underline]);
assert!(!attrset1.is_disjoint(attrset2));
assert!(!attrset2.is_disjoint(attrset1));

pub fn is_subset(self, other: AttributeSet) -> bool

Returns true if self is a subset of other

Examples

use parse_style::{Attribute, AttributeSet};

let attrset1 = AttributeSet::from([Attribute::Bold]);
let attrset2 = AttributeSet::from([Attribute::Bold,
Attribute::Underline]);
assert!(attrset1.is_subset(attrset2));
assert!(!attrset2.is_subset(attrset1));

use parse_style::{Attribute, AttributeSet};

let attrset1 = AttributeSet::from([Attribute::Bold,
Attribute::Italic]);
let attrset2 = AttributeSet::from([Attribute::Bold,
Attribute::Underline]);
assert!(!attrset1.is_subset(attrset2));
assert!(!attrset2.is_subset(attrset1));

pub fn is_superset(self, other: AttributeSet) -> bool

Returns true if self is a superset of other

Examples

use parse_style::{Attribute, AttributeSet};

let attrset1 = AttributeSet::from([Attribute::Bold]);
let attrset2 = AttributeSet::from([Attribute::Bold,
Attribute::Underline]);
assert!(!attrset1.is_superset(attrset2));
assert!(attrset2.is_superset(attrset1));

use parse_style::{Attribute, AttributeSet};

let attrset1 = AttributeSet::from([Attribute::Bold,
Attribute::Italic]);
let attrset2 = AttributeSet::from([Attribute::Bold,
Attribute::Underline]);
assert!(!attrset1.is_superset(attrset2));
assert!(!attrset2.is_superset(attrset1));

Trait Implementations

impl<A: Into<AttributeSet>> BitAnd<A> for AttributeSet

type Output = AttributeSet

The resulting type after applying the & operator.

fn bitand(self, rhs: A) -> AttributeSet

Performs the & operation.

impl<A: Into<AttributeSet>> BitAndAssign<A> for AttributeSet

fn bitand_assign(&mut self, rhs: A)

Performs the &= operation.

impl<A: Into<AttributeSet>> BitOr<A> for AttributeSet

type Output = AttributeSet

The resulting type after applying the | operator.

fn bitor(self, rhs: A) -> AttributeSet

Performs the | operation.

impl<A: Into<AttributeSet>> BitOrAssign<A> for AttributeSet

fn bitor_assign(&mut self, rhs: A)

Performs the |= operation.

impl<A: Into<AttributeSet>> BitXor<A> for AttributeSet

type Output = AttributeSet

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: A) -> AttributeSet

Performs the ^ operation.

impl<A: Into<AttributeSet>> BitXorAssign<A> for AttributeSet

fn bitxor_assign(&mut self, rhs: A)

Performs the ^= operation.

impl Clone for AttributeSet

fn clone(&self) -> AttributeSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AttributeSet

impl Debug for AttributeSet

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

Formats the value using the given formatter.

impl Default for AttributeSet

fn default() -> AttributeSet

Returns the “default value” for a type.

impl Eq for AttributeSet

impl Extend<Attribute> for AttributeSet

fn extend<I: IntoIterator<Item = Attribute>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<Attribute> for AttributeSet

fn from(value: Attribute) -> AttributeSet

Converts to this type from the input type.

impl From<AttributeSet> for Effects

Available on crate feature anstyle only.

fn from(value: AttributeSet) -> Effects

Convert an AttributeSet to an anstyle::Effects

Data Loss

The following attributes are discarded during conversion, as they have no anstyle::Effects equivalents:

• Attribute::Blink2
• Attribute::Frame
• Attribute::Encircle
• Attribute::Overline

impl From<AttributeSet> for Attributes

Available on crate feature crossterm only.

fn from(value: AttributeSet) -> Attributes

Convert an AttributeSet to a crossterm::style::Attributes that enables the input attributes

impl From<AttributeSet> for Modifier

Available on crate feature ratatui only.

fn from(value: AttributeSet) -> Modifier

Convert an AttributeSet to a ratatui_core::style::Modifier

Data Loss

The following attributes are discarded during conversion, as they have no ratatui_core::style::Modifier equivalents:

• Attribute::Underline2
• Attribute::Frame
• Attribute::Encircle
• Attribute::Overline

impl From<AttributeSet> for Style

fn from(value: AttributeSet) -> Style

Construct a new Style that enables the given attributes

impl From<Effects> for AttributeSet

Available on crate feature anstyle only.

fn from(value: Effects) -> AttributeSet

Convert an anstyle::Effects to an AttributeSet

Data Loss

The following effects are discarded during conversion, as they have no Attribute equivalents:

• anstyle::Effects::CURLY_UNDERLINE
• anstyle::Effects::DOTTED_UNDERLINE
• anstyle::Effects::DASHED_UNDERLINE

impl From<Modifier> for AttributeSet

Available on crate feature ratatui only.

fn from(value: Modifier) -> AttributeSet

Convert a ratatui_core::style::Modifier to an AttributeSet

impl<const N: usize> From<[Attribute; N]> for AttributeSet

fn from(value: [Attribute; N]) -> AttributeSet

Converts to this type from the input type.

impl FromIterator<Attribute> for AttributeSet

fn from_iter<I: IntoIterator<Item = Attribute>>(iter: I) -> Self

Creates a value from an iterator.

impl Hash for AttributeSet

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 IntoIterator for AttributeSet

type Item = Attribute

The type of the elements being iterated over.

type IntoIter = AttributeSetIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> AttributeSetIter

Creates an iterator from a value.

impl Not for AttributeSet

type Output = AttributeSet

The resulting type after applying the ! operator.

fn not(self) -> AttributeSet

Performs the unary ! operation.

impl Ord for AttributeSet

fn cmp(&self, other: &AttributeSet) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for AttributeSet

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

fn partial_cmp(&self, other: &AttributeSet) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for AttributeSet

impl<A: Into<AttributeSet>> Sub<A> for AttributeSet

type Output = AttributeSet

The resulting type after applying the - operator.

fn sub(self, rhs: A) -> AttributeSet

Performs the - operation.

impl<A: Into<AttributeSet>> SubAssign<A> for AttributeSet

fn sub_assign(&mut self, rhs: A)

Performs the -= operation.