Struct StyleChain 

pub struct StyleChain<'a> { /* private fields */ }

A chain of styles, similar to a linked list.

A style chain allows to combine properties from multiple style lists in a element hierarchy in a non-allocating way. Rather than eagerly merging the lists, each access walks the hierarchy from the innermost to the outermost map, trying to find a match and then folding it with matches further up the chain.

Implementations

impl<'a> StyleChain<'a>

pub fn new(root: &'a Styles) -> Self

Start a new style chain with root styles.

pub fn get<E, const I: u8>(self, field: Field<E, I>) -> E::Type

where E: SettableProperty<I>, E::Type: Copy,

Retrieves the value of the given field from the style chain.

A Field value is a zero-sized value that specifies which field of an element you want to retrieve on the type-system level. It also ensures that Rust can infer the correct return type.

Should be preferred over get_cloned or get_ref, but is only available for Copy types. For other types an explicit decision needs to be made whether cloning is necessary.

pub fn get_cloned<E, const I: u8>(self, _: Field<E, I>) -> E::Type

where E: SettableProperty<I>,

Retrieves and clones the value from the style chain.

Prefer get if the type is Copy and get_ref if a reference suffices.

pub fn get_ref<E, const I: u8>(self, _: Field<E, I>) -> &'a E::Type

where E: RefableProperty<I>,

Retrieves a reference to the value of the given field from the style chain.

Not possible if the value needs folding.

pub fn resolve<E, const I: u8>( self, field: Field<E, I>, ) -> <E::Type as Resolve>::Output

where E: SettableProperty<I>, E::Type: Resolve,

Retrieves the value and then immediately resolves it.

pub fn chain<'b, C>(&'b self, local: &'b C) -> StyleChain<'b>

where C: Chainable + ?Sized,

Make the given chainable the first link of this chain.

The resulting style chain contains styles from local as well as self. The ones from local take precedence over the ones from self. For folded properties local contributes the inner value.

pub fn entries(self) -> Entries<'a>

Iterate over the entries of the chain.

pub fn recipes(self) -> impl Iterator<Item = &'a Recipe>

Iterate over the recipes in the chain.

pub fn links(self) -> Links<'a>

Iterate over the links of the chain.

pub fn to_map(self) -> Styles

Convert to a style map.

pub fn suffix(self, len: usize) -> Styles

Build owned styles from the suffix (all links beyond the len) of the chain.

pub fn pop(&mut self)

Remove the last link from the chain.

pub fn trunk(iter: impl IntoIterator<Item = Self>) -> Option<Self>

Determine the shared trunk of a collection of style chains.

pub fn trunk_from_pairs(iter: &[(&Content, Self)]) -> Option<Self>

Determines the shared trunk of a list of elements.

This will ignore styles for tags (conceptually, they just don’t exist).

Trait Implementations

impl<'a> Clone for StyleChain<'a>

fn clone(&self) -> StyleChain<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StyleChain<'_>

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

Formats the value using the given formatter.

impl<'a> Default for StyleChain<'a>

fn default() -> StyleChain<'a>

Returns the “default value” for a type.

impl<'a> Hash for StyleChain<'a>

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 StyleChain<'_>

fn eq(&self, other: &Self) -> 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<'a> Copy for StyleChain<'a>