mirror of
https://github.com/matrix-construct/construct
synced 2024-12-13 17:13:02 +01:00
167 lines
3 KiB
C++
167 lines
3 KiB
C++
// Matrix Construct
|
|
//
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2022 Jason Volk <jason@zemos.net>
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
// full license for this software is available in the LICENSE file.
|
|
|
|
#pragma once
|
|
#define HAVE_IRCD_UTIL_BITSET_H
|
|
|
|
namespace ircd {
|
|
inline namespace util
|
|
{
|
|
template<size_t>
|
|
struct bitset;
|
|
}}
|
|
|
|
template<size_t N>
|
|
struct ircd::util::bitset
|
|
{
|
|
using word = uint8_t;
|
|
|
|
static constexpr size_t word_bits
|
|
{
|
|
sizeof(word) * 8
|
|
};
|
|
|
|
static constexpr size_t words
|
|
{
|
|
N / word_bits?: 1
|
|
};
|
|
|
|
private:
|
|
word buf[words] {0};
|
|
|
|
constexpr size_t byte(const size_t pos) const;
|
|
constexpr size_t bit(const size_t pos) const;
|
|
|
|
public:
|
|
constexpr size_t size() const
|
|
{
|
|
return N;
|
|
}
|
|
|
|
constexpr bool test(const size_t pos) const;
|
|
constexpr size_t count() const;
|
|
|
|
constexpr void reset(const size_t pos);
|
|
constexpr void reset();
|
|
constexpr void set(const size_t pos, const bool val = true);
|
|
constexpr void set();
|
|
constexpr void flip(const size_t pos);
|
|
constexpr void flip();
|
|
|
|
constexpr bitset(const uint128_t val);
|
|
constexpr bitset() = default;
|
|
};
|
|
|
|
template<size_t N>
|
|
constexpr
|
|
ircd::util::bitset<N>::bitset(const uint128_t val)
|
|
{
|
|
const auto bits
|
|
{
|
|
std::min(sizeof(buf) * 8, sizeof(val) * 8)
|
|
};
|
|
|
|
size_t i{0};
|
|
for(; i < bits; ++i)
|
|
{
|
|
const decltype(val) one{1};
|
|
set(i, val & (one << i));
|
|
}
|
|
|
|
for(; i < size(); ++i)
|
|
set(i, false);
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr void
|
|
ircd::util::bitset<N>::flip()
|
|
{
|
|
for(size_t i(0); i < words; ++i)
|
|
buf[i] =~ buf[i];
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr void
|
|
ircd::util::bitset<N>::flip(const size_t pos)
|
|
{
|
|
buf[byte(pos)] ^= word(1) << bit(pos);
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr void
|
|
ircd::util::bitset<N>::set()
|
|
{
|
|
for(size_t i(0); i < words; ++i)
|
|
buf[i] = ~word{0};
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr void
|
|
ircd::util::bitset<N>::set(const size_t pos,
|
|
const bool val)
|
|
{
|
|
buf[byte(pos)] |= word(val) << bit(pos);
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr void
|
|
ircd::util::bitset<N>::reset()
|
|
{
|
|
for(size_t i(0); i < words; ++i)
|
|
buf[i] = 0;
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr void
|
|
ircd::util::bitset<N>::reset(const size_t pos)
|
|
{
|
|
buf[byte(pos)] &= ~(word(1) << bit(pos));
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr size_t
|
|
ircd::util::bitset<N>::count()
|
|
const
|
|
{
|
|
size_t ret(0);
|
|
for(size_t i(0); i < words; ++i)
|
|
ret += popcount(buf[i]);
|
|
|
|
return ret;
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr bool
|
|
ircd::util::bitset<N>::test(const size_t pos)
|
|
const
|
|
{
|
|
return buf[byte(pos)] & (word(1) << bit(pos));
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr size_t
|
|
ircd::util::bitset<N>::byte(const size_t pos)
|
|
const
|
|
{
|
|
constexpr auto max(words - 1);
|
|
const auto off(pos / 8);
|
|
if(!__builtin_is_constant_evaluated())
|
|
assert(off <= max);
|
|
|
|
return std::min(off, max);
|
|
}
|
|
|
|
template<size_t N>
|
|
constexpr size_t
|
|
ircd::util::bitset<N>::bit(const size_t pos)
|
|
const
|
|
{
|
|
return pos % 8;
|
|
}
|