1 files changed, 17 insertions, 28 deletions

diff --git a/source/blender/blenlib/BLI_array.hh b/source/blender/blenlib/BLI_array.hh
index c411fc50f15..c30893f1337 100644
--- a/source/blender/blenlib/BLI_array.hh
+++ b/source/blender/blenlib/BLI_array.hh
@@ -13,6 +13,7 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
+
 #ifndef __BLI_ARRAY_HH__
 #define __BLI_ARRAY_HH__
 
@@ -56,7 +57,7 @@ template<
      * When T is large, the small buffer optimization is disabled by default to avoid large
      * unexpected allocations on the stack. It can still be enabled explicitly though.
      */
-    uint InlineBufferCapacity = (sizeof(T) < 100) ? 4 : 0,
+    int64_t InlineBufferCapacity = (sizeof(T) < 100) ? 4 : 0,
     /**
      * The allocator used by this array. Should rarely be changed, except when you don't want that
      * MEM_* functions are used internally.
@@ -68,7 +69,7 @@ class Array {
   T *data_;
 
   /** Number of elements in the array. */
-  uint size_;
+  int64_t size_;
 
   /** Used for allocations when the inline buffer is too small. */
   Allocator allocator_;
@@ -117,7 +118,7 @@ class Array {
    * even for non-trivial types. This should not be the default though, because one can easily mess
    * up when dealing with uninitialized memory.
    */
-  explicit Array(uint size)
+  explicit Array(int64_t size)
   {
     size_ = size;
     data_ = this->get_buffer_for_size(size);
@@ -128,8 +129,9 @@ class Array {
    * Create a new array with the given size. All values will be initialized by copying the given
    * default.
    */
-  Array(uint size, const T &value)
+  Array(int64_t size, const T &value)
   {
+    BLI_assert(size >= 0);
     size_ = size;
     data_ = this->get_buffer_for_size(size);
     uninitialized_fill_n(data_, size_, value);
@@ -147,8 +149,9 @@ class Array {
    * Usage:
    *  Array<std::string> my_strings(10, NoInitialization());
    */
-  Array(uint size, NoInitialization)
+  Array(int64_t size, NoInitialization)
   {
+    BLI_assert(size >= 0);
     size_ = size;
     data_ = this->get_buffer_for_size(size);
   }
@@ -203,14 +206,16 @@ class Array {
     return *this;
   }
 
-  T &operator[](uint index)
+  T &operator[](int64_t index)
   {
+    BLI_assert(index >= 0);
     BLI_assert(index < size_);
     return data_[index];
   }
 
-  const T &operator[](uint index) const
+  const T &operator[](int64_t index) const
   {
+    BLI_assert(index >= 0);
     BLI_assert(index < size_);
     return data_[index];
   }
@@ -250,7 +255,7 @@ class Array {
   /**
    * Returns the number of elements in the array.
    */
-  uint size() const
+  int64_t size() const
   {
     return size_;
   }
@@ -264,22 +269,6 @@ class Array {
   }
 
   /**
-   * Copies the value to all indices in the array.
-   */
-  void fill(const T &value)
-  {
-    initialized_fill_n(data_, size_, value);
-  }
-
-  /**
-   * Copies the value to the given indices in the array.
-   */
-  void fill_indices(Span<uint> indices, const T &value)
-  {
-    MutableSpan<T>(*this).fill_indices(indices, value);
-  }
-
-  /**
    * Get a pointer to the beginning of the array.
    */
   const T *data() const
@@ -340,13 +329,13 @@ class Array {
    * Get the value of the InlineBufferCapacity template argument. This is the number of elements
    * that can be stored without doing an allocation.
    */
-  static uint inline_buffer_capacity()
+  static int64_t inline_buffer_capacity()
   {
     return InlineBufferCapacity;
   }
 
  private:
-  T *get_buffer_for_size(uint size)
+  T *get_buffer_for_size(int64_t size)
   {
     if (size <= InlineBufferCapacity) {
       return inline_buffer_;
@@ -356,9 +345,9 @@ class Array {
     }
   }
 
-  T *allocate(uint size)
+  T *allocate(int64_t size)
   {
-    return (T *)allocator_.allocate(size * sizeof(T), alignof(T), AT);
+    return (T *)allocator_.allocate((size_t)size * sizeof(T), alignof(T), AT);
   }
 
   bool uses_inline_buffer() const