BLI_array.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include "BLI_allocator.hh"
#include "BLI_index_range.hh"
#include "BLI_memory_utils.hh"
#include "BLI_span.hh"
#include "BLI_utildefines.h"
 
namespace blender {
 
template<
    typename T,
    int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(T)),
    typename Allocator = GuardedAllocator>
class Array {
 public:
  using value_type = T;
  using pointer = T *;
  using const_pointer = const T *;
  using reference = T &;
  using const_reference = const T &;
  using iterator = T *;
  using const_iterator = const T *;
  using size_type = int64_t;
 
 private:
  T *data_;

  int64_t size_;

  BLI_NO_UNIQUE_ADDRESS Allocator allocator_;

  BLI_NO_UNIQUE_ADDRESS TypedBuffer<T, InlineBufferCapacity> inline_buffer_;
 
 public:
  Array(Allocator allocator = {}) noexcept : allocator_(allocator)
  {
    data_ = inline_buffer_;
    size_ = 0;
  }
 
  Array(NoExceptConstructor, Allocator allocator = {}) noexcept : Array(allocator) {}

  template<typename U, BLI_ENABLE_IF((std::is_convertible_v<U, T>))>
  Array(Span<U> values, Allocator allocator = {}) : Array(NoExceptConstructor(), allocator)
  {
    const int64_t size = values.size();
    data_ = this->get_buffer_for_size(size);
    uninitialized_convert_n<U, T>(values.data(), size, data_);
    size_ = size;
  }

  template<typename U, BLI_ENABLE_IF((std::is_convertible_v<U, T>))>
  Array(const std::initializer_list<U> &values, Allocator allocator = {})
      : Array(Span<U>(values), allocator)
  {
  }
 
  Array(const std::initializer_list<T> &values, Allocator allocator = {})
      : Array(Span<T>(values), allocator)
  {
  }

  explicit Array(int64_t size, Allocator allocator = {}) : Array(NoExceptConstructor(), allocator)
  {
    data_ = this->get_buffer_for_size(size);
    default_construct_n(data_, size);
    size_ = size;
  }

  Array(int64_t size, const T &value, Allocator allocator = {})
      : Array(NoExceptConstructor(), allocator)
  {
    BLI_assert(size >= 0);
    data_ = this->get_buffer_for_size(size);
#if defined(__GNUC__) && !defined(__clang__)
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Warray-bounds"
#endif
    uninitialized_fill_n(data_, size, value);
#if defined(__GNUC__) && !defined(__clang__)
#  pragma GCC diagnostic pop
#endif
    size_ = size;
  }

  Array(int64_t size, NoInitialization, Allocator allocator = {})
      : Array(NoExceptConstructor(), allocator)
  {
    BLI_assert(size >= 0);
    data_ = this->get_buffer_for_size(size);
    size_ = size;
  }
 
  Array(const Array &other) : Array(other.as_span(), other.allocator_) {}
 
  Array(Array &&other) noexcept(std::is_nothrow_move_constructible_v<T>)
      : Array(NoExceptConstructor(), other.allocator_)
  {
    if (other.data_ == other.inline_buffer_) {
#if defined(__GNUC__) && !defined(__clang__)
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Warray-bounds"
#endif
      uninitialized_relocate_n(other.data_, other.size_, data_);
#if defined(__GNUC__) && !defined(__clang__)
#  pragma GCC diagnostic pop
#endif
    }
    else {
      data_ = other.data_;
    }
    size_ = other.size_;
 
    other.data_ = other.inline_buffer_;
    other.size_ = 0;
  }
 
  ~Array()
  {
    destruct_n(data_, size_);
    this->deallocate_if_not_inline(data_);
  }
 
  Array &operator=(const Array &other)
  {
    return copy_assign_container(*this, other);
  }
 
  Array &operator=(Array &&other) noexcept(std::is_nothrow_move_constructible_v<T>)
  {
    return move_assign_container(*this, std::move(other));
  }
 
  T &operator[](int64_t index)
  {
    BLI_assert(index >= 0);
    BLI_assert(index < size_);
    return data_[index];
  }
 
  const T &operator[](int64_t index) const
  {
    BLI_assert(index >= 0);
    BLI_assert(index < size_);
    return data_[index];
  }
 
  operator Span<T>() const
  {
    return Span<T>(data_, size_);
  }
 
  operator MutableSpan<T>()
  {
    return MutableSpan<T>(data_, size_);
  }
 
  template<typename U, BLI_ENABLE_IF((is_span_convertible_pointer_v<T, U>))>
  operator Span<U>() const
  {
    return Span<U>(data_, size_);
  }
 
  template<typename U, BLI_ENABLE_IF((is_span_convertible_pointer_v<T, U>))>
  operator MutableSpan<U>()
  {
    return MutableSpan<U>(data_, size_);
  }
 
  Span<T> as_span() const
  {
    return *this;
  }
 
  MutableSpan<T> as_mutable_span()
  {
    return *this;
  }

  int64_t size() const
  {
    return size_;
  }

  bool is_empty() const
  {
    return size_ == 0;
  }

  void fill(const T &value) const
  {
    initialized_fill_n(data_, size_, value);
  }

  const T &first() const
  {
    BLI_assert(size_ > 0);
    return *data_;
  }
  T &first()
  {
    BLI_assert(size_ > 0);
    return *data_;
  }

  const T &last(const int64_t n = 0) const
  {
    BLI_assert(n >= 0);
    BLI_assert(n < size_);
    return *(data_ + size_ - 1 - n);
  }
  T &last(const int64_t n = 0)
  {
    BLI_assert(n >= 0);
    BLI_assert(n < size_);
    return *(data_ + size_ - 1 - n);
  }

  const T *data() const
  {
    return data_;
  }
  T *data()
  {
    return data_;
  }
 
  const T *begin() const
  {
    return data_;
  }
  const T *end() const
  {
    return data_ + size_;
  }
 
  T *begin()
  {
    return data_;
  }
  T *end()
  {
    return data_ + size_;
  }
 
  std::reverse_iterator<T *> rbegin()
  {
    return std::reverse_iterator<T *>(this->end());
  }
  std::reverse_iterator<T *> rend()
  {
    return std::reverse_iterator<T *>(this->begin());
  }
 
  std::reverse_iterator<const T *> rbegin() const
  {
    return std::reverse_iterator<T *>(this->end());
  }
  std::reverse_iterator<const T *> rend() const
  {
    return std::reverse_iterator<T *>(this->begin());
  }

  IndexRange index_range() const
  {
    return IndexRange(size_);
  }
 
  uint64_t hash() const
  {
    return this->as_span().hash();
  }
 
  static uint64_t hash_as(const Span<T> values)
  {
    return values.hash();
  }
 
  friend bool operator==(const Array &a, const Array &b)
  {
    return a.as_span() == b.as_span();
  }
 
  friend bool operator!=(const Array &a, const Array &b)
  {
    return !(a == b);
  }

  void clear_without_destruct()
  {
    size_ = 0;
  }

  Allocator &allocator()
  {
    return allocator_;
  }
  const Allocator &allocator() const
  {
    return allocator_;
  }

  static int64_t inline_buffer_capacity()
  {
    return InlineBufferCapacity;
  }

  void reinitialize(const int64_t new_size)
  {
    BLI_assert(new_size >= 0);
    int64_t old_size = size_;
 
    destruct_n(data_, size_);
    size_ = 0;
 
    if (new_size <= old_size) {
      default_construct_n(data_, new_size);
    }
    else {
      T *new_data = this->get_buffer_for_size(new_size);
      try {
        default_construct_n(new_data, new_size);
      }
      catch (...) {
        this->deallocate_if_not_inline(new_data);
        throw;
      }
      this->deallocate_if_not_inline(data_);
      data_ = new_data;
    }
 
    size_ = new_size;
  }
 
 private:
  T *get_buffer_for_size(int64_t size)
  {
    if (size <= InlineBufferCapacity) {
      return inline_buffer_;
    }
    return this->allocate(size);
  }
 
  T *allocate(int64_t size)
  {
    return static_cast<T *>(allocator_.allocate(size_t(size) * sizeof(T), alignof(T), AT));
  }
 
  void deallocate_if_not_inline(T *ptr)
  {
    if (ptr != inline_buffer_) {
      allocator_.deallocate(ptr);
    }
  }
};
 
}  // namespace blender