Struct RelativeSelectorDependencyCollector 

struct RelativeSelectorDependencyCollector<'a, 'b> {
    map: &'a mut InvalidationMap,
    relative_selector_invalidation_map: &'a mut InvalidationMap,
    additional_relative_selector_invalidation_map: &'a mut AdditionalRelativeSelectorInvalidationMap,
    document_state: &'a mut DocumentState,
    selector: &'a RelativeSelector<SelectorImpl>,
    combinator_count: RelativeSelectorCombinatorCount,
    next_selectors: &'a mut SmallVec<[NextDependencyEntry; 5]>,
    quirks_mode: QuirksMode,
    compound_state: PerCompoundState,
    compound_state_attributes: RelativeSelectorCompoundStateAttributes,
    scope_dependencies: &'a mut ScopeSelectorCollectorState<'b>,
    alloc_error: &'a mut Option<AllocErr>,
}

A struct that collects invalidations for a given compound selector.

Fields

map: &'a mut InvalidationMap

relative_selector_invalidation_map: &'a mut InvalidationMap

additional_relative_selector_invalidation_map: &'a mut AdditionalRelativeSelectorInvalidationMap

document_state: &'a mut DocumentState

The document this complex selector is affected by.

We don’t need to track state per compound selector, since it’s global state and it changes for everything.

selector: &'a RelativeSelector<SelectorImpl>

The current inner relative selector and offset we’re iterating.

combinator_count: RelativeSelectorCombinatorCount

Running combinator for this inner relative selector.

next_selectors: &'a mut SmallVec<[NextDependencyEntry; 5]>

The stack of next selectors that we have, and at which offset of the sequence.

This starts empty. It grows when we find nested :is and :where selector lists. The dependency field is cached and reference counted.

quirks_mode: QuirksMode

The quirks mode of the document where we’re inserting dependencies.

compound_state: PerCompoundState

State relevant to a given compound selector.

compound_state_attributes: RelativeSelectorCompoundStateAttributes

Attributes relevant to the relative compound selector state.

scope_dependencies: &'a mut ScopeSelectorCollectorState<'b>

alloc_error: &'a mut Option<AllocErr>

The allocation error, if we OOM.

Implementations

impl<'a, 'b> RelativeSelectorDependencyCollector<'a, 'b>

fn visit_whole_selector(&mut self) -> bool

Trait Implementations

impl<'a, 'b> Collector for RelativeSelectorDependencyCollector<'a, 'b>

fn dependency(&mut self) -> Dependency

fn id_map(&mut self) -> &mut IdOrClassDependencyMap

fn class_map(&mut self) -> &mut IdOrClassDependencyMap

fn state_map(&mut self) -> &mut StateDependencyMap

fn attribute_map(&mut self) -> &mut LocalNameDependencyMap

fn custom_state_map(&mut self) -> &mut CustomStateDependencyMap

fn inner_scope_dependencies(&self) -> Option<ThinArc<(), Dependency>>

fn this_scope_dependencies(&mut self) -> &mut Option<Vec<Dependency>>

fn update_states( &mut self, element_state: ElementState, document_state: DocumentState, )

fn type_map(&mut self) -> &mut LocalNameDependencyMap

fn ts_state_map(&mut self) -> &mut TSStateDependencyMap

fn any_vec(&mut self) -> &mut AnyDependencyMap

impl<'a, 'b> SelectorVisitor for RelativeSelectorDependencyCollector<'a, 'b>

type Impl = SelectorImpl

The selector implementation this visitor wants to visit.

fn visit_selector_list( &mut self, _list_kind: SelectorListKind, list: &[Selector<SelectorImpl>], ) -> bool

Visit a nested selector list. The caller is responsible to call visit into the internal selectors if / as needed.

fn visit_relative_selector_list( &mut self, _list: &[RelativeSelector<Self::Impl>], ) -> bool

Visit a nested relative selector list. The caller is responsible to call visit into the internal selectors if / as needed.

fn visit_simple_selector(&mut self, s: &Component<SelectorImpl>) -> bool

Visit a simple selector.

fn visit_attribute_selector( &mut self, _: &NamespaceConstraint<&Namespace>, local_name: &LocalName, local_name_lower: &LocalName, ) -> bool

Visit an attribute selector that may match (there are other selectors that may never match, like those containing whitespace or the empty string).

fn visit_complex_selector( &mut self, _combinator_to_right: Option<Combinator>, ) -> bool

Visits a complex selector.