Struct re_space_view::external::re_chunk_store::ChunkId

pub struct ChunkId(pub(crate) Tuid);

A unique ID for a crate::Chunk.

Chunks are the atomic unit of ingestion, transport, storage, events and GC in Rerun.

Internally, a crate::Chunk is made up of rows, which are themselves uniquely identified by their RowId.

There is no relationship whatsoever between a ChunkId and the RowIds within that chunk.

Uniqueness

ChunkId are assumed unique within a single Recording.

The chunk store will treat two chunks with the same ChunkId as the same, and only keep one of them (which one is kept is an arbitrary and unstable implementation detail).

This makes it easy to build and maintain secondary indices around RowIds with few to no extraneous state tracking.

Garbage collection

Garbage collection is handled at the chunk level by first ordering the chunks based on the minimum RowId present in each of them. Garbage collection therefore happens (roughly) in the logger’s wall-clock order.

This has very important implications when inserting data far into the past or into the future: think carefully about your RowIds in these cases.

Tuple Fields

0: Tuid

Implementations

impl ChunkId

pub const ZERO: ChunkId = _

pub const MAX: ChunkId = _

pub fn new() -> ChunkId

Create a new unique ChunkId based on the current time.

pub fn next(&self) -> ChunkId

Returns the next logical ChunkId.

Beware: wrong usage can easily lead to conflicts. Prefer ChunkId::new when unsure.

pub fn incremented_by(&self, n: u64) -> ChunkId

Returns the n-next logical ChunkId.

This is equivalent to calling ChunkId::next n times. Wraps the monotonically increasing back to zero on overflow.

Beware: wrong usage can easily lead to conflicts. Prefer ChunkId::new when unsure.

pub fn nanoseconds_since_epoch(&self) -> u64

When the ChunkId was created, in nanoseconds since unix epoch.

pub fn from_u128(id: u128) -> ChunkId

pub fn as_u128(&self) -> u128

Methods from Deref<Target = Tuid>

pub fn heap_size_bytes(&self) -> u64

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

NOTE: This crate cannot depend on re_types_core, therefore the actual implementation of SizeBytes for Tuid lives in re_types_core and calls this method.

pub const ZERO: Tuid = _

pub const MAX: Tuid = _

pub fn as_u128(&self) -> u128

pub fn nanoseconds_since_epoch(&self) -> u64

Approximate nanoseconds since unix epoch.

The upper 64 bits of the Tuid.

pub fn inc(&self) -> u64

The increment part of the Tuid.

The lower 64 bits of the Tuid.

pub fn next(&self) -> Tuid

Returns the next logical Tuid.

Wraps the monotonically increasing back to zero on overflow.

Beware: wrong usage can easily lead to conflicts. Prefer Tuid::new when unsure.

pub fn incremented_by(&self, n: u64) -> Tuid

Returns the n-next logical Tuid.

This is equivalent to calling Tuid::next n times. Wraps the monotonically increasing back to zero on overflow.

Beware: wrong usage can easily lead to conflicts. Prefer Tuid::new when unsure.

pub fn short_string(&self) -> String

A shortened string representation of the Tuid.

Trait Implementations

impl Clone for ChunkId

fn clone(&self) -> ChunkId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ChunkId

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

Formats the value using the given formatter.

impl Deref for ChunkId

type Target = Tuid

The resulting type after dereferencing.

fn deref(&self) -> &<ChunkId as Deref>::Target

Dereferences the value.

impl DerefMut for ChunkId

fn deref_mut(&mut self) -> &mut <ChunkId as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for ChunkId

fn deserialize<__D>( __deserializer: __D ) -> Result<ChunkId, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ChunkId

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

Formats the value using the given formatter.

impl Hash for ChunkId

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 Loggable for ChunkId

type Name = ComponentName

fn name() -> <ChunkId 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>( values: impl IntoIterator<Item = Option<impl Into<Cow<'a, ChunkId>>>> ) -> Result<Box<dyn Array>, SerializationError>

where ChunkId: '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>( values: impl IntoIterator<Item = impl Into<Cow<'a, ChunkId>>> ) -> Result<Box<dyn Array>, SerializationError>

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<ChunkId>, 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 ChunkId

fn cmp(&self, other: &ChunkId) -> 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 ChunkId

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

fn partial_cmp(&self, other: &ChunkId) -> 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 ChunkId

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 ChunkId

fn heap_size_bytes(&self) -> u64

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

fn is_pod() -> bool

Is Self just plain old data?

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.

impl Copy for ChunkId

impl Eq for ChunkId

impl StructuralPartialEq for ChunkId