bitset.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_BITSET_BITSET_HPP
#define TETL_BITSET_BITSET_HPP
 
#include <etl/_algorithm/min.hpp>
#include <etl/_bit/set_bit.hpp>
#include <etl/_bitset/basic_bitset.hpp>
#include <etl/_contracts/check.hpp>
#include <etl/_cstddef/size_t.hpp>
#include <etl/_limits/numeric_limits.hpp>
#include <etl/_string/basic_inplace_string.hpp>
#include <etl/_string_view/basic_string_view.hpp>
 
namespace etl {

template <etl::size_t Bits>
struct bitset {
    using reference = basic_bitset<Bits, etl::size_t>::reference;

    constexpr bitset() noexcept = default;

    constexpr bitset(unsigned long long val) noexcept
        : _bits(val)
    {
    }

    template <typename CharT, typename Traits>
    explicit constexpr bitset(
        basic_string_view<CharT, Traits> const& str,
        typename basic_string_view<CharT, Traits>::size_type pos = 0,
        typename basic_string_view<CharT, Traits>::size_type n   = basic_string_view<CharT, Traits>::npos,
        CharT zero                                               = CharT('0'),
        CharT one                                                = CharT('1')
    )
        : bitset(0ULL)
    {
        auto const len = etl::min<decltype(pos)>(n, str.size() - pos);
        TETL_PRECONDITION(len >= 0);
        TETL_PRECONDITION(len <= size());
 
        for (decltype(pos) i = 0; i < len; ++i) {
            if (Traits::eq(str[i + pos], one)) {
                set(i, true);
            }
            if (Traits::eq(str[i + pos], zero)) {
                set(i, false);
            }
        }
    }

    template <typename CharT>
    explicit constexpr bitset(
        CharT const* str,
        typename basic_string_view<CharT>::size_type n = basic_string_view<CharT>::npos,
        CharT zero                                     = CharT('0'),
        CharT one                                      = CharT('1')
    )
        : bitset(
              n == basic_string_view<CharT>::npos ? basic_string_view<CharT>(str) : basic_string_view<CharT>(str, n),
              0,
              n,
              zero,
              one
          )
    {
    }

    constexpr auto set() noexcept -> bitset&
    {
        _bits.set();
        return *this;
    }

    constexpr auto set(etl::size_t pos, bool value = true) -> bitset&
    {
        TETL_PRECONDITION(pos < size());
        _bits.unchecked_set(pos, value);
        return *this;
    }

    constexpr auto reset() noexcept -> bitset&
    {
        _bits.reset();
        return *this;
    }

    constexpr auto reset(size_t pos) noexcept -> bitset&
    {
        TETL_PRECONDITION(pos < size());
        _bits.unchecked_reset(pos);
        return *this;
    }

    constexpr auto flip() noexcept -> bitset&
    {
        _bits.flip();
        return *this;
    }

    constexpr auto flip(size_t pos) noexcept -> bitset&
    {
        TETL_PRECONDITION(pos < size());
        _bits.unchecked_flip(pos);
        return *this;
    }

    [[nodiscard]] constexpr auto operator[](size_t const pos) -> reference
    {
        TETL_PRECONDITION(pos < size());
        return _bits[pos];
    }

    [[nodiscard]] constexpr auto operator[](size_t const pos) const -> bool
    {
        TETL_PRECONDITION(pos < size());
        return _bits[pos];
    }

    [[nodiscard]] constexpr auto test(size_t const pos) const -> bool
    {
        TETL_PRECONDITION(pos < size());
        return _bits.unchecked_test(pos);
    }

    [[nodiscard]] constexpr auto all() const noexcept -> bool { return _bits.all(); }

    [[nodiscard]] constexpr auto any() const noexcept -> bool { return _bits.any(); }

    [[nodiscard]] constexpr auto none() const noexcept -> bool { return _bits.none(); }

    [[nodiscard]] constexpr auto count() const noexcept -> size_t { return _bits.count(); }

    [[nodiscard]] constexpr auto size() const noexcept -> size_t { return _bits.size(); }

    [[nodiscard]] constexpr auto operator==(bitset const& rhs) const noexcept -> bool { return _bits == rhs._bits; }

    constexpr auto operator&=(bitset const& other) noexcept -> bitset&
    {
        _bits &= other._bits;
        return *this;
    }

    constexpr auto operator|=(bitset const& other) noexcept -> bitset&
    {
        _bits |= other._bits;
        return *this;
    }

    constexpr auto operator^=(bitset const& other) noexcept -> bitset&
    {
        _bits ^= other._bits;
        return *this;
    }

    constexpr auto operator~() const noexcept -> bitset { return bitset(*this).flip(); }

    template <size_t Capacity, typename CharT = char, typename Traits = char_traits<CharT>>
        requires(Capacity >= Bits)
    [[nodiscard]] constexpr auto to_string(CharT zero = CharT('0'), CharT one = CharT('1')) const
        -> basic_inplace_string<CharT, Capacity, Traits>
    {
        auto str = basic_inplace_string<CharT, Capacity, Traits>{};
        for (auto i{size() - 1U}; i != 0; --i) {
            str.push_back(test(i) ? one : zero);
        }
        str.push_back(test(0) ? one : zero);
        return str;
    }

    [[nodiscard]] constexpr auto to_ulong() const noexcept -> unsigned long
        requires(etl::numeric_limits<unsigned long>::digits >= Bits)
    {
        return to_unsigned_type<unsigned long>();
    }

    [[nodiscard]] constexpr auto to_ullong() const noexcept -> unsigned long long
        requires(etl::numeric_limits<unsigned long long>::digits >= Bits)
    {
        return to_unsigned_type<unsigned long long>();
    }

    friend constexpr auto operator&(bitset const& lhs, bitset const& rhs) noexcept -> bitset
    {
        return bitset(lhs) &= rhs;
    }

    friend constexpr auto operator|(bitset const& lhs, bitset const& rhs) noexcept -> bitset
    {
        return bitset(lhs) |= rhs;
    }

    friend constexpr auto operator^(bitset const& lhs, bitset const& rhs) noexcept -> bitset
    {
        return bitset(lhs) ^= rhs;
    }
 
private:
    template <typename UInt>
    [[nodiscard]] constexpr auto to_unsigned_type() const noexcept -> UInt
    {
        constexpr auto digits = static_cast<UInt>(etl::numeric_limits<UInt>::digits);
        auto const idx        = etl::min<UInt>(static_cast<UInt>(size()), digits);
        UInt result{};
        for (UInt i{0}; i != idx; ++i) {
            if (test(static_cast<etl::size_t>(i))) {
                result = etl::set_bit(result, i);
            }
        }
        return result;
    }
 
    basic_bitset<Bits, etl::size_t> _bits;
};
 
} // namespace etl
 
#endif // TETL_BITSET_BITSET_HPP