bit_array.hpp

Go to the documentation of this file.

#pragma once
 
#include "generic/list.hpp"
#include "../iclonable.hpp"
#include "../iequatable.hpp"
#include "../array.hpp"
#include "../boolean.hpp"
#include "../byte.hpp"
#include "../int32.hpp"
#include "../math.hpp"
#include "../npos.hpp"
#include "../object.hpp"
#include "../size.hpp"
#include "../types.hpp"
#include <bitset>
#include <initializer_list>
#include <limits>

namespace xtd {
  namespace collections {
    class core_export_ bit_array : public xtd::object, public xtd::iequatable<bit_array>, public xtd::collections::generic::icollection<bool>, public xtd::iclonable {
    private:
      struct boolean_ref {
        boolean_ref() noexcept = default;
        bool& get_boolean_ref(bool value, xtd::size index) noexcept;
        const bool& get_boolean_ref(bool value, xtd::size index) const noexcept;
        void from_boolean(bit_array& parent) noexcept;
        
        inline static constexpr xtd::size npos = xtd::npos;
        inline static constexpr xtd::size bpos = xtd::bpos;
        inline static constexpr xtd::size epos = xtd::epos;
        mutable xtd::size index = npos;
        mutable bool value = false;
      };
      
    public:
      
      using value_type = bool;
      using base_type =  typename xtd::collections::generic::list<int32>;
      using size_type = xtd::size;
      using difference_type = xtd::ptrdiff;
      using reference = value_type&;
      using const_reference = const value_type&;
      using pointer = value_type*;
      using const_pointer = const value_type*;
      using iterator = typename xtd::collections::generic::ienumerable<bool>::iterator;
      using const_iterator = typename xtd::collections::generic::ienumerable<bool>::const_iterator;
      
      
      explicit bit_array(xtd::size length) noexcept;
      
      bit_array(xtd::size length, bool defaultValue) noexcept;
      
      bit_array(std::initializer_list<bool> il) noexcept;
      
      bit_array(const xtd::array<bool>& values) noexcept;
      
      bit_array(const xtd::array<xtd::byte>& values) noexcept;
      
      bit_array(const xtd::array<int32>& values) noexcept;
      
      template<xtd::size length>
      bit_array(const std::bitset<length>& bit_set) noexcept : bit_array(length) {
        for (auto index = xtd::size {0}; index < length; ++index)
          set(index, bit_set.test(index));
      }
      
      bit_array(const std::vector<bool>& booleans) noexcept;
      
      bit_array(bit_array&& bits) = default;
      bit_array& operator=(bit_array&&) = default;
      bit_array(const bit_array& bits) = default;
      bit_array& operator=(const bit_array&) = default;
      
      
      
      const_iterator begin() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::begin();}
      iterator begin() noexcept override {return xtd::collections::generic::ienumerable<value_type>::begin();}
      
      template<xtd::size length>
      std::bitset<length> bits() const noexcept {
        auto result = std::bitset<length> {};
        auto bits_count = xtd::math::min(length, count());
        for (auto index = xtd::size {0}; index < bits_count; ++index)
          result[index] = at(index);
        return result;
      }
      
      std::vector<bool> bits() const noexcept {
        auto result = std::vector<bool> {};
        for (auto index = xtd::size {0}; index < count(); ++index)
          result[index] = at(index);
        return result;
      }
      
      const_iterator cbegin() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::cbegin();}
      
      const_iterator cend() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::cend();}
      
      xtd::size count() const noexcept override;
      
      const_iterator end() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::end();}
      iterator end() noexcept override {return xtd::collections::generic::ienumerable<value_type>::end();}
      
      xtd::size length() const noexcept;
      void length(xtd::size value);
      
      
      const bit_array& and_(const bit_array& value);
      
      bool at(xtd::size index) const;
      
      bool& at(xtd::size index);
      
      xtd::uptr<xtd::object> clone() const override;
      
      void copy_to(xtd::array<bool>& array, xtd::size index) const override;
      
      bool equals(const bit_array& value) const noexcept override;
      
      bool equals(const object& obj) const noexcept override;
      
      bool get(xtd::size index) const;
      
      bool& get(xtd::size index);
      
      xtd::collections::generic::enumerator<bool> get_enumerator() const override;
      
      bool has_all_set() const noexcept;
      
      bool has_any_set() const noexcept;
      
      bit_array& left_shift(xtd::size count) noexcept;
      
      const bit_array& not_();
      
      const bit_array& or_(const bit_array& value);
      
      bit_array& right_shift(xtd::size count) noexcept;
      
      void set(xtd::size index, bool value);
      
      void set_all(bool value);
      
      xtd::string to_string() const noexcept override;
      
      const bit_array& xor_(const bit_array& value);
      
      
      const bool& operator [](xtd::size index) const;
      
      bool& operator [](xtd::size index);
      
      using xtd::collections::generic::icollection<bool>::operator >>;
      bit_array operator >>(xtd::size count) const noexcept;
      
      bit_array& operator >>=(xtd::size count) noexcept;
      
      using xtd::collections::generic::icollection<bool>::operator <<;
      bit_array operator <<(xtd::size count) const noexcept;
      
      bit_array& operator <<=(xtd::size count) noexcept;
      
    private:
      bool is_read_only() const noexcept override;
      bool is_synchronized() const noexcept override;
      const object& sync_root() const noexcept override;
      
      void add(const bool&) override;
      void clear() override;
      bool contains(const bool&) const noexcept override;
      bool remove(const bool&) override;
      
      void flush() const noexcept;
      xtd::size get_int32_array_length_from_bit_length(xtd::size n) const noexcept;
      xtd::size get_list_length(xtd::size length_) const noexcept;
      xtd::size get_list_position(xtd::size index) const noexcept;
      xtd::size get_bit_position(xtd::size index) const noexcept;
      bool get_bit_value(xtd::size index) const noexcept;
      void set_bit_value(xtd::size index, bool value) noexcept;
      
      static constexpr xtd::size bits_per_byte = 8;
      static constexpr xtd::size bits_per_int32 = 32;
      static constexpr xtd::size bytes_per_int32 = 4;
      static constexpr xtd::size bit_shift_per_int32 = 5;
      mutable boolean_ref value_ref_;
      xtd::collections::generic::list<int32> bit_array_;
      xtd::size length_ = 0;
    };
  }
}