Struct rerun::dataframe::ResolvedEntityPathFilter

pub struct ResolvedEntityPathFilter {
    rules: BTreeMap<ResolvedEntityPathRule, RuleEffect>,
}

An EntityPathFilter with all variables Resolved.

ResolvedEntityPathFilter sorts the rule by specificity of the entity path, with recursive coming before non-recursive. This means the last matching rule is also the most specific one. For instance:

+ /world/**
- /world
- /world/car/**
+ /world/car/driver

The last rule matching /world/car/driver is + /world/car/driver, so it is included. The last rule matching /world/car/hood is - /world/car/**, so it is excluded. The last rule matching /world is - /world, so it is excluded. The last rule matching /world/house is + /world/**, so it is included.

Fields

rules: BTreeMap<ResolvedEntityPathRule, RuleEffect>

Implementations

impl ResolvedEntityPathFilter

pub fn unresolved(&self) -> EntityPathFilter

Turns the resolved filter back into an unresolved filter.

pub fn iter_unresolved_expressions(&self) -> impl Iterator<Item = String>

Iterate over the raw expressions of the rules, displaying the raw unresolved expressions.

Note that they are iterated in the order of the resolved rules in contrast to EntityPathFilter::iter_expressions.

pub fn formatted(&self) -> String

pub fn most_specific_match(&self, path: &EntityPath) -> Option<RuleEffect>

Find the most specific matching rule and return its effect. If no rule matches, return None.

pub fn matches(&self, path: &EntityPath) -> bool

Does this filter include the given entity path?

pub fn matches_exactly(&self, entity_path: &EntityPath) -> bool

Is there a rule for this exact entity path (ignoring subtree)?

pub fn add_rule(&mut self, effect: RuleEffect, rule: ResolvedEntityPathRule)

Adds a rule to this filter.

If there’s already an effect for the rule, it is overwritten with the new effect.

pub fn remove_subtree_and_matching_rules(&mut self, entity_path: EntityPath)

Remove a subtree and any existing rules that it would match.

Because most-specific matches win, if we only add a subtree exclusion it can still be overridden by existing inclusions. This method ensures that not only do we add a subtree exclusion, but clear out any existing inclusions or (now redundant) exclusions that would match the subtree.

pub fn remove_rule_for(&mut self, entity_path: &EntityPath)

Remove any rule for the given entity path (ignoring whether or not that rule includes the subtree).

pub fn contains_rule_for_exactly(&self, entity_path: &EntityPath) -> bool

Is there any rule for this entity path?

Whether or not the subtree is included is NOT important.

pub fn is_explicitly_included(&self, entity_path: &EntityPath) -> bool

Is this entity path explicitly included?

Whether or not the subtree is included is NOT important.

pub fn is_explicitly_excluded(&self, entity_path: &EntityPath) -> bool

Is this entity path explicitly excluded?

Whether or not the subtree is included is NOT important.

pub fn is_anything_in_subtree_included(&self, path: &EntityPath) -> bool

Is anything under this path included (including self)?

pub fn is_superset_of(&self, other: &ResolvedEntityPathFilter) -> bool

Checks whether this results of this filter “fully contain” the results of another filter.

If this returns true there should not exist any EntityPath for which Self::matches would return true and the other filter would return false for this filter.

This check operates purely on the rule expressions and not the actual entity tree, and will thus not reason about entities included in an actual recording: different queries that are not a superset of each other may still query the same entities in given recording.

This is a conservative estimate, and may return false in situations where the query does in fact cover the other query. However, it should never return true in a case where the other query would not be fully covered.

pub fn rules( &self, ) -> impl Iterator<Item = (&ResolvedEntityPathRule, &RuleEffect)>

Iterate over all rules in the filter.

Trait Implementations

impl Clone for ResolvedEntityPathFilter

fn clone(&self) -> ResolvedEntityPathFilter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedEntityPathFilter

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

Formats the value using the given formatter.

impl Default for ResolvedEntityPathFilter

fn default() -> ResolvedEntityPathFilter

Returns the “default value” for a type.

impl Hash for ResolvedEntityPathFilter

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 ResolvedEntityPathFilter

fn eq(&self, other: &ResolvedEntityPathFilter) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ResolvedEntityPathFilter

impl StructuralPartialEq for ResolvedEntityPathFilter