BLI_bit_ref.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_utildefines.h"
 
#include <iosfwd>
 
namespace blender::bits {
 
using BitInt = uint64_t;
static constexpr int64_t BitsPerInt = int64_t(sizeof(BitInt) * 8);
static constexpr int64_t BitToIntIndexShift = 3 + (sizeof(BitInt) >= 2) + (sizeof(BitInt) >= 4) +
                                              (sizeof(BitInt) >= 8);
static constexpr BitInt BitIndexMask = (BitInt(1) << BitToIntIndexShift) - 1;
 
inline BitInt mask_first_n_bits(const int64_t n)
{
  BLI_assert(n >= 0);
  BLI_assert(n <= BitsPerInt);
  if (n == BitsPerInt) {
    return BitInt(-1);
  }
  return (BitInt(1) << n) - 1;
}
 
inline BitInt mask_last_n_bits(const int64_t n)
{
  return ~mask_first_n_bits(BitsPerInt - n);
}
 
inline BitInt mask_range_bits(const int64_t start, const int64_t size)
{
  BLI_assert(start >= 0);
  BLI_assert(size >= 0);
  const int64_t end = start + size;
  BLI_assert(end <= BitsPerInt);
  if (end == BitsPerInt) {
    return mask_last_n_bits(size);
  }
  return ((BitInt(1) << end) - 1) & ~((BitInt(1) << start) - 1);
}
 
inline BitInt mask_single_bit(const int64_t bit_index)
{
  BLI_assert(bit_index >= 0);
  BLI_assert(bit_index < BitsPerInt);
  return BitInt(1) << bit_index;
}
 
inline BitInt *int_containing_bit(BitInt *data, const int64_t bit_index)
{
  return data + (bit_index >> BitToIntIndexShift);
}
 
inline const BitInt *int_containing_bit(const BitInt *data, const int64_t bit_index)
{
  return data + (bit_index >> BitToIntIndexShift);
}
 
class BitRef {
 private:
  const BitInt *int_;
  BitInt mask_;
 
  friend class MutableBitRef;
 
 public:
  BitRef() = default;
 
  BitRef(const BitInt *data, const int64_t bit_index)
  {
    int_ = int_containing_bit(data, bit_index);
    mask_ = mask_single_bit(bit_index & BitIndexMask);
  }
 
  bool test() const
  {
    const BitInt value = *int_;
    const BitInt masked_value = value & mask_;
    return masked_value != 0;
  }
 
  operator bool() const
  {
    return this->test();
  }
};
 
class MutableBitRef {
 private:
  BitInt *int_;
  BitInt mask_;
 
 public:
  MutableBitRef() = default;
 
  MutableBitRef(BitInt *data, const int64_t bit_index)
  {
    int_ = int_containing_bit(data, bit_index);
    mask_ = mask_single_bit(bit_index & BitIndexMask);
  }
 
  operator BitRef() const
  {
    BitRef bit_ref;
    bit_ref.int_ = int_;
    bit_ref.mask_ = mask_;
    return bit_ref;
  }
 
  bool test() const
  {
    const BitInt value = *int_;
    const BitInt masked_value = value & mask_;
    return masked_value != 0;
  }
 
  operator bool() const
  {
    return this->test();
  }
 
  void set()
  {
    *int_ |= mask_;
  }
 
  void reset()
  {
    *int_ &= ~mask_;
  }
 
  void set(const bool value)
  {
    if (value) {
      this->set();
    }
    else {
      this->reset();
    }
  }
 
  void set_branchless(const bool value)
  {
    const BitInt value_int = BitInt(value);
    BLI_assert(ELEM(value_int, 0, 1));
    const BitInt old = *int_;
    *int_ =
        /* Unset bit. */
        (~mask_ & old)
        /* Optionally set it again. The -1 turns a 1 into `0x00...` and a 0 into `0xff...`. */
        | (mask_ & ~(value_int - 1));
  }
 
  MutableBitRef &operator|=(const bool value)
  {
    if (value) {
      this->set();
    }
    return *this;
  }
 
  MutableBitRef &operator&=(const bool value)
  {
    if (!value) {
      this->reset();
    }
    return *this;
  }
};
 
std::ostream &operator<<(std::ostream &stream, const BitRef &bit);
std::ostream &operator<<(std::ostream &stream, const MutableBitRef &bit);
 
}  // namespace blender::bits
 
namespace blender {
using bits::BitRef;
using bits::MutableBitRef;
}  // namespace blender