Use rerun::Collection almost everywhere we'd use std::vector before

crates/re_types_builder/src/codegen/cpp/mod.rs

@@ -1343,41 +1343,60 @@ fn component_to_data_cell_method(type_ident: &Ident, hpp_includes: &mut Includes
 fn archetype_serialize(type_ident: &Ident, obj: &Object, hpp_includes: &mut Includes) -> Method {
     hpp_includes.insert_rerun("data_cell.hpp");
     hpp_includes.insert_rerun("collection.hpp");
+    hpp_includes.insert_rerun("serialized_component_batch.hpp");
     hpp_includes.insert_system("vector"); // std::vector
 
     let num_fields = quote_integer(obj.fields.len());
     let push_batches = obj.fields.iter().map(|field| {
         let field_name = format_ident!("{}", field.name);
         let field_accessor = quote!(archetype.#field_name);
+        let field_type = quote_fqname_as_type_path(
+            hpp_includes,
+            field
+                .typ
+                .fqname()
+                .expect("Archetypes only have components and vectors of components."),
+        );
 
-        // TODO(andreas): Introducing MonoCollection will remove the need for this.
-        let wrapping_type = if field.typ.is_plural() {
-            quote!()
-        } else {
-            let field_type = quote_fqname_as_type_path(
-                hpp_includes,
-                field
-                    .typ
-                    .fqname()
-                    .expect("Archetypes only have components and vectors of components."),
-            );
-            quote!(Collection<#field_type>)
+        let emplace_back = quote! {
+            RR_RETURN_NOT_OK(result.error);
+            cells.emplace_back(std::move(result.value), size);
         };
 
-        if field.is_nullable {
+
+        // TODO(andreas): Introducing MonoCollection will remove the need for distinguishing these two cases.
+        if field.typ.is_plural() {
+            if field.is_nullable {
+                quote! {
+                    if (#field_accessor.has_value()) {
+                        const size_t size = #field_accessor.value().size();
+                        auto result = #field_type::to_data_cell(#field_accessor.value().data(), size);
+                        #emplace_back
+                    }
+                }
+            } else {
+                quote! {
+                    {
+                        const size_t size = #field_accessor.size();
+                        auto result = #field_type::to_data_cell(#field_accessor.data(), #field_accessor.size());
+                        #emplace_back
+                    }
+                }
+            }
+        } else if field.is_nullable {
             quote! {
                 if (#field_accessor.has_value()) {
-                    auto result = #wrapping_type(#field_accessor.value()).serialize();
-                    RR_RETURN_NOT_OK(result.error);
-                    cells.emplace_back(std::move(result.value));
+                    const size_t size = 1;
+                    auto result = #field_type::to_data_cell(&#field_accessor.value(), size);
+                    #emplace_back
                 }
             }
         } else {
             quote! {
                 {
-                    auto result = #wrapping_type(#field_accessor).serialize();
-                    RR_RETURN_NOT_OK(result.error);
-                    cells.emplace_back(std::move(result.value));
+                    const size_t size = 1;
+                    auto result = #field_type::to_data_cell(&#field_accessor, size);
+                    #emplace_back
                 }
             }
         }
@@ -1399,9 +1418,10 @@ fn archetype_serialize(type_ident: &Ident, obj: &Object, hpp_includes: &mut Incl
             #NEWLINE_TOKEN
             #(#push_batches)*
             {
-                auto result = Collection<#type_ident::IndicatorComponent>(#type_ident::IndicatorComponent()).serialize();
+                auto indicator = #type_ident::IndicatorComponent();
+                auto result = #type_ident::IndicatorComponent::to_data_cell(&indicator, 1);
                 RR_RETURN_NOT_OK(result.error);
-                cells.emplace_back(std::move(result.value));
+                cells.emplace_back(std::move(result.value), 1);
             }
             #NEWLINE_TOKEN
             #NEWLINE_TOKEN
@@ -1983,8 +2003,8 @@ fn quote_field_type(includes: &mut Includes, obj_field: &ObjectField) -> TokenSt
         }
         Type::Vector { elem_type } => {
             let elem_type = quote_element_type(includes, elem_type);
-            includes.insert_system("vector");
-            quote! { std::vector<#elem_type>  }
+            includes.insert_rerun("collection.hpp");
+            quote! { rerun::Collection<#elem_type>  }
         }
         Type::Object(fqname) => {
             let type_name = quote_fqname_as_type_path(includes, fqname);

docs/code-examples/line_strip2d_batch.cpp

@@ -8,8 +8,8 @@ int main() {
     const auto rec = rerun::RecordingStream("rerun_example_line_strip2d");
     rec.spawn().exit_on_failure();
 
-    std::vector<rerun::Vec2D> strip1 = {{0.f, 0.f}, {2.f, 1.f}, {4.f, -1.f}, {6.f, 0.f}};
-    std::vector<rerun::Vec2D> strip2 =
+    rerun::Collection<rerun::Vec2D> strip1 = {{0.f, 0.f}, {2.f, 1.f}, {4.f, -1.f}, {6.f, 0.f}};
+    rerun::Collection<rerun::Vec2D> strip2 =
         {{0.f, 3.f}, {1.f, 4.f}, {2.f, 2.f}, {3.f, 4.f}, {4.f, 2.f}, {5.f, 4.f}, {6.f, 3.f}};
     rec.log(
         "strips",

docs/code-examples/line_strip3d_batch.cpp

@@ -8,13 +8,13 @@ int main() {
     const auto rec = rerun::RecordingStream("rerun_example_line_strip3d");
     rec.spawn().exit_on_failure();
 
-    std::vector<rerun::Vec3D> strip1 = {
+    rerun::Collection<rerun::Vec3D> strip1 = {
         {0.f, 0.f, 2.f},
         {1.f, 0.f, 2.f},
         {1.f, 1.f, 2.f},
         {0.f, 1.f, 2.f},
     };
-    std::vector<rerun::Vec3D> strip2 = {
+    rerun::Collection<rerun::Vec3D> strip2 = {
         {0.f, 0.f, 0.f},
         {0.f, 0.f, 1.f},
         {1.f, 0.f, 0.f},

rerun_cpp/docs/writing_docs.md

@@ -34,3 +34,5 @@ We stick to the following styles:
     /// \endcond
     ```
 * Avoid the use of groups when namespaces can be used instead
+* Don't omit namespaces when referring to types in docs - instead of `Collection` use `rerun::Collection`.
+  Both works usually but the latter makes it easier to understand what is meant.