Struct style::invalidation::element::relative_selector::RelativeSelectorInnerInvalidationProcessor

pub struct RelativeSelectorInnerInvalidationProcessor<'a, 'b, 'c, E>
where
    E: TElement + 'a,
{
    matching_context: MatchingContext<'b, E::Impl>,
    snapshot_table: Option<&'c SnapshotMap>,
    dependencies: &'c SmallVec<[(Option<OpaqueElement>, &'a Dependency); 1]>,
    invalidations: SmallVec<[(E, RelativeSelectorInvalidation<'a>); 1]>,
    traversal_map: &'b SiblingTraversalMap<E>,
}

Invalidation for the selector(s) inside a relative selector.

Fields

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

Matching context to be used.

snapshot_table: Option<&'c SnapshotMap>

Table of snapshots.

dependencies: &'c SmallVec<[(Option<OpaqueElement>, &'a Dependency); 1]>

Incoming dependencies to be processed.

invalidations: SmallVec<[(E, RelativeSelectorInvalidation<'a>); 1]>

Generated invalidations.

traversal_map: &'b SiblingTraversalMap<E>

Traversal map for this invalidation.

Implementations

impl<'a, 'b, 'c, E> RelativeSelectorInnerInvalidationProcessor<'a, 'b, 'c, E>

where E: TElement + 'a,

fn new( quirks_mode: QuirksMode, snapshot_table: Option<&'c ServoElementSnapshotTable>, dependencies: &'c SmallVec<[(Option<OpaqueElement>, &'a Dependency); 1]>, selector_caches: &'b mut SelectorCaches, traversal_map: &'b SiblingTraversalMap<E>, ) -> Self

fn note_dependency( &mut self, element: E, scope: Option<OpaqueElement>, dependency: &'a Dependency, descendant_invalidations: &mut DescendantInvalidationLists<'a>, sibling_invalidations: &mut InvalidationVector<'a>, )

fn take_invalidations( self, ) -> SmallVec<[(E, RelativeSelectorInvalidation<'a>); 1]>

Take the generated invalidations.

Trait Implementations

impl<'a, 'b, 'c, E> InvalidationProcessor<'a, 'b, E> for RelativeSelectorInnerInvalidationProcessor<'a, 'b, 'c, E>

where E: TElement + 'a,

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<'b, E::Impl>

The matching context that should be used to process invalidations.

fn collect_invalidations( &mut self, element: E, _self_invalidations: &mut InvalidationVector<'a>, descendant_invalidations: &mut DescendantInvalidationLists<'a>, sibling_invalidations: &mut InvalidationVector<'a>, ) -> 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_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 invalidated_descendants(&mut self, _element: E, _child: E)

Executes an action when any descendant of Self is invalidated.

fn found_relative_selector_invalidation( &mut self, element: E, kind: RelativeDependencyInvalidationKind, dep: &'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.

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

The traversal map that should be used to process invalidations.

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…