BLI_bit_group_vector.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_bit_vector.hh"
 
namespace blender::bits {
 
template<int64_t InlineBufferCapacity = 64, typename Allocator = GuardedAllocator>
class BitGroupVector {
 private:
  int64_t group_size_ = 0;
  int64_t aligned_group_size_ = 0;
  BitVector<InlineBufferCapacity, Allocator> data_;
 
  static int64_t align_group_size(const int64_t group_size)
  {
    if (group_size < 64) {
      /* Align to next power of two so that a single group never spans across two ints. */
      return power_of_2_max(group_size);
    }
    /* Align to multiple of BitsPerInt. */
    return (group_size + BitsPerInt - 1) & ~(BitsPerInt - 1);
  }
 
 public:
  BitGroupVector(Allocator allocator = {}) noexcept : data_(allocator) {}
 
  BitGroupVector(NoExceptConstructor, Allocator allocator = {}) noexcept
      : BitGroupVector(allocator)
  {
  }
 
  BitGroupVector(const int64_t size_in_groups,
                 const int64_t group_size,
                 const bool value = false,
                 Allocator allocator = {})
      : group_size_(group_size),
        aligned_group_size_(align_group_size(group_size)),
        data_(size_in_groups * aligned_group_size_, value, allocator)
  {
    BLI_assert(group_size >= 0);
    BLI_assert(size_in_groups >= 0);
  }
 
  BitGroupVector(const BitGroupVector &other)
      : group_size_(other.group_size_),
        aligned_group_size_(other.aligned_group_size_),
        data_(other.data_)
  {
  }
 
  BitGroupVector(BitGroupVector &&other)
      : group_size_(other.group_size_),
        aligned_group_size_(other.aligned_group_size_),
        data_(std::move(other.data_))
  {
  }
 
  BitGroupVector &operator=(const BitGroupVector &other)
  {
    return copy_assign_container(*this, other);
  }
 
  BitGroupVector &operator=(BitGroupVector &&other)
  {
    return move_assign_container(*this, std::move(other));
  }
 
  BoundedBitSpan operator[](const int64_t i) const
  {
    const int64_t offset = aligned_group_size_ * i;
    return {data_.data() + (offset >> BitToIntIndexShift),
            IndexRange(offset & BitIndexMask, group_size_)};
  }
 
  MutableBoundedBitSpan operator[](const int64_t i)
  {
    const int64_t offset = aligned_group_size_ * i;
    return {data_.data() + (offset >> BitToIntIndexShift),
            IndexRange(offset & BitIndexMask, group_size_)};
  }
 
  int64_t size() const
  {
    return aligned_group_size_ == 0 ? 0 : data_.size() / aligned_group_size_;
  }
 
  bool is_empty() const
  {
    return this->size() == 0;
  }
 
  int64_t group_size() const
  {
    return group_size_;
  }
 
  IndexRange index_range() const
  {
    return IndexRange{this->size()};
  }
 
  BoundedBitSpan all_bits() const
  {
    return data_;
  }
 
  MutableBoundedBitSpan all_bits()
  {
    return data_;
  }
};
 
}  // namespace blender::bits
 
namespace blender {
using bits::BitGroupVector;
}