Struct style::invalidation::element::document_state::DocumentStateInvalidationProcessor

pub struct DocumentStateInvalidationProcessor<'a, 'b, E: TElement, I> {
    rules: I,
    matching_context: MatchingContext<'a, E::Impl>,
    traversal_map: SiblingTraversalMap<E>,
    document_states_changed: DocumentState,
    _marker: PhantomData<&'b ()>,
}

An invalidation processor for style changes due to state and attribute changes.

Fields

rules: I

matching_context: MatchingContext<'a, E::Impl>

traversal_map: SiblingTraversalMap<E>

document_states_changed: DocumentState

_marker: PhantomData<&'b ()>

Implementations

impl<'a, 'b, E: TElement, I> DocumentStateInvalidationProcessor<'a, 'b, E, I>

pub fn new( rules: I, document_states_changed: DocumentState, selector_caches: &'a mut SelectorCaches, quirks_mode: QuirksMode, ) -> Self

Creates a new DocumentStateInvalidationProcessor.

Trait Implementations

impl<'a, 'b, E, I> InvalidationProcessor<'b, 'a, E> for DocumentStateInvalidationProcessor<'a, 'b, E, I>

where E: TElement, I: Iterator<Item = &'b CascadeData>,

fn check_outer_dependency(&mut self, _: &Dependency, _: E) -> bool

When a dependency from a :where or :is selector matches, it may still be the case that we don’t need to invalidate the full style. Consider the case of:

fn collect_invalidations( &mut self, _element: E, self_invalidations: &mut InvalidationVector<'b>, _descendant_invalidations: &mut DescendantInvalidationLists<'b>, _sibling_invalidations: &mut InvalidationVector<'b>, ) -> bool

Collect invalidations for a given element’s descendants and siblings.

fn matching_context(&mut self) -> &mut MatchingContext<'a, E::Impl>

The matching context that should be used to process invalidations.

fn sibling_traversal_map(&self) -> &SiblingTraversalMap<E>

The traversal map that should be used to process invalidations.

fn recursion_limit_exceeded(&mut self, _: E)

Executes an arbitrary action when the recursion limit is exceded (if any).

fn should_process_descendants(&mut self, element: E) -> bool

Returns whether the invalidation process should process the descendants of the given element.

fn invalidated_descendants(&mut self, element: E, child: E)

Executes an action when any descendant of Self is invalidated.

fn invalidated_self(&mut self, element: E)

Executes an action when Self is invalidated.

fn invalidated_sibling(&mut self, sibling: E, of: E)

Executes an action when sibling is invalidated as a sibling of of.

fn invalidates_on_pseudo_element(&self) -> bool

Whether an invalidation that contains only a pseudo-element selector like ::before or ::after triggers invalidation of the element that would originate it.

fn light_tree_only(&self) -> bool

Whether the invalidation processor only cares about light-tree descendants of a given element, that is, doesn’t invalidate pseudo-elements, NAC, shadow dom…

fn found_relative_selector_invalidation( &mut self, _element: E, _kind: RelativeDependencyInvalidationKind, _relative_dependency: &'a Dependency, )

Executes an action when an element in a relative selector is reached. Lets the dependency to be borrowed for further processing out of the invalidation traversal.