pymomentum-cpu 0.1.82.post0__cp312-cp312-macosx_14_0_arm64.whl

include/rerun/archetypes/tensor.hpp

@@ -0,0 +1,213 @@
+// 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/archetypes/tensor.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_batch.hpp"
+#include "../component_column.hpp"
+#include "../components/tensor_data.hpp"
+#include "../components/value_range.hpp"
+#include "../indicator_component.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::archetypes {
+    /// **Archetype**: An N-dimensional array of numbers.
+    ///
+    /// Since the underlying `rerun::datatypes::TensorData` uses `rerun::Collection` internally,
+    /// data can be passed in without a copy from raw pointers or by reference from `std::vector`/`std::array`/c-arrays.
+    /// If needed, this "borrow-behavior" can be extended by defining your own `rerun::CollectionAdapter`.
+    ///
+    /// ## Example
+    ///
+    /// ### Simple tensor
+    /// ![image](https://static.rerun.io/tensor_simple/baacb07712f7b706e3c80e696f70616c6c20b367/full.png)
+    ///
+    /// ```cpp
+    /// #include <rerun.hpp>
+    ///
+    /// #include <algorithm> // std::generate
+    /// #include <random>
+    /// #include <vector>
+    ///
+    /// int main() {
+    ///     const auto rec = rerun::RecordingStream("rerun_example_tensor");
+    ///     rec.spawn().exit_on_failure();
+    ///
+    ///     std::default_random_engine gen;
+    ///     // On MSVC uint8_t distributions are not supported.
+    ///     std::uniform_int_distribution<int> dist(0, 255);
+    ///
+    ///     std::vector<uint8_t> data(8 * 6 * 3 * 5);
+    ///     std::generate(data.begin(), data.end(), [&] { return static_cast<uint8_t>(dist(gen)); });
+    ///
+    ///     rec.log(
+    ///         "tensor",
+    ///         rerun::Tensor({8, 6, 3, 5}, data).with_dim_names({"width", "height", "channel", "batch"})
+    ///     );
+    /// }
+    /// ```
+    struct Tensor {
+        /// The tensor data
+        std::optional<ComponentBatch> data;
+
+        /// The expected range of values.
+        ///
+        /// This is typically the expected range of valid values.
+        /// Everything outside of the range is clamped to the range for the purpose of colormpaping.
+        /// Any colormap applied for display, will map this range.
+        ///
+        /// If not specified, the range will be automatically estimated from the data.
+        /// Note that the Viewer may try to guess a wider range than the minimum/maximum of values
+        /// in the contents of the tensor.
+        /// E.g. if all values are positive, some bigger than 1.0 and all smaller than 255.0,
+        /// the Viewer will guess that the data likely came from an 8bit image, thus assuming a range of 0-255.
+        std::optional<ComponentBatch> value_range;
+
+      public:
+        static constexpr const char IndicatorComponentName[] = "rerun.components.TensorIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.archetypes.Tensor";
+
+        /// `ComponentDescriptor` for the `data` field.
+        static constexpr auto Descriptor_data = ComponentDescriptor(
+            ArchetypeName, "data",
+            Loggable<rerun::components::TensorData>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `value_range` field.
+        static constexpr auto Descriptor_value_range = ComponentDescriptor(
+            ArchetypeName, "value_range",
+            Loggable<rerun::components::ValueRange>::Descriptor.component_name
+        );
+
+      public: // START of extensions from tensor_ext.cpp:
+        RR_DISABLE_MAYBE_UNINITIALIZED_PUSH
+
+        /// New Tensor from dimensions and tensor buffer.
+        Tensor(Collection<uint64_t> shape, datatypes::TensorBuffer buffer)
+            : Tensor(datatypes::TensorData(std::move(shape), std::move(buffer))) {}
+
+        RR_DISABLE_MAYBE_UNINITIALIZED_POP
+
+        /// New tensor from dimensions and pointer to tensor data.
+        ///
+        /// Type must be one of the types supported by `rerun::datatypes::TensorData`.
+        /// \param shape
+        /// Shape of the image. Determines the number of elements expected to be in `data`.
+        /// \param data_
+        /// Target of the pointer must outlive the archetype.
+        template <typename TElement>
+        explicit Tensor(Collection<uint64_t> shape, const TElement* data_)
+            : Tensor(datatypes::TensorData(std::move(shape), data_)) {}
+
+        /// Update the `names` of the contained `TensorData` dimensions.
+        ///
+        /// Any existing Dimension names will be overwritten.
+        ///
+        /// If too many, or too few names are provided, this function will call
+        /// Error::handle and then proceed to only update the subset of names that it can.
+        Tensor with_dim_names(Collection<std::string> names) &&;
+
+        // END of extensions from tensor_ext.cpp, start of generated code:
+
+      public:
+        Tensor() = default;
+        Tensor(Tensor&& other) = default;
+        Tensor(const Tensor& other) = default;
+        Tensor& operator=(const Tensor& other) = default;
+        Tensor& operator=(Tensor&& other) = default;
+
+        explicit Tensor(rerun::components::TensorData _data)
+            : data(ComponentBatch::from_loggable(std::move(_data), Descriptor_data).value_or_throw()
+              ) {}
+
+        /// Update only some specific fields of a `Tensor`.
+        static Tensor update_fields() {
+            return Tensor();
+        }
+
+        /// Clear all the fields of a `Tensor`.
+        static Tensor clear_fields();
+
+        /// The tensor data
+        Tensor with_data(const rerun::components::TensorData& _data) && {
+            data = ComponentBatch::from_loggable(_data, Descriptor_data).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `data` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_data` should
+        /// be used when logging a single row's worth of data.
+        Tensor with_many_data(const Collection<rerun::components::TensorData>& _data) && {
+            data = ComponentBatch::from_loggable(_data, Descriptor_data).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The expected range of values.
+        ///
+        /// This is typically the expected range of valid values.
+        /// Everything outside of the range is clamped to the range for the purpose of colormpaping.
+        /// Any colormap applied for display, will map this range.
+        ///
+        /// If not specified, the range will be automatically estimated from the data.
+        /// Note that the Viewer may try to guess a wider range than the minimum/maximum of values
+        /// in the contents of the tensor.
+        /// E.g. if all values are positive, some bigger than 1.0 and all smaller than 255.0,
+        /// the Viewer will guess that the data likely came from an 8bit image, thus assuming a range of 0-255.
+        Tensor with_value_range(const rerun::components::ValueRange& _value_range) && {
+            value_range = ComponentBatch::from_loggable(_value_range, Descriptor_value_range)
+                              .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `value_range` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_value_range` should
+        /// be used when logging a single row's worth of data.
+        Tensor with_many_value_range(const Collection<rerun::components::ValueRange>& _value_range
+        ) && {
+            value_range = ComponentBatch::from_loggable(_value_range, Descriptor_value_range)
+                              .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::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.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<archetypes::Tensor> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(const archetypes::Tensor& archetype);
+    };
+} // namespace rerun

include/rerun/archetypes/text_document.hpp

@@ -0,0 +1,200 @@
+// 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/archetypes/text_document.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_batch.hpp"
+#include "../component_column.hpp"
+#include "../components/media_type.hpp"
+#include "../components/text.hpp"
+#include "../indicator_component.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::archetypes {
+    /// **Archetype**: A text element intended to be displayed in its own text box.
+    ///
+    /// Supports raw text and markdown.
+    ///
+    /// ## Example
+    ///
+    /// ### Markdown text document
+    /// ![image](https://static.rerun.io/textdocument/babda19558ee32ed8d730495b595aee7a5e2c174/full.png)
+    ///
+    /// ```cpp
+    /// #include <rerun.hpp>
+    ///
+    /// int main() {
+    ///     const auto rec = rerun::RecordingStream("rerun_example_text_document");
+    ///     rec.spawn().exit_on_failure();
+    ///
+    ///     rec.log("text_document", rerun::TextDocument("Hello, TextDocument!"));
+    ///
+    ///     rec.log(
+    ///         "markdown",
+    ///         rerun::TextDocument(R"#(# Hello Markdown!
+    /// [Click here to see the raw text](recording://markdown:Text).
+    ///
+    /// Basic formatting:
+    ///
+    /// | **Feature**       | **Alternative** |
+    /// | ----------------- | --------------- |
+    /// | Plain             |                 |
+    /// | *italics*         | _italics_       |
+    /// | **bold**          | __bold__        |
+    /// | ~~strikethrough~~ |                 |
+    /// | `inline code`     |                 |
+    ///
+    /// ----------------------------------
+    ///
+    /// ## Support
+    /// - [x] [Commonmark](https://commonmark.org/help/) support
+    /// - [x] GitHub-style strikethrough, tables, and checkboxes
+    /// - Basic syntax highlighting for:
+    ///   - [x] C and C++
+    ///   - [x] Python
+    ///   - [x] Rust
+    ///   - [ ] Other languages
+    ///
+    /// ## Links
+    /// You can link to [an entity](recording://markdown),
+    /// a [specific instance of an entity](recording://markdown[#0]),
+    /// or a [specific component](recording://markdown:Text).
+    ///
+    /// Of course you can also have [normal https links](https://github.com/rerun-io/rerun), e.g. <https://rerun.io>.
+    ///
+    /// ## Image
+    /// ![A random image](https://picsum.photos/640/480))#")
+    ///             .with_media_type(rerun::MediaType::markdown())
+    ///     );
+    /// }
+    /// ```
+    struct TextDocument {
+        /// Contents of the text document.
+        std::optional<ComponentBatch> text;
+
+        /// The Media Type of the text.
+        ///
+        /// For instance:
+        /// * `text/plain`
+        /// * `text/markdown`
+        ///
+        /// If omitted, `text/plain` is assumed.
+        std::optional<ComponentBatch> media_type;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.components.TextDocumentIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.archetypes.TextDocument";
+
+        /// `ComponentDescriptor` for the `text` field.
+        static constexpr auto Descriptor_text = ComponentDescriptor(
+            ArchetypeName, "text", Loggable<rerun::components::Text>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `media_type` field.
+        static constexpr auto Descriptor_media_type = ComponentDescriptor(
+            ArchetypeName, "media_type",
+            Loggable<rerun::components::MediaType>::Descriptor.component_name
+        );
+
+      public:
+        TextDocument() = default;
+        TextDocument(TextDocument&& other) = default;
+        TextDocument(const TextDocument& other) = default;
+        TextDocument& operator=(const TextDocument& other) = default;
+        TextDocument& operator=(TextDocument&& other) = default;
+
+        explicit TextDocument(rerun::components::Text _text)
+            : text(ComponentBatch::from_loggable(std::move(_text), Descriptor_text).value_or_throw()
+              ) {}
+
+        /// Update only some specific fields of a `TextDocument`.
+        static TextDocument update_fields() {
+            return TextDocument();
+        }
+
+        /// Clear all the fields of a `TextDocument`.
+        static TextDocument clear_fields();
+
+        /// Contents of the text document.
+        TextDocument with_text(const rerun::components::Text& _text) && {
+            text = ComponentBatch::from_loggable(_text, Descriptor_text).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `text` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_text` should
+        /// be used when logging a single row's worth of data.
+        TextDocument with_many_text(const Collection<rerun::components::Text>& _text) && {
+            text = ComponentBatch::from_loggable(_text, Descriptor_text).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The Media Type of the text.
+        ///
+        /// For instance:
+        /// * `text/plain`
+        /// * `text/markdown`
+        ///
+        /// If omitted, `text/plain` is assumed.
+        TextDocument with_media_type(const rerun::components::MediaType& _media_type) && {
+            media_type =
+                ComponentBatch::from_loggable(_media_type, Descriptor_media_type).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `media_type` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_media_type` should
+        /// be used when logging a single row's worth of data.
+        TextDocument with_many_media_type(
+            const Collection<rerun::components::MediaType>& _media_type
+        ) && {
+            media_type =
+                ComponentBatch::from_loggable(_media_type, Descriptor_media_type).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::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.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<archetypes::TextDocument> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const archetypes::TextDocument& archetype
+        );
+    };
+} // namespace rerun

include/rerun/archetypes/text_log.hpp

@@ -0,0 +1,211 @@
+// 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/archetypes/text_log.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_batch.hpp"
+#include "../component_column.hpp"
+#include "../components/color.hpp"
+#include "../components/text.hpp"
+#include "../components/text_log_level.hpp"
+#include "../indicator_component.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::archetypes {
+    /// **Archetype**: A log entry in a text log, comprised of a text body and its log level.
+    ///
+    /// ## Example
+    ///
+    /// ### text_log_integration:
+    /// ![image](https://static.rerun.io/text_log_integration/9737d0c986325802a9885499d6fcc773b1736488/full.png)
+    ///
+    /// ```cpp
+    /// #include <loguru.hpp>
+    /// #include <rerun.hpp>
+    ///
+    /// void loguru_to_rerun(void* user_data, const loguru::Message& message) {
+    ///     // NOTE: `rerun::RecordingStream` is thread-safe.
+    ///     const rerun::RecordingStream* rec = reinterpret_cast<const rerun::RecordingStream*>(user_data);
+    ///
+    ///     rerun::TextLogLevel level;
+    ///     if (message.verbosity == loguru::Verbosity_FATAL) {
+    ///         level = rerun::TextLogLevel::Critical;
+    ///     } else if (message.verbosity == loguru::Verbosity_ERROR) {
+    ///         level = rerun::TextLogLevel::Error;
+    ///     } else if (message.verbosity == loguru::Verbosity_WARNING) {
+    ///         level = rerun::TextLogLevel::Warning;
+    ///     } else if (message.verbosity == loguru::Verbosity_INFO) {
+    ///         level = rerun::TextLogLevel::Info;
+    ///     } else if (message.verbosity == loguru::Verbosity_1) {
+    ///         level = rerun::TextLogLevel::Debug;
+    ///     } else if (message.verbosity == loguru::Verbosity_2) {
+    ///         level = rerun::TextLogLevel::Trace;
+    ///     } else {
+    ///         level = rerun::TextLogLevel(std::to_string(message.verbosity));
+    ///     }
+    ///
+    ///     rec->log(
+    ///         "logs/handler/text_log_integration",
+    ///         rerun::TextLog(message.message).with_level(level)
+    ///     );
+    /// }
+    ///
+    /// int main() {
+    ///     const auto rec = rerun::RecordingStream("rerun_example_text_log_integration");
+    ///     rec.spawn().exit_on_failure();
+    ///
+    ///     // Log a text entry directly:
+    ///     rec.log(
+    ///         "logs",
+    ///         rerun::TextLog("this entry has loglevel TRACE").with_level(rerun::TextLogLevel::Trace)
+    ///     );
+    ///
+    ///     loguru::add_callback(
+    ///         "rerun",
+    ///         loguru_to_rerun,
+    ///         const_cast<void*>(reinterpret_cast<const void*>(&rec)),
+    ///         loguru::Verbosity_INFO
+    ///     );
+    ///
+    ///     LOG_F(INFO, "This INFO log got added through the standard logging interface");
+    ///
+    ///     loguru::remove_callback("rerun"); // we need to do this before `rec` goes out of scope
+    /// }
+    /// ```
+    struct TextLog {
+        /// The body of the message.
+        std::optional<ComponentBatch> text;
+
+        /// The verbosity level of the message.
+        ///
+        /// This can be used to filter the log messages in the Rerun Viewer.
+        std::optional<ComponentBatch> level;
+
+        /// Optional color to use for the log line in the Rerun Viewer.
+        std::optional<ComponentBatch> color;
+
+      public:
+        static constexpr const char IndicatorComponentName[] = "rerun.components.TextLogIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.archetypes.TextLog";
+
+        /// `ComponentDescriptor` for the `text` field.
+        static constexpr auto Descriptor_text = ComponentDescriptor(
+            ArchetypeName, "text", Loggable<rerun::components::Text>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `level` field.
+        static constexpr auto Descriptor_level = ComponentDescriptor(
+            ArchetypeName, "level",
+            Loggable<rerun::components::TextLogLevel>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `color` field.
+        static constexpr auto Descriptor_color = ComponentDescriptor(
+            ArchetypeName, "color", Loggable<rerun::components::Color>::Descriptor.component_name
+        );
+
+      public:
+        TextLog() = default;
+        TextLog(TextLog&& other) = default;
+        TextLog(const TextLog& other) = default;
+        TextLog& operator=(const TextLog& other) = default;
+        TextLog& operator=(TextLog&& other) = default;
+
+        explicit TextLog(rerun::components::Text _text)
+            : text(ComponentBatch::from_loggable(std::move(_text), Descriptor_text).value_or_throw()
+              ) {}
+
+        /// Update only some specific fields of a `TextLog`.
+        static TextLog update_fields() {
+            return TextLog();
+        }
+
+        /// Clear all the fields of a `TextLog`.
+        static TextLog clear_fields();
+
+        /// The body of the message.
+        TextLog with_text(const rerun::components::Text& _text) && {
+            text = ComponentBatch::from_loggable(_text, Descriptor_text).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `text` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_text` should
+        /// be used when logging a single row's worth of data.
+        TextLog with_many_text(const Collection<rerun::components::Text>& _text) && {
+            text = ComponentBatch::from_loggable(_text, Descriptor_text).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The verbosity level of the message.
+        ///
+        /// This can be used to filter the log messages in the Rerun Viewer.
+        TextLog with_level(const rerun::components::TextLogLevel& _level) && {
+            level = ComponentBatch::from_loggable(_level, Descriptor_level).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `level` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_level` should
+        /// be used when logging a single row's worth of data.
+        TextLog with_many_level(const Collection<rerun::components::TextLogLevel>& _level) && {
+            level = ComponentBatch::from_loggable(_level, Descriptor_level).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Optional color to use for the log line in the Rerun Viewer.
+        TextLog with_color(const rerun::components::Color& _color) && {
+            color = ComponentBatch::from_loggable(_color, Descriptor_color).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `color` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_color` should
+        /// be used when logging a single row's worth of data.
+        TextLog with_many_color(const Collection<rerun::components::Color>& _color) && {
+            color = ComponentBatch::from_loggable(_color, Descriptor_color).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::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.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<archetypes::TextLog> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(const archetypes::TextLog& archetype);
+    };
+} // namespace rerun