Struct re_types::archetypes::Clear

pub struct Clear {
    pub is_recursive: Option<SerializedComponentBatch>,
}

Archetype: Empties all the components of an entity.

The presence of a clear means that a latest-at query of components at a given path(s) will not return any components that were logged at those paths before the clear. Any logged components after the clear are unaffected by the clear.

This implies that a range query that includes time points that are before the clear, still returns all components at the given path(s). Meaning that in practice clears are ineffective when making use of visible time ranges. Scalar plots are an exception: they track clears and use them to represent holes in the data (i.e. discontinuous lines).

Example

Flat

use rerun::external::glam;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec = rerun::RecordingStreamBuilder::new("rerun_example_clear").spawn()?;

    #[rustfmt::skip]
    let (vectors, origins, colors) = (
        [glam::Vec3::X,    glam::Vec3::NEG_Y, glam::Vec3::NEG_X, glam::Vec3::Y],
        [(-0.5, 0.5, 0.0), (0.5, 0.5, 0.0),   (0.5, -0.5, 0.0),  (-0.5, -0.5, 0.0)],
        [(200, 0, 0),      (0, 200, 0),       (0, 0, 200),       (200, 0, 200)],
    );

    // Log a handful of arrows.
    for (i, ((vector, origin), color)) in vectors.into_iter().zip(origins).zip(colors).enumerate() {
        rec.log(
            format!("arrows/{i}"),
            &rerun::Arrows3D::from_vectors([vector])
                .with_origins([origin])
                .with_colors([rerun::Color::from_rgb(color.0, color.1, color.2)]),
        )?;
    }

    // Now clear them, one by one on each tick.
    for i in 0..vectors.len() {
        rec.log(format!("arrows/{i}"), &rerun::Clear::flat())?;
    }

    Ok(())
}

Fields

is_recursive: Option<SerializedComponentBatch>

Implementations

impl Clear

pub fn descriptor_is_recursive() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::is_recursive.

pub fn descriptor_indicator() -> ComponentDescriptor

Returns the ComponentDescriptor for the associated indicator component.

impl Clear

pub const NUM_COMPONENTS: usize = 2usize

The total number of components in the archetype: 1 required, 1 recommended, 0 optional

impl Clear

pub fn new(is_recursive: impl Into<ClearIsRecursive>) -> Clear

Create a new Clear.

pub fn update_fields() -> Clear

Update only some specific fields of a Clear.

pub fn clear_fields() -> Clear

Clear all the fields of a Clear.

pub fn columns<I>( self, _lengths: I, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

where I: IntoIterator<Item = usize> + Clone,

Partitions the component data into multiple sub-batches.

Specifically, this transforms the existing SerializedComponentBatches data into SerializedComponentColumns instead, via SerializedComponentBatch::partitioned.

This makes it possible to use RecordingStream::send_columns to send columnar data directly into Rerun.

The specified lengths must sum to the total length of the component batch.

pub fn columns_of_unit_batches( self, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

Helper to partition the component data into unit-length sub-batches.

This is semantically similar to calling Self::columns with std::iter::take(1).repeat(n), where n is automatically guessed.

pub fn with_is_recursive( self, is_recursive: impl Into<ClearIsRecursive>, ) -> Clear

pub fn with_many_is_recursive( self, is_recursive: impl IntoIterator<Item = impl Into<ClearIsRecursive>>, ) -> Clear

This method makes it possible to pack multiple crate::components::ClearIsRecursive in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_is_recursive should be used when logging a single row’s worth of data.

impl Clear

pub fn flat() -> Clear

Returns a non-recursive clear.

This will empty all components of the associated entity at the logged timepoint. Children will be left untouched.

pub fn recursive() -> Clear

Returns a recursive clear.

This will empty all components of the associated entity at the logged timepoint, as well as all components of all its recursive children.

Trait Implementations

impl Archetype for Clear

type Indicator = GenericIndicatorComponent<Clear>

The associated indicator component, whose presence indicates that the high-level archetype-based APIs were used to log the data.

fn name() -> ArchetypeName

The fully-qualified name of this archetype, e.g. rerun.archetypes.Points2D.

fn display_name() -> &'static str

Readable name for displaying in UI.

fn indicator() -> SerializedComponentBatch

Creates a ComponentBatch out of the associated Self::Indicator component.

fn required_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that must be provided by the user when constructing this archetype.

fn recommended_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that should be provided by the user when constructing this archetype.

fn optional_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that may be provided by the user when constructing this archetype.

fn all_components() -> Cow<'static, [ComponentDescriptor]>

Returns all component descriptors that must, should and may be provided by the user when constructing this archetype.

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentDescriptor, Arc<dyn Array>)>, ) -> Result<Clear, DeserializationError>

Given an iterator of Arrow arrays and their respective ComponentNames, deserializes them into this archetype.

fn from_arrow( data: impl IntoIterator<Item = (Field, Arc<dyn Array>)>, ) -> Result<Self, DeserializationError>

where Self: Sized,

Given an iterator of Arrow arrays and their respective field metadata, deserializes them into this archetype.

impl AsComponents for Clear

fn as_serialized_batches(&self) -> Vec<SerializedComponentBatch>

Exposes the object’s contents as a set of SerializedComponentBatches.

fn to_arrow(&self) -> Result<Vec<(Field, Arc<dyn Array>)>, SerializationError>

Serializes all non-null Components of this bundle into Arrow arrays.

impl Clone for Clear

fn clone(&self) -> Clear

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Clear

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

Formats the value using the given formatter.

impl Default for Clear

fn default() -> Clear

Returns the “default value” for a type.

impl PartialEq for Clear

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

fn heap_size_bytes(&self) -> u64

Returns how many bytes self uses on the heap.

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 ArchetypeReflectionMarker for Clear

impl StructuralPartialEq for Clear