Struct re_viewer::external::re_entity_db::EntityPath

pub struct EntityPath {
    hash: EntityPathHash,
    parts: Arc<Vec<EntityPathPart>>,
}

The unique identifier of an entity, e.g. camera/3/points

The entity path is a list of parts separated by slashes. Each part is a non-empty string, that can contain any character. When written as a string, some characters in the parts need to be escaped with a \ (only character, numbers, ., -, _ does not need escaping).

See https://www.rerun.io/docs/concepts/entity-path for more on entity paths.

This is basically implemented as a list of strings, but is reference-counted internally, so it is cheap to clone. It also has a precomputed hash and implemented nohash_hasher::IsEnabled, so it is very cheap to use in a nohash_hasher::IntMap and nohash_hasher::IntSet.

assert_eq!(
    EntityPath::parse_strict(r#"camera/ACME\ Örnöga/points/42"#).unwrap(),
    EntityPath::new(vec![
        "camera".into(),
        "ACME Örnöga".into(),
        "points".into(),
        "42".into(),
    ])
);

Fields

hash: EntityPathHash

parts: Arc<Vec<EntityPathPart>>

Implementations

impl EntityPath

pub fn root() -> EntityPath

pub fn new(parts: Vec<EntityPathPart>) -> EntityPath

pub fn from_file_path_as_single_string(file_path: &Path) -> EntityPath

Treat the file path as one opaque string.

The file path separators will NOT become splits in the new path. The returned path will only have one part.

pub fn from_file_path(file_path: &Path) -> EntityPath

Treat the file path as an entity path hierarchy.

The file path separators will become splits in the new path.

pub fn from_single_string(string: impl Into<InternedString>) -> EntityPath

Treat the string as one opaque string, NOT splitting on any slashes.

The given string is expected to be unescaped, i.e. any \ is treated as a normal character.

pub fn iter(&self) -> impl DoubleEndedIterator + ExactSizeIterator

pub fn last(&self) -> Option<&EntityPathPart>

pub fn as_slice(&self) -> &[EntityPathPart]

pub fn to_vec(&self) -> Vec<EntityPathPart>

pub fn is_root(&self) -> bool

pub fn starts_with(&self, prefix: &EntityPath) -> bool

Is this equals to, or a descendant of, the given path.

pub fn is_descendant_of(&self, other: &EntityPath) -> bool

Is this a strict descendant of the given path.

pub fn is_child_of(&self, other: &EntityPath) -> bool

Is this a direct child of the other path.

pub fn len(&self) -> usize

Number of parts

pub fn hash(&self) -> EntityPathHash

pub fn hash64(&self) -> u64

Precomputed 64-bit hash.

pub fn parent(&self) -> Option<EntityPath>

Return None if root.

pub fn join(&self, other: &EntityPath) -> EntityPath

pub fn incremental_walk<'a>( start: Option<&EntityPath>, end: &'a EntityPath ) -> impl Iterator<Item = EntityPath> + 'a

Helper function to iterate over all incremental EntityPaths from start to end, NOT including start itself.

For example incremental_walk("foo", "foo/bar/baz") returns: ["foo/bar", "foo/bar/baz"]

pub fn common_ancestor(&self, other: &EntityPath) -> EntityPath

Returns the first common ancestor of two paths.

If both paths are the same, the common ancestor is the path itself.

pub fn common_ancestor_of<'a>( entities: impl Iterator<Item = &'a EntityPath> ) -> EntityPath

Returns the first common ancestor of a list of entity paths.

pub fn short_names_with_disambiguation( entities: impl IntoIterator<Item = EntityPath> ) -> HashMap<EntityPath, String, RandomState>

Returns short names for a collection of entities based on the last part(s), ensuring uniqueness. Disambiguation is achieved by increasing the number of entity parts used.

Note: the result is undefined when the input contains duplicates.

impl EntityPath

Entity path parsing

When parsing a DataPath, it is important that we can distinguish the component and index from the actual entity path. This requires us to forbid certain characters in an entity part name. For instance, in foo/bar.baz, is baz a component name, or part of the entity path? So, when parsing a full DataPaths we are quite strict with what we allow. But when parsing EntityPaths we want to be a bit more forgiving, so we can accept things like foo/bar.baz and transform it into foo/"bar.baz". This allows user to do things like log(f"foo/{filename}", my_mesh) without Rerun throwing a fit.

pub fn parse_strict(input: &str) -> Result<EntityPath, PathParseError>

Parse an entity path from a string, with strict checks for correctness.

Parses anything that ent_path.to_string() outputs.

For a forgiving parse that accepts anything, use Self::parse_forgiving.

pub fn parse_forgiving(input: &str) -> EntityPath

Parses an entity path, handling any malformed input with a logged warning.

Things like foo/Hallå Där! will be accepted, and transformed into the path foo/Hallå\ Där\!.

For a strict parses, use Self::parse_strict instead.

Trait Implementations

impl Clone for EntityPath

fn clone(&self) -> EntityPath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DataUi for EntityPath

fn data_ui( &self, ctx: &ViewerContext<'_>, ui: &mut Ui, ui_layout: UiLayout, query: &LatestAtQuery, db: &EntityDb )

If you need to lookup something in the chunk store, use the given query to do so.

fn data_ui_recording( &self, ctx: &ViewerContext<'_>, ui: &mut Ui, ui_layout: UiLayout )

Called Self::data_ui using the default query and recording.

impl Debug for EntityPath

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EntityPath

fn deserialize<D>( deserializer: D ) -> Result<EntityPath, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for EntityPath

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

Formats the value using the given formatter.

impl From<&[EntityPathPart]> for EntityPath

fn from(path: &[EntityPathPart]) -> EntityPath

Converts to this type from the input type.

impl From<&EntityPath> for EntityPath

fn from(value: &EntityPath) -> EntityPath

Converts to this type from the input type.

impl From<&str> for EntityPath

fn from(path: &str) -> EntityPath

Converts to this type from the input type.

impl From<EntityPath> for EntityPath

fn from(value: EntityPath) -> EntityPath

Converts to this type from the input type.

impl From<EntityPath> for EntityPath

fn from(value: EntityPath) -> EntityPath

Converts to this type from the input type.

impl From<EntityPath> for EntityPathRule

fn from(entity_path: EntityPath) -> EntityPathRule

Converts to this type from the input type.

impl From<EntityPath> for InstancePath

fn from(entity_path: EntityPath) -> InstancePath

Converts to this type from the input type.

impl From<EntityPath> for String

fn from(path: EntityPath) -> String

Converts to this type from the input type.

impl From<String> for EntityPath

fn from(path: String) -> EntityPath

Converts to this type from the input type.

impl From<Vec<EntityPathPart>> for EntityPath

fn from(path: Vec<EntityPathPart>) -> EntityPath

Converts to this type from the input type.

impl FromIterator<EntityPathPart> for EntityPath

fn from_iter<T>(parts: T) -> EntityPath

where T: IntoIterator<Item = EntityPathPart>,

Creates a value from an iterator.

impl Hash for EntityPath

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<Idx> Index<Idx> for EntityPath

where Idx: SliceIndex<[EntityPathPart]>,

type Output = <Idx as SliceIndex<[EntityPathPart]>>::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &<EntityPath as Index<Idx>>::Output

Performs the indexing (container[index]) operation.

impl Loggable for EntityPath

type Name = ComponentName

fn name() -> <EntityPath as Loggable>::Name

The fully-qualified name of this loggable, e.g. rerun.datatypes.Vec2D.

fn arrow_datatype() -> DataType

The underlying arrow2::datatypes::DataType, excluding datatype extensions.

fn to_arrow_opt<'a>( _data: impl IntoIterator<Item = Option<impl Into<Cow<'a, EntityPath>>>> ) -> Result<Box<dyn Array>, SerializationError>

where EntityPath: 'a,

Given an iterator of options of owned or reference values to the current Loggable, serializes them into an Arrow array.

fn to_arrow<'a>( data: impl IntoIterator<Item = impl Into<Cow<'a, EntityPath>>> ) -> Result<Box<dyn Array>, SerializationError>

where EntityPath: 'a,

Given an iterator of owned or reference values to the current Loggable, serializes them into an Arrow array.

fn from_arrow( array: &(dyn Array + 'static) ) -> Result<Vec<EntityPath>, DeserializationError>

Given an Arrow array, deserializes it into a collection of Loggables.

fn from_arrow_opt( data: &(dyn Array + 'static) ) -> Result<Vec<Option<Self>>, DeserializationError>

Given an Arrow array, deserializes it into a collection of optional Loggables.

impl Ord for EntityPath

fn cmp(&self, other: &EntityPath) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for EntityPath

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

fn partial_cmp(&self, other: &EntityPath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for EntityPath

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SizeBytes for EntityPath

fn heap_size_bytes(&self) -> u64

Returns the total size of self on the heap, in bytes.

fn total_size_bytes(&self) -> u64

Returns the total size of self in bytes, accounting for both stack and heap space.

fn stack_size_bytes(&self) -> u64

Returns the total size of self on the stack, in bytes.

fn is_pod() -> bool

Is Self just plain old data?

impl SyntaxHighlighting for EntityPath

fn syntax_highlight_into(&self, style: &Style, job: &mut LayoutJob)

fn syntax_highlighted(&self, style: &Style) -> LayoutJob

impl Eq for EntityPath

impl IsEnabled for EntityPath