BLI_generic_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_cpp_type.hh"
#include "BLI_generic_span.hh"
 
namespace blender {
 
template<
    typename Allocator = GuardedAllocator>
class GArray {
 protected:
  const CPPType *type_ = nullptr;
  void *data_ = nullptr;
  int64_t size_ = 0;
 
  BLI_NO_UNIQUE_ADDRESS Allocator allocator_;
 
 public:
  GArray(Allocator allocator = {}) noexcept : allocator_(allocator) {}
 
  GArray(NoExceptConstructor, Allocator allocator = {}) noexcept : GArray(allocator) {}
 
  GArray(const CPPType &type, int64_t size, Allocator allocator = {}) : GArray(type, allocator)
  {
    BLI_assert(size >= 0);
    size_ = size;
    data_ = this->allocate(size_);
    type_->default_construct_n(data_, size_);
  }
 
  GArray(const CPPType &type, Allocator allocator = {}) : GArray(allocator)
  {
    type_ = &type;
  }
 
  GArray(const CPPType &type, void *buffer, int64_t size, Allocator allocator = {})
      : GArray(type, allocator)
  {
    BLI_assert(size >= 0);
    BLI_assert(buffer != nullptr || size == 0);
    BLI_assert(type_->pointer_has_valid_alignment(buffer));
 
    data_ = buffer;
    size_ = size;
  }
 
  GArray(const GSpan span, Allocator allocator = {}) : GArray(span.type(), span.size(), allocator)
  {
    /* Use copy assign rather than construct since the memory is already initialized. */
    type_->copy_assign_n(span.data(), data_, size_);
  }
 
  GArray(const GArray &other) : GArray(other.as_span(), other.allocator()) {}
 
  GArray(GArray &&other)
      : type_(other.type_), data_(other.data_), size_(other.size_), allocator_(other.allocator_)
  {
    other.data_ = nullptr;
    other.size_ = 0;
  }
 
  ~GArray()
  {
    if (data_ != nullptr) {
      type_->destruct_n(data_, size_);
      this->deallocate(data_);
    }
  }
 
  GArray &operator=(const GArray &other)
  {
    return copy_assign_container(*this, other);
  }
 
  GArray &operator=(GArray &&other)
  {
    return move_assign_container(*this, std::move(other));
  }
 
  const CPPType &type() const
  {
    BLI_assert(type_ != nullptr);
    return *type_;
  }
 
  bool is_empty() const
  {
    return size_ == 0;
  }
 
  int64_t size() const
  {
    return size_;
  }
 
  const void *data() const
  {
    return data_;
  }
  void *data()
  {
    return data_;
  }
 
  const void *operator[](int64_t index) const
  {
    BLI_assert(index < size_);
    return POINTER_OFFSET(data_, type_->size() * index);
  }
 
  void *operator[](int64_t index)
  {
    BLI_assert(index < size_);
    return POINTER_OFFSET(data_, type_->size() * index);
  }
 
  operator GSpan() const
  {
    BLI_assert(size_ == 0 || type_ != nullptr);
    return GSpan(type_, data_, size_);
  }
 
  operator GMutableSpan()
  {
    BLI_assert(size_ == 0 || type_ != nullptr);
    return GMutableSpan(type_, data_, size_);
  }
 
  GSpan as_span() const
  {
    return *this;
  }
 
  GMutableSpan as_mutable_span()
  {
    return *this;
  }
 
  Allocator &allocator()
  {
    return allocator_;
  }
  const Allocator &allocator() const
  {
    return allocator_;
  }
 
  void reinitialize(const int64_t new_size)
  {
    BLI_assert(new_size >= 0);
    int64_t old_size = size_;
 
    type_->destruct_n(data_, size_);
    size_ = 0;
 
    if (new_size <= old_size) {
      type_->default_construct_n(data_, new_size);
    }
    else {
      void *new_data = this->allocate(new_size);
      try {
        type_->default_construct_n(new_data, new_size);
      }
      catch (...) {
        this->deallocate(new_data);
        throw;
      }
      if (this->data_) {
        this->deallocate(data_);
      }
      data_ = new_data;
    }
 
    size_ = new_size;
  }
 
 private:
  void *allocate(int64_t size)
  {
    const int64_t item_size = type_->size();
    const int64_t alignment = type_->alignment();
    return allocator_.allocate(size_t(size) * item_size, alignment, AT);
  }
 
  void deallocate(void *ptr)
  {
    allocator_.deallocate(ptr);
  }
};
 
}  // namespace blender