Refactor: Update integer type usage

This updates the usage of integer types in code I wrote according to our new style guides.

Major changes:
* Use signed instead of unsigned integers in many places.
* C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`).
* Hash values for C++ containers are 64 bit wide now (instead of 32 bit).

I do hope that I broke no builds, but it is quite likely that some compiler reports
slightly different errors. Please let me know when there are any errors. If the fix
is small, feel free to commit it yourself.
I compiled successfully on linux with gcc and on windows.

1 files changed, 45 insertions, 22 deletions

diff --git a/source/blender/blenlib/BLI_memory_utils.hh b/source/blender/blenlib/BLI_memory_utils.hh
index b73e0e95312..5c692850017 100644
--- a/source/blender/blenlib/BLI_memory_utils.hh
+++ b/source/blender/blenlib/BLI_memory_utils.hh
@@ -43,8 +43,10 @@ namespace blender {
  * After:
  *  ptr: uninitialized
  */
-template<typename T> void destruct_n(T *ptr, uint n)
+template<typename T> void destruct_n(T *ptr, int64_t n)
 {
+  BLI_assert(n >= 0);
+
   static_assert(std::is_nothrow_destructible_v<T>,
                 "This should be true for all types. Destructors are noexcept by default.");
 
@@ -54,7 +56,7 @@ template<typename T> void destruct_n(T *ptr, uint n)
     return;
   }
 
-  for (uint i = 0; i < n; i++) {
+  for (int64_t i = 0; i < n; i++) {
     ptr[i].~T();
   }
 }
@@ -70,15 +72,17 @@ template<typename T> void destruct_n(T *ptr, uint n)
  * After:
  *  ptr: initialized
  */
-template<typename T> void default_construct_n(T *ptr, uint n)
+template<typename T> void default_construct_n(T *ptr, int64_t n)
 {
+  BLI_assert(n >= 0);
+
   /* This is not strictly necessary, because the loop below will be optimized away anyway. It is
    * nice to make behavior this explicitly, though. */
   if (std::is_trivially_constructible_v<T>) {
     return;
   }
 
-  uint current = 0;
+  int64_t current = 0;
   try {
     for (; current < n; current++) {
       new ((void *)(ptr + current)) T;
@@ -102,9 +106,11 @@ template<typename T> void default_construct_n(T *ptr, uint n)
  *  src: initialized
  *  dst: initialized
  */
-template<typename T> void initialized_copy_n(const T *src, uint n, T *dst)
+template<typename T> void initialized_copy_n(const T *src, int64_t n, T *dst)
 {
-  for (uint i = 0; i < n; i++) {
+  BLI_assert(n >= 0);
+
+  for (int64_t i = 0; i < n; i++) {
     dst[i] = src[i];
   }
 }
@@ -121,9 +127,11 @@ template<typename T> void initialized_copy_n(const T *src, uint n, T *dst)
  *  src: initialized
  *  dst: initialized
  */
-template<typename T> void uninitialized_copy_n(const T *src, uint n, T *dst)
+template<typename T> void uninitialized_copy_n(const T *src, int64_t n, T *dst)
 {
-  uint current = 0;
+  BLI_assert(n >= 0);
+
+  int64_t current = 0;
   try {
     for (; current < n; current++) {
       new ((void *)(dst + current)) T(src[current]);
@@ -147,9 +155,12 @@ template<typename T> void uninitialized_copy_n(const T *src, uint n, T *dst)
  *  src: initialized
  *  dst: initialized
  */
-template<typename From, typename To> void uninitialized_convert_n(const From *src, uint n, To *dst)
+template<typename From, typename To>
+void uninitialized_convert_n(const From *src, int64_t n, To *dst)
 {
-  uint current = 0;
+  BLI_assert(n >= 0);
+
+  int64_t current = 0;
   try {
     for (; current < n; current++) {
       new ((void *)(dst + current)) To((To)src[current]);
@@ -173,9 +184,11 @@ template<typename From, typename To> void uninitialized_convert_n(const From *sr
  *  src: initialized, moved-from
  *  dst: initialized
  */
-template<typename T> void initialized_move_n(T *src, uint n, T *dst)
+template<typename T> void initialized_move_n(T *src, int64_t n, T *dst)
 {
-  for (uint i = 0; i < n; i++) {
+  BLI_assert(n >= 0);
+
+  for (int64_t i = 0; i < n; i++) {
     dst[i] = std::move(src[i]);
   }
 }
@@ -192,9 +205,11 @@ template<typename T> void initialized_move_n(T *src, uint n, T *dst)
  *  src: initialized, moved-from
  *  dst: initialized
  */
-template<typename T> void uninitialized_move_n(T *src, uint n, T *dst)
+template<typename T> void uninitialized_move_n(T *src, int64_t n, T *dst)
 {
-  uint current = 0;
+  BLI_assert(n >= 0);
+
+  int64_t current = 0;
   try {
     for (; current < n; current++) {
       new ((void *)(dst + current)) T(std::move(src[current]));
@@ -219,8 +234,10 @@ template<typename T> void uninitialized_move_n(T *src, uint n, T *dst)
  *  src: uninitialized
  *  dst: initialized
  */
-template<typename T> void initialized_relocate_n(T *src, uint n, T *dst)
+template<typename T> void initialized_relocate_n(T *src, int64_t n, T *dst)
 {
+  BLI_assert(n >= 0);
+
   initialized_move_n(src, n, dst);
   destruct_n(src, n);
 }
@@ -238,8 +255,10 @@ template<typename T> void initialized_relocate_n(T *src, uint n, T *dst)
  *  src: uninitialized
  *  dst: initialized
  */
-template<typename T> void uninitialized_relocate_n(T *src, uint n, T *dst)
+template<typename T> void uninitialized_relocate_n(T *src, int64_t n, T *dst)
 {
+  BLI_assert(n >= 0);
+
   uninitialized_move_n(src, n, dst);
   destruct_n(src, n);
 }
@@ -254,9 +273,11 @@ template<typename T> void uninitialized_relocate_n(T *src, uint n, T *dst)
  * After:
  *  dst: initialized
  */
-template<typename T> void initialized_fill_n(T *dst, uint n, const T &value)
+template<typename T> void initialized_fill_n(T *dst, int64_t n, const T &value)
 {
-  for (uint i = 0; i < n; i++) {
+  BLI_assert(n >= 0);
+
+  for (int64_t i = 0; i < n; i++) {
     dst[i] = value;
   }
 }
@@ -271,9 +292,11 @@ template<typename T> void initialized_fill_n(T *dst, uint n, const T &value)
  * After:
  *  dst: initialized
  */
-template<typename T> void uninitialized_fill_n(T *dst, uint n, const T &value)
+template<typename T> void uninitialized_fill_n(T *dst, int64_t n, const T &value)
 {
-  uint current = 0;
+  BLI_assert(n >= 0);
+
+  int64_t current = 0;
   try {
     for (; current < n; current++) {
       new ((void *)(dst + current)) T(value);
@@ -334,9 +357,9 @@ template<size_t Size, size_t Alignment> class alignas(Alignment) AlignedBuffer {
  * lifetime of the object they are embedded in. It's used by containers with small buffer
  * optimization and hash table implementations.
  */
-template<typename T, size_t Size = 1> class TypedBuffer {
+template<typename T, int64_t Size = 1> class TypedBuffer {
  private:
-  AlignedBuffer<sizeof(T) * Size, alignof(T)> buffer_;
+  AlignedBuffer<sizeof(T) * (size_t)Size, alignof(T)> buffer_;
 
  public:
   operator T *()