Struct StateConfiguration 

pub struct StateConfiguration {
    pub values: Option<SerializedComponentBatch>,
    pub labels: Option<SerializedComponentBatch>,
    pub colors: Option<SerializedComponentBatch>,
    pub visible: Option<SerializedComponentBatch>,
}

Archetype: Define the style and mapping for state values in a state timeline view.

This archetype provides configuration for how state values are displayed. It maps raw state values to display labels, colors, and visibility.

values, labels, colors, and visible are parallel arrays: the entry at index i of each describes the same state value, and only the per-index pairing is meaningful. The four arrays should have matching length; any secondary array (labels, colors, visible) that is shorter than values falls back to defaults for the missing entries.

It’s generally recommended to log this type as static.

The underlying data needs to be logged to the same entity path using archetypes::StateChange.

⚠️ This type is unstable and may change significantly in a way that the data won’t be backwards compatible.

Example

State changes with a custom style

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

    // Configure how each raw state value is displayed (label, color, visibility).
    rec.log_static(
        "door",
        &rerun::StateConfiguration::new()
            .with_values(["open", "closed"])
            .with_labels(["Open", "Closed"])
            .with_colors([0x4CAF50FFu32, 0xEF5350FFu32]),
    )?;

    rec.set_time_sequence("step", 0);
    rec.log("door", &rerun::StateChange::new().with_state("open"))?;

    rec.set_time_sequence("step", 1);
    rec.log("door", &rerun::StateChange::new().with_state("closed"))?;

    rec.set_time_sequence("step", 2);
    rec.log("door", &rerun::StateChange::new().with_state("open"))?;

    Ok(())
}

Fields

values: Option<SerializedComponentBatch>

The raw state values that this configuration applies to.

Each entry defines a known state value. The order determines the mapping to labels, colors, and visible (by index).

labels: Option<SerializedComponentBatch>

Display labels for each state value.

If provided, the label at index i is shown instead of the raw value at index i. If not provided or shorter than values, the raw value is used as the label.

colors: Option<SerializedComponentBatch>

Colors for each state value.

If provided, the color at index i is used for the state at index i. If not provided, colors are assigned automatically from a built-in palette.

visible: Option<SerializedComponentBatch>

Visibility for each state value.

If provided, the visibility at index i controls whether the state at index i is shown. If not provided, all state values are visible.

Implementations

impl StateConfiguration

pub fn descriptor_values() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::values.

The corresponding component is crate::components::Text.

pub fn descriptor_labels() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::labels.

The corresponding component is crate::components::Text.

pub fn descriptor_colors() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::colors.

The corresponding component is crate::components::Color.

pub fn descriptor_visible() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::visible.

The corresponding component is crate::components::Visible.

impl StateConfiguration

pub const NUM_COMPONENTS: usize = 4usize

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

impl StateConfiguration

pub fn new() -> StateConfiguration

Create a new StateConfiguration.

pub fn update_fields() -> StateConfiguration

Update only some specific fields of a StateConfiguration.

pub fn clear_fields() -> StateConfiguration

Clear all the fields of a StateConfiguration.

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_values( self, values: impl IntoIterator<Item = impl Into<Text>>, ) -> StateConfiguration

The raw state values that this configuration applies to.

Each entry defines a known state value. The order determines the mapping to labels, colors, and visible (by index).

pub fn with_labels( self, labels: impl IntoIterator<Item = impl Into<Text>>, ) -> StateConfiguration

Display labels for each state value.

If provided, the label at index i is shown instead of the raw value at index i. If not provided or shorter than values, the raw value is used as the label.

pub fn with_colors( self, colors: impl IntoIterator<Item = impl Into<Color>>, ) -> StateConfiguration

Colors for each state value.

If provided, the color at index i is used for the state at index i. If not provided, colors are assigned automatically from a built-in palette.

pub fn with_visible( self, visible: impl IntoIterator<Item = impl Into<Visible>>, ) -> StateConfiguration

Visibility for each state value.

If provided, the visibility at index i controls whether the state at index i is shown. If not provided, all state values are visible.

Trait Implementations

impl Archetype for StateConfiguration

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 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<StateConfiguration, DeserializationError>

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

fn all_component_identifiers() -> impl Iterator<Item = ComponentIdentifier>

Utility method based on Self::all_components to return all component identifiers.

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 StateConfiguration

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 StateConfiguration

fn clone(&self) -> StateConfiguration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StateConfiguration

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

Formats the value using the given formatter.

impl Default for StateConfiguration

fn default() -> StateConfiguration

Returns the “default value” for a type.

impl PartialEq for StateConfiguration

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl SizeBytes for StateConfiguration

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

where Self: Sized,

Is Self just plain old data?

impl VisualizableArchetype for StateConfiguration

fn visualizer(&self) -> Visualizer

Create a visualizer for this archetype, using all currently set values as overrides.

impl ArchetypeReflectionMarker for StateConfiguration

impl StructuralPartialEq for StateConfiguration