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 "../index.hpp"
#include "../int32.hpp"
#include "../math.hpp"
#include "../npos.hpp"
#include "../object.hpp"
#include "../usize.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::usize index) noexcept;
        const bool& get_boolean_ref(bool value, xtd::usize index) const noexcept;
        void from_boolean(bit_array& parent) noexcept;
        
        inline static constexpr xtd::usize npos = xtd::npos;
        mutable xtd::usize index = npos;
        mutable bool value = false;
      };
      
    public:
      
      using value_type = bool;
      using base_type =  typename xtd::collections::generic::list<int32>;
      using size_type = xtd::usize;
      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*;
      
      
      explicit bit_array(xtd::usize length) noexcept;
      
      bit_array(xtd::usize 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::usize length>
      bit_array(const std::bitset<length>& bit_set) noexcept : bit_array(length) {
        for (auto index = xtd::usize {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(const bit_array& bits) = default;
      auto operator=(bit_array&&) -> bit_array& = default;
      auto operator=(const bit_array&) -> bit_array& = default;
      
      
      template<xtd::usize length>
      [[nodiscard]] auto bits() const noexcept -> std::bitset<length> {
        auto result = std::bitset<length> {};
        auto bits_count = xtd::math::min(length, count());
        for (auto index = xtd::usize {0}; index < bits_count; ++index)
          result[index] = self_[index];
        return result;
      }
      
      [[nodiscard]] auto bits() const noexcept -> std::vector<bool> {
        auto result = std::vector<bool> {};
        for (auto index = xtd::usize {0}; index < count(); ++index)
          result[index] = self_[index];
        return result;
      }
      
      [[nodiscard]] auto count() const noexcept -> xtd::usize override;
      
      [[nodiscard]] auto length() const noexcept -> xtd::usize;
      auto length(xtd::usize value) -> void;
      
      
      auto and_(const bit_array& value) -> const bit_array&;
      
      [[nodiscard]] xtd::uptr<xtd::object> clone() const override;
      
      auto copy_to(xtd::array<bool>& array, xtd::usize index) const -> void override;
      
      [[nodiscard]] auto equals(const bit_array& value) const noexcept -> bool override;
      
      [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override;
      
      [[nodiscard]] auto get(xtd::usize index) const -> bool;
      
      [[nodiscard]] auto get(xtd::usize index) -> bool&;
      
      [[nodiscard]] xtd::collections::generic::enumerator<bool> get_enumerator() const override;
      
      [[nodiscard]] auto has_all_set() const noexcept -> bool;
      
      [[nodiscard]] auto has_any_set() const noexcept -> bool;
      
      auto left_shift(xtd::usize count) noexcept -> bit_array&;
      
      auto not_() -> const bit_array&;
      
      auto or_(const bit_array& value) -> const bit_array&;
      
      auto right_shift(xtd::usize count) noexcept -> bit_array&;
      
      auto set(xtd::usize index, bool value) -> void;
      
      auto set_all(bool value) -> void;
      
      [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
      
      auto xor_(const bit_array& value) -> const bit_array&;
      
      
      auto operator [](xtd::usize index) const -> const bool&;
      auto operator [](xtd::usize index) -> bool&;
      auto operator [](const xtd::index& index) const -> const bool&;
      auto operator [](const xtd::index& index) -> bool&;

      auto operator ()(xtd::usize index) const -> const bool&;
      auto operator ()(xtd::usize index) -> bool&;
      auto operator ()(const xtd::index& index) const -> const bool&;
      auto operator ()(const xtd::index& index) -> bool&;

      auto operator &(const bit_array& value) const -> bit_array;
      auto operator &=(const bit_array& value) -> bit_array&;
      
      auto operator |(const bit_array& value) const -> bit_array;
      auto operator |=(const bit_array& value) -> bit_array&;
      
      auto operator ^(const bit_array& value) const -> bit_array;
      auto operator ^=(const bit_array& value) -> bit_array&;
      
      auto operator ~() const -> bit_array;
      
      using xtd::collections::generic::icollection<bool>::operator >>;
      auto operator >>(xtd::usize count) const noexcept -> bit_array;
      
      auto operator >>=(xtd::usize count) noexcept -> bit_array&;
      
      using xtd::collections::generic::icollection<bool>::operator <<;
      auto operator <<(xtd::usize count) const noexcept -> bit_array;
      
      auto operator <<=(xtd::usize count) noexcept -> bit_array&;
      
    private:
      auto is_read_only() const noexcept -> bool override;
      auto is_synchronized() const noexcept -> bool override;
      const object& sync_root() const noexcept override;
      
      auto add(const bool&) -> void override;
      auto clear() -> void override;
      auto contains(const bool&) const noexcept -> bool override;
      auto remove(const bool&) -> bool override;
      
      auto flush() const noexcept -> void;
      auto get_int32_array_length_from_bit_length(xtd::usize n) const noexcept -> xtd::usize;
      auto get_list_length(xtd::usize length_) const noexcept -> xtd::usize;
      auto get_list_position(xtd::usize index) const noexcept -> xtd::usize;
      auto get_bit_position(xtd::usize index) const noexcept -> xtd::usize;
      auto get_bit_value(xtd::usize index) const noexcept -> bool;
      auto set_bit_value(xtd::usize index, bool value) noexcept -> void;
      
      static constexpr xtd::usize bits_per_byte = 8;
      static constexpr xtd::usize bits_per_int32 = 32;
      static constexpr xtd::usize bytes_per_int32 = 4;
      static constexpr xtd::usize bit_shift_per_int32 = 5;
      mutable boolean_ref value_ref_;
      xtd::collections::generic::list<xtd::int32> bit_array_;
      xtd::usize length_ = 0;
    };
  }
}

template<xtd::usize size_>
inline auto xtd::linq::enumerable::as_enumerable(const std::bitset<size_>& source) noexcept -> xtd::collections::generic::enumerable_generator<bool> {
  for (const auto& item : xtd::collections::bit_array {source})
    co_yield item;
}
template<xtd::usize size_>
inline auto xtd::linq::enumerable::as_enumerable(std::bitset<size_>& source) noexcept -> xtd::collections::generic::enumerable_generator<bool> {
  for (const auto& item : xtd::collections::bit_array {source})
    co_yield item;
}
 
template<xtd::usize size_>
auto xtd::linq::enumerable::from(const std::bitset<size_>& source) noexcept -> xtd::collections::generic::enumerable_generator<bool> {
  return as_enumerable(source);
}
template<xtd::usize size_>
auto xtd::linq::enumerable::from(std::bitset<size_>& source) noexcept -> xtd::collections::generic::enumerable_generator<bool> {
  return as_enumerable(source);
}