progress

it didn't always make things shorter but made things more obscure

@@ -31,0 +26,4 @@
+ * - The most-significant-bit is not used so that signed integers can be used which avoids common
+ *   issues when mixing signed and unsigned ints.
+ * - The second most-significant bit is not used for indices so that #max_segment_size itself can
+ *   be stored in the #int16_t.

@@ -73,0 +77,4 @@
+  /**
+   * Encodes the size of each segment. The size of a specific segment can be computed by
+   * subtracting consecutive elements (also see #OffsetIndices). The size of this array is one
+   * larger than #segments_num_. Note that the first elements is _not_ necessarily zero.

@@ -257,3 +294,1 @@
-   *
-   * All the indices in the sub-mask are shifted by 3 towards zero,
-   * so that the first index in the output is zero.
+   * Same as above but may generate more code at compile time because it optimizes for the case

@@ -291,0 +353,4 @@
+ * The class has to be constructed once. Afterwards, `update` has to be called to fill the mask
+ * with the provided segment.
+ */
+class IndexMaskFromSegment : NonCopyable, NonMovable {

@@ -0,0 +7,4 @@
+namespace blender {
+
+/**
+ * An #OffsetSpan where a constant offset is added to every value when accessed. This allows e.g.

@@ -0,0 +66,4 @@
+ *   [3, 4, 5, 6, 8, 9, 10]
+ *                ^ Range ends here because 6 and 8 are not consecutive.
+ */
+template<typename T> inline int64_t find_size_of_next_range(const Span<T> indices)

@@ -5,0 +28,4 @@
+const IndexMask &get_static_index_mask_for_min_size(const int64_t min_size)
+{
+  static constexpr int64_t size_shift = 30;
+  static constexpr int64_t max_size = (1 << size_shift);

@@ -44,3 +149,1 @@
-  }
-  if (indices_.is_empty()) {
-    return full_range;
+  /* TODO: Implement more efficient solution. */

@@ -54,0 +168,4 @@
+  int64_t group_start_segment_i = 0;
+  int64_t group_first = segments[0][0];
+  int64_t group_last = segments[0].last();
+  bool group_as_range = unique_sorted_indices::non_empty_is_range(segments[0].base_span());

@@ -90,0 +257,4 @@
+                                  LinearAllocator<> &allocator,
+                                  Vector<IndexMaskSegment> &r_segments)
+{
+  Vector<std::variant<IndexRange, Span<T>>> segments;

@@ -90,0 +277,4 @@
+          segment_indices.size());
+      while (!segment_indices.is_empty()) {
+        const int64_t offset = segment_indices[0];
+        const int64_t next_segment_size = binary_search::find_predicate_begin(

@@ -135,2 +130,2 @@
-          return curves_to_delete[curve_i];
-        });
+    IndexMaskMemory mask_memory;
+    const IndexMask &mask_to_delete = IndexMask::from_bools(curves_to_delete, mask_memory);

@@ -165,2 +164,4 @@
       }
     }
+    IndexMaskMemory memory;
+    const IndexMask changed_curves_mask = IndexMask::from_indices<int64_t>(changed_curves_indices,

@@ -323,3 +321,3 @@
         MutableSpan<T> dst = attributes.dst[i_attribute].typed<T>();
 
-        for (const int i_curve : sliced_selection) {
+        for (const int i_curve : selection_segment) {

@@ -527,1 +514,3 @@
-      for (const int i : selection.slice(range)) {
+    selection.foreach_segment(GrainSize(512), [&](const IndexMaskSegment segment) {
+      for (const int i : segment) {
+        nurbs_order[i] = 4;

@@ -1068,3 +1051,3 @@
     /* Only trimmed curves are no longer cyclic. */
     if (bke::SpanAttributeWriter cyclic = dst_attributes.lookup_for_write_span<bool>("cyclic")) {
-      cyclic.span.fill_indices(selection.indices(), false);
+      selection.foreach_index(GrainSize(4096), [&](const int64_t i) { cyclic.span[i] = false; });

@@ -415,2 +408,4 @@
+        });
       });
 
+      IndexMaskMemory memory;