Struct rerun::dataframe::EntityPathFilter

pub struct EntityPathFilter {
    rules: BTreeMap<EntityPathRule, RuleEffect>,
}

A way to filter a set of EntityPaths.

This implements as simple set of include/exclude rules:

+ /world/**           # add everything…
- /world/roads/**     # …but remove all roads…
+ /world/roads/main   # …but show main road

If there is multiple matching rules, the most specific rule wins. If there are multiple rules of the same specificity, the last one wins. If no rules match, the path is excluded.

The /** suffix matches the whole subtree, i.e. self and any child, recursively (/world/** matches both /world and /world/car/driver). Other uses of * are not (yet) supported.

Since variable substitution (and thus path parsing) hasn’t been performed yet, the rules can not be sorted yet from general to specific, instead they are stored in alphabetical order. To expand variables & evaluate the filter, use ResolvedEntityPathFilter.

Fields

rules: BTreeMap<EntityPathRule, RuleEffect>

Implementations

impl EntityPathFilter

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

Iterates the expressions in alphabetical order.

This is not the order the rules are evaluated in (use ResolvedEntityPathFilter::iter_unresolved_expressions for that instead).

pub fn parse_forgiving(rules: &str) -> EntityPathFilter

Parse an entity path filter from a string, ignoring any parsing errors.

Example of rules:

+ /world/**
- /world/roads/**
+ /world/roads/main

Each line is a rule.

The first character should be + or -. If missing, + is assumed. The rest of the line is trimmed and treated as an entity path after variable substitution through Self::resolve_forgiving/Self::resolve_strict.

Conflicting rules are resolved by the last rule.

pub fn parse_strict( rules: &str, ) -> Result<EntityPathFilter, EntityPathFilterError>

Parse an entity path filter from a string.

Example of rules:

+ /world/**
- /world/roads/**
+ /world/roads/main

Each line is a rule.

The first character should be + or -. If missing, + is assumed. The rest of the line is trimmed and treated as an entity path after variable substitution through Self::resolve_forgiving/Self::resolve_strict.

Conflicting rules are resolved by the last rule.

pub fn from_query_expressions<'a>( rules: impl IntoIterator<Item = &'a str>, ) -> EntityPathFilter

Build a filter from a list of query expressions.

Each item in the iterator should be a query expression.

The first character should be + or -. If missing, + is assumed. The rest of the expression is trimmed and treated as an entity path.

Conflicting rules are resolved by the last rule.

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

Adds a rule to this filter.

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

pub fn all() -> EntityPathFilter

Creates a filter that accepts everything.

pub fn add_exact(&mut self, path_or_variable: &str)

Include this path or variable expression, but not the subtree.

pub fn add_exact_entity(&mut self, path: &EntityPath)

Include this entity, but not the subtree.

pub fn add_subtree(&mut self, path_or_variable: &str)

Include this entity or variable expression with subtree.

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

Include this entity with subtree.

pub fn single_filter(path_or_variable: &str) -> EntityPathFilter

Creates a new entity path filter that includes only a single path or variable expression.

pub fn single_entity_filter(entity_path: &EntityPath) -> EntityPathFilter

Creates a new entity path filter that includes only a single entity.

pub fn subtree_filter(path_or_variable: &str) -> EntityPathFilter

Creates a new entity path filter that includes a single subtree.

pub fn subtree_entity_filter(entity_path: &EntityPath) -> EntityPathFilter

Creates a new entity path filter that includes a single subtree.

To use this with unsubsituted variables, use Self::subtree_filter instead.

pub fn resolve_forgiving( &self, subst_env: &EntityPathSubs, ) -> ResolvedEntityPathFilter

Resolve variables & parse paths, ignoring any errors.

pub fn resolve_strict( self, subst_env: &EntityPathSubs, ) -> Result<ResolvedEntityPathFilter, EntityPathFilterError>

Resolve variables & parse paths, returning an error if any rule cannot be parsed or variable substitution fails.

pub fn resolve_without_substitutions(self) -> ResolvedEntityPathFilter

Resolve variables & parse paths, without any substitutions.

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

Iterate over all rules in the filter.

Trait Implementations

impl AddAssign for EntityPathFilter

fn add_assign(&mut self, rhs: EntityPathFilter)

The union of all rules

impl Clone for EntityPathFilter

fn clone(&self) -> EntityPathFilter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EntityPathFilter

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

Formats the value using the given formatter.

impl Default for EntityPathFilter

fn default() -> EntityPathFilter

Returns the “default value” for a type.

impl Hash for EntityPathFilter

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 EntityPathFilter

fn eq(&self, other: &EntityPathFilter) -> 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 Sum for EntityPathFilter

fn sum<I>(iter: I) -> EntityPathFilter

where I: Iterator<Item = EntityPathFilter>,

The union of all rules

impl TryFrom<&str> for EntityPathFilter

type Error = EntityPathFilterError

The type returned in the event of a conversion error.

fn try_from( value: &str, ) -> Result<EntityPathFilter, <EntityPathFilter as TryFrom<&str>>::Error>

Performs the conversion.

impl Eq for EntityPathFilter

impl StructuralPartialEq for EntityPathFilter