dynamic_bitset.hpp

Go to the documentation of this file.

 
 
#ifndef DYNAMIC_BITSET_H_
#define DYNAMIC_BITSET_H_
#include <algorithm>
#include <cmath>
#include <cstring>
#include <initializer_list>
#include <ostream>
#include <vector>
 
template <std::size_t N = 0> class dynamic_bitset {
public:
  dynamic_bitset() : bits_(N) {}
 
  dynamic_bitset(int value) : bits_(N) {
    auto binary = int_to_binary(value);
    int number_of_padding = bits_.size() - binary.size();
    add_padding(binary, number_of_padding);
    bits_ = std::move(binary);
  }
 
  dynamic_bitset(std::vector<bool> binaries) : bits_(N) {
    int number_of_padding = bits_.size() - binaries.size();
    add_padding(binaries, number_of_padding);
    bits_ = std::move(binaries);
  }
 
  dynamic_bitset(std::initializer_list<bool> binaries) : bits_(N) {
    int number_of_padding = bits_.size() - binaries.size();
    bits_ = std::move(binaries);
    add_padding(bits_, number_of_padding);
  }
 
  dynamic_bitset(const std::string &binary_string) : bits_(N) {
    bits_ = std::move(string_to_bitset(binary_string));
  }
 
  dynamic_bitset(const char *binary) : bits_(N) {
    int number_of_padding = bits_.size() - strlen(binary);
    std::vector<bool> binaries;
 
    while (*binary != '\0')
      binaries.emplace_back(*binary++ == '1');
 
    add_padding(binaries, number_of_padding);
    bits_ = std::move(binaries);
  }
 
  ~dynamic_bitset() {}
 
  dynamic_bitset(const dynamic_bitset &) = delete;
 
  dynamic_bitset &operator=(const dynamic_bitset &) = delete;
 
  dynamic_bitset(dynamic_bitset &&other) : bits_(std::move(other.bits_)) {}
 
  dynamic_bitset &operator=(dynamic_bitset &&other) {
    if (this != &other) {
      bits_ = std::move(other.bits_);
    }
    return *this;
  }
 
  dynamic_bitset &operator=(const std::vector<bool> &binaries) {
    int number_of_padding = bits_.size() - binaries.size();
    bits_ = std::move(binaries);
    add_padding(bits_, number_of_padding);
    return *this;
  }
 
  dynamic_bitset &reverse() {
    std::reverse(std::begin(bits_), std::end(bits_));
    return *this;
  }
 
  const std::vector<bool> &get() const { return bits_; }
 
  bool operator[](std::size_t index) const { return bits_.at(index); }
 
  bool all() const {
    return std::all_of(std::begin(bits_), std::end(bits_),
                       [](bool b) { return b; });
  }
 
  bool any() const {
    return std::any_of(std::begin(bits_), std::end(bits_),
                       [](bool b) { return b; });
  }
 
  bool none() const {
    return std::none_of(std::begin(bits_), std::end(bits_),
                        [](bool b) { return b; });
  }
 
  inline std::vector<bool>::reference operator[](std::size_t index) {
    return bits_.at(index);
  }
 
  constexpr std::size_t size() const { return bits_.size(); }
 
  dynamic_bitset &set(bool value) {
    std::fill(std::begin(bits_), std::end(bits_), value);
    return *this;
  }
 
  inline dynamic_bitset &reset() { return set(false); }
 
  std::string to_string() const {
    std::string str;
    for (const auto &bit : bits_)
      str.push_back(bit == true ? '1' : '0');
 
    return str;
  }
 
  operator std::string() const { return to_string(); }
 
  std::size_t to_ulong() const {
    std::size_t value = 0;
    std::size_t power = 1;
    for (auto it = bits_.rbegin(); it != bits_.rend(); ++it) {
      if (*it)
        value += power;
      power *= 2;
    }
    return value;
  }
 
  operator std::size_t() const { return to_ulong(); }
 
  operator unsigned long const() {
    return static_cast<unsigned long>(to_ulong());
  }
 
  operator unsigned long long const() {
    return static_cast<unsigned long>(to_ulong());
  }
 
  dynamic_bitset operator&(const dynamic_bitset &other) const {
    std::size_t size = std::min(bits_.size(), other.size());
    std::vector<bool> set;
    for (int i = 0; i < size; ++i)
      set.emplace_back(other[i] && bits_[i]);
    return dynamic_bitset(set);
  }
 
  dynamic_bitset &operator&=(const dynamic_bitset &other) {
    std::size_t size = std::min(bits_.size(), other.size());
    for (int i = 0; i < size; ++i)
      bits_[i] = bits_[i] && other.bits_[i];
    return *this;
  }
 
  dynamic_bitset operator|(const dynamic_bitset &other) const {
    std::size_t size = std::min(bits_.size(), other.size());
    std::vector<bool> set;
    for (int i = 0; i < size; ++i)
      set.emplace_back(other[i] || bits_[i]);
    return dynamic_bitset(set);
  }
 
  dynamic_bitset &operator|=(const dynamic_bitset &other) {
    std::size_t size = std::min(bits_.size(), other.size());
    std::vector<bool> set;
    for (int i = 0; i < size; ++i)
      bits_[i] = bits_[i] || other.bits_[i];
    return *this;
  }
 
  dynamic_bitset operator^(const dynamic_bitset &other) const {
    std::size_t size = std::min(bits_.size(), other.size());
    std::vector<bool> set;
    for (int i = 0; i < size; ++i)
      set.emplace_back(other[i] ^ bits_[i]);
    return dynamic_bitset(set);
  }
 
  dynamic_bitset &operator^=(const dynamic_bitset &other) {
    std::size_t size = std::min(bits_.size(), other.size());
    std::vector<bool> set;
    for (int i = 0; i < size; ++i)
      bits_[i] = bits_[i] ^ other.bits_[i];
    return *this;
  }
 
  dynamic_bitset &operator<<=(std::size_t shift_amount) {
    if (shift_amount >= bits_.size())
      bits_.assign(bits_.size(), false);
    else {
      // shift all bits to left
      for (std::size_t i = 0; i < bits_.size(); ++i)
        bits_[i] = bits_[i + shift_amount];
      // fill shifted position
      for (std::size_t i = bits_.size() - shift_amount; i < bits_.size(); ++i)
        bits_[i] = false;
    }
    return *this;
  }
 
  dynamic_bitset &operator>>=(std::size_t shift_amount) {
    if (shift_amount >= bits_.size())
      bits_.assign(bits_.size(), false);
    else {
      // shift all bits to  right
      for (std::size_t i = bits_.size() - 1; i >= shift_amount; --i)
        bits_[i] = bits_[i - shift_amount];
      // fill shifted position
      for (std::size_t i = 0; i < shift_amount; ++i)
        bits_[i] = false;
    }
    return *this;
  }
 
  std::vector<bool>::iterator begin() { return bits_.begin(); }
 
  std::vector<bool>::iterator end() { return bits_.end(); }
 
  friend std::ostream &operator<<(std::ostream &out,
                                  const dynamic_bitset &set) {
    for (const auto &bit : set.bits_) {
      out << bit;
    }
    return out;
  }
 
  friend std::istream &operator>>(std::istream &input, dynamic_bitset &set) {
    std::string str;
    input >> str;
    set.bits_ = std::move(set.string_to_bitset(str));
    return input;
  }
 
private:
  std::vector<bool> string_to_bitset(const std::string &binary_string) {
    int number_of_padding = bits_.size() - binary_string.size();
    std::vector<bool> binaries;
    for (const char &c : binary_string)
      binaries.emplace_back(c == '1');
    add_padding(binaries, number_of_padding);
    return binaries;
  }
 
  void add_padding(std::vector<bool> &base, int number_of_padding) {
    for (int i = 0; i < number_of_padding; ++i)
      base.insert(base.begin(), 0);
  }
 
  std::vector<bool> int_to_binary(int value) {
    std::vector<bool> temp;
    while (value > 0) {
      temp.insert(temp.begin(), static_cast<bool>(value % 2));
      value /= 2;
    }
    if (temp.empty())
      temp.emplace_back(value);
    return temp;
  }
 
  std::vector<bool> bits_;
};
 
#endif