Struct re_types::testing::archetypes::AffixFuzzer3

pub struct AffixFuzzer3 {

    pub fuzz2001: Option<SerializedComponentBatch>,
    pub fuzz2002: Option<SerializedComponentBatch>,
    pub fuzz2003: Option<SerializedComponentBatch>,
    pub fuzz2004: Option<SerializedComponentBatch>,
    pub fuzz2005: Option<SerializedComponentBatch>,
    pub fuzz2006: Option<SerializedComponentBatch>,
    pub fuzz2007: Option<SerializedComponentBatch>,
    pub fuzz2008: Option<SerializedComponentBatch>,
    pub fuzz2009: Option<SerializedComponentBatch>,
    pub fuzz2010: Option<SerializedComponentBatch>,
    pub fuzz2011: Option<SerializedComponentBatch>,
    pub fuzz2012: Option<SerializedComponentBatch>,
    pub fuzz2013: Option<SerializedComponentBatch>,
    pub fuzz2014: Option<SerializedComponentBatch>,
    pub fuzz2015: Option<SerializedComponentBatch>,
    pub fuzz2016: Option<SerializedComponentBatch>,
    pub fuzz2017: Option<SerializedComponentBatch>,
    pub fuzz2018: Option<SerializedComponentBatch>,
}

Fields

fuzz2001: Option<SerializedComponentBatch>

fuzz2002: Option<SerializedComponentBatch>

fuzz2003: Option<SerializedComponentBatch>

fuzz2004: Option<SerializedComponentBatch>

fuzz2005: Option<SerializedComponentBatch>

fuzz2006: Option<SerializedComponentBatch>

fuzz2007: Option<SerializedComponentBatch>

fuzz2008: Option<SerializedComponentBatch>

fuzz2009: Option<SerializedComponentBatch>

fuzz2010: Option<SerializedComponentBatch>

fuzz2011: Option<SerializedComponentBatch>

fuzz2012: Option<SerializedComponentBatch>

fuzz2013: Option<SerializedComponentBatch>

fuzz2014: Option<SerializedComponentBatch>

fuzz2015: Option<SerializedComponentBatch>

fuzz2016: Option<SerializedComponentBatch>

fuzz2017: Option<SerializedComponentBatch>

fuzz2018: Option<SerializedComponentBatch>

Implementations

impl AffixFuzzer3

pub fn descriptor_fuzz2001() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2001.

pub fn descriptor_fuzz2002() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2002.

pub fn descriptor_fuzz2003() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2003.

pub fn descriptor_fuzz2004() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2004.

pub fn descriptor_fuzz2005() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2005.

pub fn descriptor_fuzz2006() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2006.

pub fn descriptor_fuzz2007() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2007.

pub fn descriptor_fuzz2008() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2008.

pub fn descriptor_fuzz2009() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2009.

pub fn descriptor_fuzz2010() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2010.

pub fn descriptor_fuzz2011() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2011.

pub fn descriptor_fuzz2012() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2012.

pub fn descriptor_fuzz2013() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2013.

pub fn descriptor_fuzz2014() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2014.

pub fn descriptor_fuzz2015() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2015.

pub fn descriptor_fuzz2016() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2016.

pub fn descriptor_fuzz2017() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2017.

pub fn descriptor_fuzz2018() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::fuzz2018.

pub fn descriptor_indicator() -> ComponentDescriptor

Returns the ComponentDescriptor for the associated indicator component.

impl AffixFuzzer3

pub const NUM_COMPONENTS: usize = 19usize

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

impl AffixFuzzer3

pub fn new() -> Self

Create a new AffixFuzzer3.

pub fn update_fields() -> Self

Update only some specific fields of a AffixFuzzer3.

pub fn clear_fields() -> Self

Clear all the fields of a AffixFuzzer3.

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

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, ) -> SerializationResult<impl Iterator<Item = SerializedComponentColumn>>

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_fuzz2001(self, fuzz2001: impl Into<AffixFuzzer1>) -> Self

pub fn with_many_fuzz2001( self, fuzz2001: impl IntoIterator<Item = impl Into<AffixFuzzer1>>, ) -> Self

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

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

pub fn with_fuzz2002(self, fuzz2002: impl Into<AffixFuzzer2>) -> Self

pub fn with_many_fuzz2002( self, fuzz2002: impl IntoIterator<Item = impl Into<AffixFuzzer2>>, ) -> Self

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

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

pub fn with_fuzz2003(self, fuzz2003: impl Into<AffixFuzzer3>) -> Self

pub fn with_many_fuzz2003( self, fuzz2003: impl IntoIterator<Item = impl Into<AffixFuzzer3>>, ) -> Self

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

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

pub fn with_fuzz2004(self, fuzz2004: impl Into<AffixFuzzer4>) -> Self

pub fn with_many_fuzz2004( self, fuzz2004: impl IntoIterator<Item = impl Into<AffixFuzzer4>>, ) -> Self

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

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

pub fn with_fuzz2005(self, fuzz2005: impl Into<AffixFuzzer5>) -> Self

pub fn with_many_fuzz2005( self, fuzz2005: impl IntoIterator<Item = impl Into<AffixFuzzer5>>, ) -> Self

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

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

pub fn with_fuzz2006(self, fuzz2006: impl Into<AffixFuzzer6>) -> Self

pub fn with_many_fuzz2006( self, fuzz2006: impl IntoIterator<Item = impl Into<AffixFuzzer6>>, ) -> Self

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

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

pub fn with_fuzz2007(self, fuzz2007: impl Into<AffixFuzzer7>) -> Self

pub fn with_many_fuzz2007( self, fuzz2007: impl IntoIterator<Item = impl Into<AffixFuzzer7>>, ) -> Self

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

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

pub fn with_fuzz2008(self, fuzz2008: impl Into<AffixFuzzer8>) -> Self

pub fn with_many_fuzz2008( self, fuzz2008: impl IntoIterator<Item = impl Into<AffixFuzzer8>>, ) -> Self

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

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

pub fn with_fuzz2009(self, fuzz2009: impl Into<AffixFuzzer9>) -> Self

pub fn with_many_fuzz2009( self, fuzz2009: impl IntoIterator<Item = impl Into<AffixFuzzer9>>, ) -> Self

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

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

pub fn with_fuzz2010(self, fuzz2010: impl Into<AffixFuzzer10>) -> Self

pub fn with_many_fuzz2010( self, fuzz2010: impl IntoIterator<Item = impl Into<AffixFuzzer10>>, ) -> Self

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

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

pub fn with_fuzz2011(self, fuzz2011: impl Into<AffixFuzzer11>) -> Self

pub fn with_many_fuzz2011( self, fuzz2011: impl IntoIterator<Item = impl Into<AffixFuzzer11>>, ) -> Self

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

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

pub fn with_fuzz2012(self, fuzz2012: impl Into<AffixFuzzer12>) -> Self

pub fn with_many_fuzz2012( self, fuzz2012: impl IntoIterator<Item = impl Into<AffixFuzzer12>>, ) -> Self

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

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

pub fn with_fuzz2013(self, fuzz2013: impl Into<AffixFuzzer13>) -> Self

pub fn with_many_fuzz2013( self, fuzz2013: impl IntoIterator<Item = impl Into<AffixFuzzer13>>, ) -> Self

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

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

pub fn with_fuzz2014(self, fuzz2014: impl Into<AffixFuzzer14>) -> Self

pub fn with_many_fuzz2014( self, fuzz2014: impl IntoIterator<Item = impl Into<AffixFuzzer14>>, ) -> Self

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

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

pub fn with_fuzz2015(self, fuzz2015: impl Into<AffixFuzzer15>) -> Self

pub fn with_many_fuzz2015( self, fuzz2015: impl IntoIterator<Item = impl Into<AffixFuzzer15>>, ) -> Self

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

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

pub fn with_fuzz2016(self, fuzz2016: impl Into<AffixFuzzer16>) -> Self

pub fn with_many_fuzz2016( self, fuzz2016: impl IntoIterator<Item = impl Into<AffixFuzzer16>>, ) -> Self

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

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

pub fn with_fuzz2017(self, fuzz2017: impl Into<AffixFuzzer17>) -> Self

pub fn with_many_fuzz2017( self, fuzz2017: impl IntoIterator<Item = impl Into<AffixFuzzer17>>, ) -> Self

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

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

pub fn with_fuzz2018(self, fuzz2018: impl Into<AffixFuzzer18>) -> Self

pub fn with_many_fuzz2018( self, fuzz2018: impl IntoIterator<Item = impl Into<AffixFuzzer18>>, ) -> Self

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

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

Trait Implementations

impl Archetype for AffixFuzzer3

type Indicator = GenericIndicatorComponent<AffixFuzzer3>

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, ArrayRef)>, ) -> DeserializationResult<Self>

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 AffixFuzzer3

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 AffixFuzzer3

fn clone(&self) -> AffixFuzzer3

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AffixFuzzer3

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

Formats the value using the given formatter.

impl Default for AffixFuzzer3

fn default() -> AffixFuzzer3

Returns the “default value” for a type.

impl PartialEq for AffixFuzzer3

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

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 AffixFuzzer3

impl StructuralPartialEq for AffixFuzzer3