Struct style::invalidation::element::relative_selector::RelativeSelectorOuterInvalidationProcessor

pub struct RelativeSelectorOuterInvalidationProcessor<'a, 'b, E: TElement> {
    pub element: E,
    pub host: Option<OpaqueElement>,
    pub data: &'a mut ElementData,
    pub dependency: &'b Dependency,
    pub matching_context: MatchingContext<'a, E::Impl>,
    pub traversal_map: &'a SiblingTraversalMap<E>,
}

Blindly invalidate everything outside of a relative selector. Consider :is(.a :has(.b) .c ~ .d) ~ .e .f, where .b gets deleted. Since the tree mutated, we cannot rely on snapshots.

Fields

element: E

Element being invalidated.

host: Option<OpaqueElement>

The current shadow host, if any.

data: &'a mut ElementData

Data for the element being invalidated.

dependency: &'b Dependency

Dependency to be processed.

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

Matching context to use for invalidation.

traversal_map: &'a SiblingTraversalMap<E>

Traversal map for this invalidation.

Trait Implementations

impl<'a, 'b: 'a, E> InvalidationProcessor<'b, 'a, E> for RelativeSelectorOuterInvalidationProcessor<'a, 'b, E>

where E: TElement + 'a,

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 check_outer_dependency( &mut self, _dependency: &Dependency, _element: 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 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 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 should_process_descendants(&mut self, element: E) -> bool

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

fn recursion_limit_exceeded(&mut self, _element: E)

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

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, element: E, of: E)

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

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.