BitVector.h

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Taylor Woll and panga contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for
// full license information.
//-------------------------------------------------------------------------------------------------------
 
#ifndef BITVECTOR_H__
#define BITVECTOR_H__
 
#include <cassert>
#include <climits>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
 
namespace panga {
 
class BitVector {
 public:
  explicit BitVector(size_t bit_count = 0);
  BitVector(const BitVector& source);
  ~BitVector() = default;
 
  BitVector& operator=(const BitVector& rhs);
 
  bool Equals(const BitVector& rhs, size_t bits_to_compare) const;
 
  bool Equals(const BitVector& rhs) const;
 
  void SetBitCount(size_t bit_count);
 
  size_t GetBitCount() const;
 
  void Clip(size_t bit_count);
 
  void Clear();
 
  void Set(size_t index);
 
  void Unset(size_t index);
 
  bool Get(size_t index) const;
 
  void Flip(size_t index);
 
  template <typename IntegerType = uint64_t>
  IntegerType GetInt(size_t bit_index, size_t bit_width) const {
    assert((bit_index + bit_width) <= this->bit_count_);
    return ReadInt<IntegerType>(this->bytes_.data(), bit_index, bit_width);
  }
 
  template <typename IntegerType = uint64_t>
  void SetInt(IntegerType value, size_t bit_index, size_t bit_width) {
    assert((bit_index + bit_width) <= this->bit_count_);
    WriteInt<IntegerType>(this->bytes_.data(), bit_index, bit_width, value);
  }
 
  void SubVector(BitVector* destination, size_t destination_start_bit_offset,
                 size_t source_start_bit_offset, size_t bits_to_copy) const;
 
  size_t HammingDistance(const BitVector& rhs) const;
 
  size_t ToString(char* buffer, size_t buffer_length) const;
 
  void FromString(const char* buffer, size_t buffer_length);
 
  size_t ToStringHex(char* buffer, size_t buffer_length) const;
 
  void FromStringHex(const char* buffer, size_t buffer_length);
 
 protected:
  const std::vector<std::byte>& GetBytes() const;
 
  std::vector<std::byte>& GetBytesWritable();
 
  void Resize(size_t bit_count);
 
  template <typename IntegerType = uint64_t>
  static void WriteInt(std::byte* bytes, size_t start_bit_index,
                       size_t bits_to_copy, IntegerType value) {
    assert(bits_to_copy <= CHAR_BIT * sizeof(IntegerType));
    WriteBytes(reinterpret_cast<std::byte*>(&value), 0, bytes, start_bit_index,
               bits_to_copy);
  }
 
  template <typename IntegerType = uint64_t>
  static IntegerType ReadInt(const std::byte* bytes, size_t start_bit_index,
                             size_t bits_to_copy) {
    assert(bits_to_copy <= CHAR_BIT * sizeof(IntegerType));
    IntegerType value = 0;
    WriteBytes(bytes, start_bit_index, reinterpret_cast<std::byte*>(&value), 0,
               bits_to_copy);
    return value;
  }
 
  static void WriteBytes(const std::byte* source,
                         size_t source_start_bit_offset, std::byte* destination,
                         size_t destination_start_bit_offset,
                         size_t bits_to_copy);
 
  static bool Compare(const std::byte* left, const std::byte* right,
                      size_t bits_to_compare);
 
 public:
  struct HexFormatWrapper {
    std::ostream& _os;
  };
  struct HexFormat_t {
    friend HexFormatWrapper operator<<(std::ostream& out,
                                       const HexFormat_t& manip);
  };
 
  static HexFormat_t HexFormat;
 
  friend std::ostream& operator<<(const HexFormatWrapper& wrapper,
                                  const BitVector& bv);
  friend std::ostream& operator<<(std::ostream& out, const BitVector& bv);
 
 protected:
  void WriteToStream(std::ostream& out) const;
  void WriteToStreamHex(std::ostream& out) const;
 
 private:
  std::vector<std::byte> bytes_;
 
  size_t bit_count_ = 0;
};
 
}  // namespace panga
 
#endif  // BITVECTOR_H__