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*;
      
      
      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(const bit_array& bits) = default;
      auto operator=(bit_array&&) -> bit_array& = default;
      auto operator=(const bit_array&) -> bit_array& = default;
      
      
      template<xtd::size length>
      auto bits() const noexcept -> std::bitset<length> {
        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] = self_[index];
        return result;
      }
      
      auto bits() const noexcept -> std::vector<bool> {
        auto result = std::vector<bool> {};
        for (auto index = xtd::size {0}; index < count(); ++index)
          result[index] = self_[index];
        return result;
      }
      
      auto count() const noexcept -> xtd::size override;
      
      auto length() const noexcept -> xtd::size;
      auto length(xtd::size value) -> void;
      
      
      auto and_(const bit_array& value) -> const bit_array&;
      
      xtd::uptr<xtd::object> clone() const override;
      
      auto copy_to(xtd::array<bool>& array, xtd::size index) const -> void override;
      
      auto equals(const bit_array& value) const noexcept -> bool override;
      
      auto equals(const object& obj) const noexcept -> bool override;
      
      auto get(xtd::size index) const -> bool;
      
      auto get(xtd::size index) -> bool&;
      
      xtd::collections::generic::enumerator<bool> get_enumerator() const override;
      
      auto has_all_set() const noexcept -> bool;
      
      auto has_any_set() const noexcept -> bool;
      
      auto left_shift(xtd::size count) noexcept -> bit_array&;
      
      auto not_() -> const bit_array&;
      
      auto or_(const bit_array& value) -> const bit_array&;
      
      auto right_shift(xtd::size count) noexcept -> bit_array&;
      
      auto set(xtd::size index, bool value) -> void;
      
      auto set_all(bool value) -> void;
      
      auto to_string() const noexcept -> xtd::string override;
      
      auto xor_(const bit_array& value) -> const bit_array&;
      
      
      auto operator [](xtd::size index) const -> const bool&;
      
      auto operator [](xtd::size 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::size count) const noexcept -> bit_array;
      
      auto operator >>=(xtd::size count) noexcept -> bit_array&;
      
      using xtd::collections::generic::icollection<bool>::operator <<;
      auto operator <<(xtd::size count) const noexcept -> bit_array;
      
      auto operator <<=(xtd::size 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::size n) const noexcept -> xtd::size;
      auto get_list_length(xtd::size length_) const noexcept -> xtd::size;
      auto get_list_position(xtd::size index) const noexcept -> xtd::size;
      auto get_bit_position(xtd::size index) const noexcept -> xtd::size;
      auto get_bit_value(xtd::size index) const noexcept -> bool;
      auto set_bit_value(xtd::size index, bool value) noexcept -> void;
      
      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;
    };
  }
}

template<xtd::size size_>
inline auto xtd::linq::enumerable::as_enumerable(std::bitset<size_> source) {
  return xtd::collections::bit_array {source};
}