Introduce codegen optimizations for primitives and fixed-sized-arrays

crates/re_log_types/src/data_cell.rs

@@ -362,17 +362,8 @@ impl DataCell {
     pub fn try_to_native<'a, C: Component + Default + 'a>(
         &'a self,
     ) -> DataCellResult<impl Iterator<Item = C> + '_> {
-        Ok(C::try_iter_from_arrow(self.inner.values.as_ref())?
-            .map(C::convert_item_to_self)
-            .map(|v| {
-                // TODO(#2523): This unwrap and the `Default` bounds should go away once we move to fallible iterators
-                v.unwrap_or_else(|| {
-                    re_log::warn_once!(
-                        "Unexpected missing data when iterating non-optional data-cell. Falling back on Default value."
-                    );
-                    C::default()
-                })
-            }))
+        re_tracing::profile_function!(C::name().as_str());
+        Ok(C::try_iter_from_arrow(self.inner.values.as_ref())?.map(C::convert_item_to_self))
     }
 
     /// Returns the contents of an expected mono-component as an `Option<C>`.
@@ -381,7 +372,7 @@ impl DataCell {
     #[inline]
     pub fn try_to_native_mono<'a, C: Component + 'a>(&'a self) -> DataCellResult<Option<C>> {
         let mut iter =
-            C::try_iter_from_arrow(self.inner.values.as_ref())?.map(C::convert_item_to_self);
+            C::try_iter_from_arrow(self.inner.values.as_ref())?.map(C::convert_item_to_opt_self);
 
         let result = match iter.next() {
             // It's ok to have no result from the iteration: this is what we
@@ -420,7 +411,7 @@ impl DataCell {
     pub fn try_to_native_opt<'a, C: Component + 'a>(
         &'a self,
     ) -> DataCellResult<impl Iterator<Item = Option<C>> + '_> {
-        Ok(C::try_iter_from_arrow(self.inner.values.as_ref())?.map(C::convert_item_to_self))
+        Ok(C::try_iter_from_arrow(self.inner.values.as_ref())?.map(C::convert_item_to_opt_self))
     }
 
     /// Returns the contents of the cell as an iterator of native optional components.

crates/re_log_types/src/lib.rs

@@ -485,7 +485,7 @@ macro_rules! component_legacy_shim {
             }
 
             #[inline]
-            fn convert_item_to_self(item: Self::Item<'_>) -> Option<Self> {
+            fn convert_item_to_opt_self(item: Self::Item<'_>) -> Option<Self> {
                 <Self as arrow2_convert::deserialize::ArrowDeserialize>::arrow_deserialize(item)
             }
         }

crates/re_types/src/arrow_buffer.rs

@@ -0,0 +1,30 @@
+use arrow2::buffer::Buffer;
+
+/// Convenience-wrapper around an arrow [`Buffer`] that is known to contain a
+/// a primitive type.
+///
+/// The arrow2 [`Buffer`] object is internally reference-counted and can be
+/// easily converted back to a `&[T]` referencing the underlying storage.
+/// This avoids some of the lifetime complexities that would otherwise
+/// arise from returning a `&[T]` directly, but is significantly more
+/// performant than doing the full allocation necessary to return a `Vec<T>`.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ArrowBuffer<T>(pub Buffer<T>);
+
+impl<T> ArrowBuffer<T> {
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl<T> From<Vec<T>> for ArrowBuffer<T> {
+    fn from(value: Vec<T>) -> Self {
+        Self(value.into())
+    }
+}