Functions: Various improvements to the spans and generic data structures

Most of this code is covered by unit tests.

3 files changed, 146 insertions, 0 deletions

diff --git a/tests/gtests/functions/FN_array_spans_test.cc b/tests/gtests/functions/FN_array_spans_test.cc
index 47e1c129266..21e52a90e4b 100644
--- a/tests/gtests/functions/FN_array_spans_test.cc
+++ b/tests/gtests/functions/FN_array_spans_test.cc
@@ -18,6 +18,9 @@
 
 #include "FN_array_spans.hh"
 #include "FN_cpp_types.hh"
+#include "FN_generic_vector_array.hh"
+
+#include "BLI_array.hh"
 
 namespace blender {
 namespace fn {
@@ -27,6 +30,10 @@ TEST(virtual_array_span, EmptyConstructor)
   VArraySpan<int> span;
   EXPECT_EQ(span.size(), 0);
   EXPECT_TRUE(span.is_empty());
+
+  GVArraySpan converted(span);
+  EXPECT_EQ(converted.type(), CPPType::get<int>());
+  EXPECT_EQ(converted.size(), 0);
 }
 
 TEST(virtual_array_span, SingleArrayConstructor)
@@ -44,6 +51,13 @@ TEST(virtual_array_span, SingleArrayConstructor)
   EXPECT_EQ(span[0][3], 6);
   EXPECT_EQ(span[1][3], 6);
   EXPECT_EQ(span[2][1], 4);
+
+  GVArraySpan converted(span);
+  EXPECT_EQ(converted.type(), CPPType::get<int>());
+  EXPECT_EQ(converted.size(), 3);
+  EXPECT_EQ(converted[0].size(), 4);
+  EXPECT_EQ(converted[1].size(), 4);
+  EXPECT_EQ(converted[1][2], &values[2]);
 }
 
 TEST(virtual_array_span, MultipleArrayConstructor)
@@ -65,6 +79,15 @@ TEST(virtual_array_span, MultipleArrayConstructor)
   EXPECT_EQ(&span[2][0], values2.data());
   EXPECT_EQ(span[2][0], 8);
   EXPECT_EQ(span[1][1], 7);
+
+  GVArraySpan converted(span);
+  EXPECT_EQ(converted.type(), CPPType::get<int>());
+  EXPECT_EQ(converted.size(), 3);
+  EXPECT_EQ(converted[0].size(), 4);
+  EXPECT_EQ(converted[1].size(), 2);
+  EXPECT_EQ(converted[2].size(), 1);
+  EXPECT_EQ(converted[0][0], values0.data());
+  EXPECT_EQ(converted[1][1], values1.data() + 1);
 }
 
 TEST(generic_virtual_array_span, TypeConstructor)
@@ -72,6 +95,9 @@ TEST(generic_virtual_array_span, TypeConstructor)
   GVArraySpan span{CPPType_int32};
   EXPECT_EQ(span.size(), 0);
   EXPECT_TRUE(span.is_empty());
+
+  VArraySpan converted = span.typed<int>();
+  EXPECT_EQ(converted.size(), 0);
 }
 
 TEST(generic_virtual_array_span, GSpanConstructor)
@@ -86,6 +112,37 @@ TEST(generic_virtual_array_span, GSpanConstructor)
   EXPECT_EQ(span[0].size(), 3);
   EXPECT_EQ(span[2].size(), 3);
   EXPECT_EQ(*(std::string *)span[3][1], "world");
+
+  VArraySpan converted = span.typed<std::string>();
+  EXPECT_EQ(converted.size(), 5);
+  EXPECT_EQ(converted[0][0], "hello");
+  EXPECT_EQ(converted[1][0], "hello");
+  EXPECT_EQ(converted[4][0], "hello");
+  EXPECT_EQ(converted[0].size(), 3);
+  EXPECT_EQ(converted[2].size(), 3);
+}
+
+TEST(generic_virtual_array_span, IsSingleArray1)
+{
+  Array<int> values = {5, 6, 7};
+  GVArraySpan span{GSpan(values.as_span()), 4};
+  EXPECT_TRUE(span.is_single_array());
+
+  VArraySpan converted = span.typed<int>();
+  EXPECT_TRUE(converted.is_single_array());
+}
+
+TEST(generic_virtual_array_span, IsSingleArray2)
+{
+  GVectorArray vectors{CPPType_int32, 3};
+  GVectorArrayRef<int> vectors_ref = vectors;
+  vectors_ref.append(1, 4);
+
+  GVArraySpan span = vectors;
+  EXPECT_FALSE(span.is_single_array());
+
+  VArraySpan converted = span.typed<int>();
+  EXPECT_FALSE(converted.is_single_array());
 }
 
 }  // namespace fn
diff --git a/tests/gtests/functions/FN_generic_vector_array_test.cc b/tests/gtests/functions/FN_generic_vector_array_test.cc
index 5840feb955d..c701fb9f678 100644
--- a/tests/gtests/functions/FN_generic_vector_array_test.cc
+++ b/tests/gtests/functions/FN_generic_vector_array_test.cc
@@ -97,5 +97,22 @@ TEST(generic_vector_array, TypedRef)
   EXPECT_EQ(ref[3][1], 6);
 }
 
+TEST(generic_vector_array, Extend)
+{
+  GVectorArray vectors{CPPType_int32, 3};
+  GVectorArrayRef<int> ref = vectors;
+
+  ref.extend(1, {5, 6, 7});
+  ref.extend(0, {3});
+
+  EXPECT_EQ(vectors[0].size(), 1);
+  EXPECT_EQ(vectors[1].size(), 3);
+  EXPECT_EQ(vectors[2].size(), 0);
+  EXPECT_EQ(ref[1][0], 5);
+  EXPECT_EQ(ref[1][1], 6);
+  EXPECT_EQ(ref[1][2], 7);
+  EXPECT_EQ(ref[0][0], 3);
+}
+
 }  // namespace fn
 }  // namespace blender
diff --git a/tests/gtests/functions/FN_spans_test.cc b/tests/gtests/functions/FN_spans_test.cc
index 551918a3aae..59797f69309 100644
--- a/tests/gtests/functions/FN_spans_test.cc
+++ b/tests/gtests/functions/FN_spans_test.cc
@@ -71,6 +71,11 @@ TEST(virtual_span, EmptyConstructor)
   VSpan<int> span;
   EXPECT_EQ(span.size(), 0);
   EXPECT_TRUE(span.is_empty());
+  EXPECT_FALSE(span.is_single_element());
+
+  GVSpan converted(span);
+  EXPECT_EQ(converted.type(), CPPType::get<int>());
+  EXPECT_EQ(converted.size(), 0);
 }
 
 TEST(virtual_span, SpanConstructor)
@@ -83,6 +88,11 @@ TEST(virtual_span, SpanConstructor)
   EXPECT_EQ(virtual_span[0], 7);
   EXPECT_EQ(virtual_span[2], 8);
   EXPECT_EQ(virtual_span[3], 6);
+  EXPECT_FALSE(virtual_span.is_single_element());
+
+  GVSpan converted(span);
+  EXPECT_EQ(converted.type(), CPPType::get<int>());
+  EXPECT_EQ(converted.size(), 5);
 }
 
 TEST(virtual_span, PointerSpanConstructor)
@@ -98,6 +108,14 @@ TEST(virtual_span, PointerSpanConstructor)
   EXPECT_EQ(span[1], 7);
   EXPECT_EQ(span[2], 6);
   EXPECT_EQ(&span[1], &x2);
+  EXPECT_FALSE(span.is_single_element());
+
+  GVSpan converted(span);
+  EXPECT_EQ(converted.type(), CPPType::get<int>());
+  EXPECT_EQ(converted.size(), 3);
+  EXPECT_EQ(converted[0], &x0);
+  EXPECT_EQ(converted[1], &x2);
+  EXPECT_EQ(converted[2], &x1);
 }
 
 TEST(virtual_span, SingleConstructor)
@@ -112,6 +130,14 @@ TEST(virtual_span, SingleConstructor)
   EXPECT_EQ(&span[0], &value);
   EXPECT_EQ(&span[1], &value);
   EXPECT_EQ(&span[2], &value);
+  EXPECT_TRUE(span.is_single_element());
+
+  GVSpan converted(span);
+  EXPECT_EQ(converted.type(), CPPType::get<int>());
+  EXPECT_EQ(converted.size(), 3);
+  EXPECT_EQ(converted[0], &value);
+  EXPECT_EQ(converted[1], &value);
+  EXPECT_EQ(converted[2], &value);
 }
 
 TEST(generic_virtual_span, TypeConstructor)
@@ -119,6 +145,10 @@ TEST(generic_virtual_span, TypeConstructor)
   GVSpan span(CPPType_int32);
   EXPECT_EQ(span.size(), 0);
   EXPECT_TRUE(span.is_empty());
+  EXPECT_FALSE(span.is_single_element());
+
+  VSpan<int> converted = span.typed<int>();
+  EXPECT_EQ(converted.size(), 0);
 }
 
 TEST(generic_virtual_span, GenericSpanConstructor)
@@ -131,6 +161,21 @@ TEST(generic_virtual_span, GenericSpanConstructor)
   EXPECT_EQ(span[1], &values[1]);
   EXPECT_EQ(span[2], &values[2]);
   EXPECT_EQ(span[3], &values[3]);
+  EXPECT_FALSE(span.is_single_element());
+
+  int materialized[4] = {0};
+  span.materialize_to_uninitialized(materialized);
+  EXPECT_EQ(materialized[0], 3);
+  EXPECT_EQ(materialized[1], 4);
+  EXPECT_EQ(materialized[2], 5);
+  EXPECT_EQ(materialized[3], 6);
+
+  VSpan<int> converted = span.typed<int>();
+  EXPECT_EQ(converted.size(), 4);
+  EXPECT_EQ(converted[0], 3);
+  EXPECT_EQ(converted[1], 4);
+  EXPECT_EQ(converted[2], 5);
+  EXPECT_EQ(converted[3], 6);
 }
 
 TEST(generic_virtual_span, SpanConstructor)
@@ -142,6 +187,19 @@ TEST(generic_virtual_span, SpanConstructor)
   EXPECT_EQ(span[0], &values[0]);
   EXPECT_EQ(span[1], &values[1]);
   EXPECT_EQ(span[2], &values[2]);
+  EXPECT_FALSE(span.is_single_element());
+
+  int materialized[3] = {0};
+  span.materialize_to_uninitialized(materialized);
+  EXPECT_EQ(materialized[0], 6);
+  EXPECT_EQ(materialized[1], 7);
+  EXPECT_EQ(materialized[2], 8);
+
+  VSpan<int> converted = span.typed<int>();
+  EXPECT_EQ(converted.size(), 3);
+  EXPECT_EQ(converted[0], 6);
+  EXPECT_EQ(converted[1], 7);
+  EXPECT_EQ(converted[2], 8);
 }
 
 TEST(generic_virtual_span, SingleConstructor)
@@ -153,6 +211,20 @@ TEST(generic_virtual_span, SingleConstructor)
   EXPECT_EQ(span[0], &value);
   EXPECT_EQ(span[1], &value);
   EXPECT_EQ(span[2], &value);
+  EXPECT_TRUE(span.is_single_element());
+  EXPECT_EQ(span.as_single_element(), &value);
+
+  int materialized[3] = {0};
+  span.materialize_to_uninitialized({1, 2}, materialized);
+  EXPECT_EQ(materialized[0], 0);
+  EXPECT_EQ(materialized[1], 5);
+  EXPECT_EQ(materialized[2], 5);
+
+  VSpan<int> converted = span.typed<int>();
+  EXPECT_EQ(converted.size(), 3);
+  EXPECT_EQ(converted[0], 5);
+  EXPECT_EQ(converted[1], 5);
+  EXPECT_EQ(converted[2], 5);
 }
 
 }  // namespace fn