pymomentum-cpu 0.1.77.post30__cp313-cp313-manylinux_2_39_x86_64.whl

include/rerun/datatypes/tensor_buffer.hpp

@@ -0,0 +1,529 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/tensor_buffer.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../half.hpp"
+#include "../result.hpp"
+#include "../type_traits.hpp"
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <new>
+#include <utility>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class DenseUnionBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    namespace detail {
+        /// \private
+        enum class TensorBufferTag : uint8_t {
+            /// Having a special empty state makes it possible to implement move-semantics. We need to be able to leave the object in a state which we can run the destructor on.
+            None = 0,
+            U8,
+            U16,
+            U32,
+            U64,
+            I8,
+            I16,
+            I32,
+            I64,
+            F16,
+            F32,
+            F64,
+        };
+
+        /// \private
+        union TensorBufferData {
+            /// 8bit unsigned integer.
+            rerun::Collection<uint8_t> u8;
+
+            /// 16bit unsigned integer.
+            rerun::Collection<uint16_t> u16;
+
+            /// 32bit unsigned integer.
+            rerun::Collection<uint32_t> u32;
+
+            /// 64bit unsigned integer.
+            rerun::Collection<uint64_t> u64;
+
+            /// 8bit signed integer.
+            rerun::Collection<int8_t> i8;
+
+            /// 16bit signed integer.
+            rerun::Collection<int16_t> i16;
+
+            /// 32bit signed integer.
+            rerun::Collection<int32_t> i32;
+
+            /// 64bit signed integer.
+            rerun::Collection<int64_t> i64;
+
+            /// 16bit IEEE-754 floating point, also known as `half`.
+            rerun::Collection<rerun::half> f16;
+
+            /// 32bit IEEE-754 floating point, also known as `float` or `single`.
+            rerun::Collection<float> f32;
+
+            /// 64bit IEEE-754 floating point, also known as `double`.
+            rerun::Collection<double> f64;
+
+            TensorBufferData() {
+                std::memset(reinterpret_cast<void*>(this), 0, sizeof(TensorBufferData));
+            }
+
+            ~TensorBufferData() {}
+
+            void swap(TensorBufferData& other) noexcept {
+                // This bitwise swap would fail for self-referential types, but we don't have any of those.
+                char temp[sizeof(TensorBufferData)];
+                void* otherbytes = reinterpret_cast<void*>(&other);
+                void* thisbytes = reinterpret_cast<void*>(this);
+                std::memcpy(temp, thisbytes, sizeof(TensorBufferData));
+                std::memcpy(thisbytes, otherbytes, sizeof(TensorBufferData));
+                std::memcpy(otherbytes, temp, sizeof(TensorBufferData));
+            }
+        };
+    } // namespace detail
+
+    /// **Datatype**: The underlying storage for `archetypes::Tensor`.
+    ///
+    /// Tensor elements are stored in a contiguous buffer of a single type.
+    struct TensorBuffer {
+        TensorBuffer() : _tag(detail::TensorBufferTag::None) {}
+
+        /// Copy constructor
+        TensorBuffer(const TensorBuffer& other) : _tag(other._tag) {
+            switch (other._tag) {
+                case detail::TensorBufferTag::U8: {
+                    using TypeAlias = rerun::Collection<uint8_t>;
+                    new (&_data.u8) TypeAlias(other._data.u8);
+                } break;
+                case detail::TensorBufferTag::U16: {
+                    using TypeAlias = rerun::Collection<uint16_t>;
+                    new (&_data.u16) TypeAlias(other._data.u16);
+                } break;
+                case detail::TensorBufferTag::U32: {
+                    using TypeAlias = rerun::Collection<uint32_t>;
+                    new (&_data.u32) TypeAlias(other._data.u32);
+                } break;
+                case detail::TensorBufferTag::U64: {
+                    using TypeAlias = rerun::Collection<uint64_t>;
+                    new (&_data.u64) TypeAlias(other._data.u64);
+                } break;
+                case detail::TensorBufferTag::I8: {
+                    using TypeAlias = rerun::Collection<int8_t>;
+                    new (&_data.i8) TypeAlias(other._data.i8);
+                } break;
+                case detail::TensorBufferTag::I16: {
+                    using TypeAlias = rerun::Collection<int16_t>;
+                    new (&_data.i16) TypeAlias(other._data.i16);
+                } break;
+                case detail::TensorBufferTag::I32: {
+                    using TypeAlias = rerun::Collection<int32_t>;
+                    new (&_data.i32) TypeAlias(other._data.i32);
+                } break;
+                case detail::TensorBufferTag::I64: {
+                    using TypeAlias = rerun::Collection<int64_t>;
+                    new (&_data.i64) TypeAlias(other._data.i64);
+                } break;
+                case detail::TensorBufferTag::F16: {
+                    using TypeAlias = rerun::Collection<rerun::half>;
+                    new (&_data.f16) TypeAlias(other._data.f16);
+                } break;
+                case detail::TensorBufferTag::F32: {
+                    using TypeAlias = rerun::Collection<float>;
+                    new (&_data.f32) TypeAlias(other._data.f32);
+                } break;
+                case detail::TensorBufferTag::F64: {
+                    using TypeAlias = rerun::Collection<double>;
+                    new (&_data.f64) TypeAlias(other._data.f64);
+                } break;
+                case detail::TensorBufferTag::None: {
+                } break;
+                default:
+                    assert(false && "unreachable");
+            }
+        }
+
+        TensorBuffer& operator=(const TensorBuffer& other) noexcept {
+            TensorBuffer tmp(other);
+            this->swap(tmp);
+            return *this;
+        }
+
+        TensorBuffer(TensorBuffer&& other) noexcept : TensorBuffer() {
+            this->swap(other);
+        }
+
+        TensorBuffer& operator=(TensorBuffer&& other) noexcept {
+            this->swap(other);
+            return *this;
+        }
+
+        ~TensorBuffer() {
+            switch (this->_tag) {
+                case detail::TensorBufferTag::None: {
+                    // Nothing to destroy
+                } break;
+                case detail::TensorBufferTag::U8: {
+                    using TypeAlias = rerun::Collection<uint8_t>;
+                    _data.u8.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::U16: {
+                    using TypeAlias = rerun::Collection<uint16_t>;
+                    _data.u16.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::U32: {
+                    using TypeAlias = rerun::Collection<uint32_t>;
+                    _data.u32.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::U64: {
+                    using TypeAlias = rerun::Collection<uint64_t>;
+                    _data.u64.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::I8: {
+                    using TypeAlias = rerun::Collection<int8_t>;
+                    _data.i8.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::I16: {
+                    using TypeAlias = rerun::Collection<int16_t>;
+                    _data.i16.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::I32: {
+                    using TypeAlias = rerun::Collection<int32_t>;
+                    _data.i32.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::I64: {
+                    using TypeAlias = rerun::Collection<int64_t>;
+                    _data.i64.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::F16: {
+                    using TypeAlias = rerun::Collection<rerun::half>;
+                    _data.f16.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::F32: {
+                    using TypeAlias = rerun::Collection<float>;
+                    _data.f32.~TypeAlias();
+                } break;
+                case detail::TensorBufferTag::F64: {
+                    using TypeAlias = rerun::Collection<double>;
+                    _data.f64.~TypeAlias();
+                } break;
+                default:
+                    assert(false && "unreachable");
+            }
+        }
+
+      public: // START of extensions from tensor_buffer_ext.cpp:
+        /// Construct a `TensorBuffer` from any container type that has a `value_type` member and for which a
+        /// `rerun::ContainerAdapter` exists.
+        ///
+        /// This constructor assumes the type of tensor buffer you want to use is defined by `TContainer::value_type`
+        /// and then forwards the argument as-is to the appropriate `rerun::Container` constructor.
+        /// \see rerun::ContainerAdapter, rerun::Container
+        template <typename TContainer, typename value_type = traits::value_type_of_t<TContainer>>
+        TensorBuffer(TContainer&& container)
+            : TensorBuffer(Collection<value_type>(std::forward<TContainer>(container))) {}
+
+        /// Number of elements in the buffer.
+        ///
+        /// You may NOT call this for NV12 or YUY2.
+        size_t num_elems() const;
+
+        // END of extensions from tensor_buffer_ext.cpp, start of generated code:
+
+        void swap(TensorBuffer& other) noexcept {
+            std::swap(this->_tag, other._tag);
+            this->_data.swap(other._data);
+        }
+
+        /// 8bit unsigned integer.
+        TensorBuffer(rerun::Collection<uint8_t> u8) : TensorBuffer() {
+            *this = TensorBuffer::u8(std::move(u8));
+        }
+
+        /// 16bit unsigned integer.
+        TensorBuffer(rerun::Collection<uint16_t> u16) : TensorBuffer() {
+            *this = TensorBuffer::u16(std::move(u16));
+        }
+
+        /// 32bit unsigned integer.
+        TensorBuffer(rerun::Collection<uint32_t> u32) : TensorBuffer() {
+            *this = TensorBuffer::u32(std::move(u32));
+        }
+
+        /// 64bit unsigned integer.
+        TensorBuffer(rerun::Collection<uint64_t> u64) : TensorBuffer() {
+            *this = TensorBuffer::u64(std::move(u64));
+        }
+
+        /// 8bit signed integer.
+        TensorBuffer(rerun::Collection<int8_t> i8) : TensorBuffer() {
+            *this = TensorBuffer::i8(std::move(i8));
+        }
+
+        /// 16bit signed integer.
+        TensorBuffer(rerun::Collection<int16_t> i16) : TensorBuffer() {
+            *this = TensorBuffer::i16(std::move(i16));
+        }
+
+        /// 32bit signed integer.
+        TensorBuffer(rerun::Collection<int32_t> i32) : TensorBuffer() {
+            *this = TensorBuffer::i32(std::move(i32));
+        }
+
+        /// 64bit signed integer.
+        TensorBuffer(rerun::Collection<int64_t> i64) : TensorBuffer() {
+            *this = TensorBuffer::i64(std::move(i64));
+        }
+
+        /// 16bit IEEE-754 floating point, also known as `half`.
+        TensorBuffer(rerun::Collection<rerun::half> f16) : TensorBuffer() {
+            *this = TensorBuffer::f16(std::move(f16));
+        }
+
+        /// 32bit IEEE-754 floating point, also known as `float` or `single`.
+        TensorBuffer(rerun::Collection<float> f32) : TensorBuffer() {
+            *this = TensorBuffer::f32(std::move(f32));
+        }
+
+        /// 64bit IEEE-754 floating point, also known as `double`.
+        TensorBuffer(rerun::Collection<double> f64) : TensorBuffer() {
+            *this = TensorBuffer::f64(std::move(f64));
+        }
+
+        /// 8bit unsigned integer.
+        static TensorBuffer u8(rerun::Collection<uint8_t> u8) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::U8;
+            new (&self._data.u8) rerun::Collection<uint8_t>(std::move(u8));
+            return self;
+        }
+
+        /// 16bit unsigned integer.
+        static TensorBuffer u16(rerun::Collection<uint16_t> u16) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::U16;
+            new (&self._data.u16) rerun::Collection<uint16_t>(std::move(u16));
+            return self;
+        }
+
+        /// 32bit unsigned integer.
+        static TensorBuffer u32(rerun::Collection<uint32_t> u32) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::U32;
+            new (&self._data.u32) rerun::Collection<uint32_t>(std::move(u32));
+            return self;
+        }
+
+        /// 64bit unsigned integer.
+        static TensorBuffer u64(rerun::Collection<uint64_t> u64) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::U64;
+            new (&self._data.u64) rerun::Collection<uint64_t>(std::move(u64));
+            return self;
+        }
+
+        /// 8bit signed integer.
+        static TensorBuffer i8(rerun::Collection<int8_t> i8) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::I8;
+            new (&self._data.i8) rerun::Collection<int8_t>(std::move(i8));
+            return self;
+        }
+
+        /// 16bit signed integer.
+        static TensorBuffer i16(rerun::Collection<int16_t> i16) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::I16;
+            new (&self._data.i16) rerun::Collection<int16_t>(std::move(i16));
+            return self;
+        }
+
+        /// 32bit signed integer.
+        static TensorBuffer i32(rerun::Collection<int32_t> i32) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::I32;
+            new (&self._data.i32) rerun::Collection<int32_t>(std::move(i32));
+            return self;
+        }
+
+        /// 64bit signed integer.
+        static TensorBuffer i64(rerun::Collection<int64_t> i64) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::I64;
+            new (&self._data.i64) rerun::Collection<int64_t>(std::move(i64));
+            return self;
+        }
+
+        /// 16bit IEEE-754 floating point, also known as `half`.
+        static TensorBuffer f16(rerun::Collection<rerun::half> f16) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::F16;
+            new (&self._data.f16) rerun::Collection<rerun::half>(std::move(f16));
+            return self;
+        }
+
+        /// 32bit IEEE-754 floating point, also known as `float` or `single`.
+        static TensorBuffer f32(rerun::Collection<float> f32) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::F32;
+            new (&self._data.f32) rerun::Collection<float>(std::move(f32));
+            return self;
+        }
+
+        /// 64bit IEEE-754 floating point, also known as `double`.
+        static TensorBuffer f64(rerun::Collection<double> f64) {
+            TensorBuffer self;
+            self._tag = detail::TensorBufferTag::F64;
+            new (&self._data.f64) rerun::Collection<double>(std::move(f64));
+            return self;
+        }
+
+        /// Return a pointer to u8 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<uint8_t>* get_u8() const {
+            if (_tag == detail::TensorBufferTag::U8) {
+                return &_data.u8;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to u16 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<uint16_t>* get_u16() const {
+            if (_tag == detail::TensorBufferTag::U16) {
+                return &_data.u16;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to u32 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<uint32_t>* get_u32() const {
+            if (_tag == detail::TensorBufferTag::U32) {
+                return &_data.u32;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to u64 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<uint64_t>* get_u64() const {
+            if (_tag == detail::TensorBufferTag::U64) {
+                return &_data.u64;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to i8 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<int8_t>* get_i8() const {
+            if (_tag == detail::TensorBufferTag::I8) {
+                return &_data.i8;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to i16 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<int16_t>* get_i16() const {
+            if (_tag == detail::TensorBufferTag::I16) {
+                return &_data.i16;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to i32 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<int32_t>* get_i32() const {
+            if (_tag == detail::TensorBufferTag::I32) {
+                return &_data.i32;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to i64 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<int64_t>* get_i64() const {
+            if (_tag == detail::TensorBufferTag::I64) {
+                return &_data.i64;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to f16 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<rerun::half>* get_f16() const {
+            if (_tag == detail::TensorBufferTag::F16) {
+                return &_data.f16;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to f32 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<float>* get_f32() const {
+            if (_tag == detail::TensorBufferTag::F32) {
+                return &_data.f32;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// Return a pointer to f64 if the union is in that state, otherwise `nullptr`.
+        const rerun::Collection<double>* get_f64() const {
+            if (_tag == detail::TensorBufferTag::F64) {
+                return &_data.f64;
+            } else {
+                return nullptr;
+            }
+        }
+
+        /// \private
+        const detail::TensorBufferData& get_union_data() const {
+            return _data;
+        }
+
+        /// \private
+        detail::TensorBufferTag get_union_tag() const {
+            return _tag;
+        }
+
+      private:
+        detail::TensorBufferTag _tag;
+        detail::TensorBufferData _data;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::TensorBuffer> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.TensorBuffer";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::TensorBuffer` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::TensorBuffer* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::DenseUnionBuilder* builder, const datatypes::TensorBuffer* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/tensor_data.hpp

@@ -0,0 +1,100 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/tensor_data.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+#include "tensor_buffer.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: An N-dimensional array of numbers.
+    ///
+    /// The number of dimensions and their respective lengths is specified by the `shape` field.
+    /// The dimensions are ordered from outermost to innermost. For example, in the common case of
+    /// a 2D RGB Image, the shape would be `[height, width, channel]`.
+    ///
+    /// These dimensions are combined with an index to look up values from the `buffer` field,
+    /// which stores a contiguous array of typed values.
+    struct TensorData {
+        /// The shape of the tensor, i.e. the length of each dimension.
+        rerun::Collection<uint64_t> shape;
+
+        /// The names of the dimensions of the tensor (optional).
+        ///
+        /// If set, should be the same length as `datatypes::TensorData::shape`.
+        /// If it has a different length your names may show up improperly,
+        /// and some constructors may produce a warning or even an error.
+        ///
+        /// Example: `["height", "width", "channel", "batch"]`.
+        std::optional<rerun::Collection<std::string>> names;
+
+        /// The content/data.
+        rerun::datatypes::TensorBuffer buffer;
+
+      public: // START of extensions from tensor_data_ext.cpp:
+        /// New tensor data from shape and tensor buffer.
+        ///
+        /// \param shape_ Shape of the tensor.
+        /// \param buffer_ The tensor buffer containing the tensor's data.
+        TensorData(Collection<uint64_t> shape_, datatypes::TensorBuffer buffer_)
+            : shape(std::move(shape_)), buffer(std::move(buffer_)) {}
+
+        /// New tensor data from dimensions and pointer to tensor data.
+        ///
+        /// Type must be one of the types supported by `rerun::datatypes::TensorData`.
+        /// \param shape_ Shape of the tensor. Determines the number of elements expected to be in `data`.
+        /// \param data Target of the pointer must outlive the archetype.
+        template <typename TElement>
+        explicit TensorData(Collection<uint64_t> shape_, const TElement* data)
+            : shape(std::move(shape_)) {
+            size_t num_elements = shape.empty() ? 0 : 1;
+            for (const auto& dim : shape) {
+                num_elements *= dim;
+            }
+            buffer = rerun::Collection<TElement>::borrow(data, num_elements);
+        }
+
+        // END of extensions from tensor_data_ext.cpp, start of generated code:
+
+      public:
+        TensorData() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::TensorData> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.datatypes.TensorData";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::TensorData` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::TensorData* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::TensorData* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/datatypes/tensor_dimension_index_selection.hpp

@@ -0,0 +1,58 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/datatypes/tensor_dimension_selection.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    class Array;
+    class DataType;
+    class StructBuilder;
+} // namespace arrow
+
+namespace rerun::datatypes {
+    /// **Datatype**: Indexing a specific tensor dimension.
+    ///
+    /// Selecting `dimension=2` and `index=42` is similar to doing `tensor[:, :, 42, :, :, …]` in numpy.
+    struct TensorDimensionIndexSelection {
+        /// The dimension number to select.
+        uint32_t dimension;
+
+        /// The index along the dimension to use.
+        uint64_t index;
+
+      public:
+        TensorDimensionIndexSelection() = default;
+    };
+} // namespace rerun::datatypes
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<datatypes::TensorDimensionIndexSelection> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.datatypes.TensorDimensionIndexSelection";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::datatypes::TensorDimensionIndexSelection` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const datatypes::TensorDimensionIndexSelection* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::StructBuilder* builder, const datatypes::TensorDimensionIndexSelection* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun