bits.h

 
#pragma once
 
#include <bit>
#include <stdexcept>
 
#include "cpp23.h"
 
#if !defined(__cpp_concepts)
#error "This library requires concepts"
#endif
 
namespace ghassanpl
{
    

    template<typename T>
    concept bit_integral = std::integral<T> && !std::same_as<std::remove_cvref_t<T>, bool>;

    template <typename T>
    constexpr inline auto bit_count = sizeof(T) * CHAR_BIT;

    constexpr inline uint64_t all_bits = ~uint64_t{ 0 };

    template <size_t BEGIN, size_t END>
    requires (END > BEGIN) && (END <= 64)
    constexpr inline uint64_t bit_mask_v = (all_bits >> (64 - END)) << BEGIN;

    template <bit_integral FOR>
    constexpr inline uint64_t bit_mask_for_v = (all_bits >> (64 - bit_count<FOR>));

    template <typename TO, typename FROM>
    concept bit_castable = std::is_trivially_copyable_v<TO> && std::is_trivially_copyable_v<FROM> && sizeof(TO) == sizeof(FROM);

    template <size_t BEGIN, size_t END, bit_integral T>
    constexpr T extract_bits(T value) {
        static_assert(END > BEGIN, "range size must be greater than zero");
        static_assert(END <= bit_count<T>, "range must be within type bit size");
        return T(value >> BEGIN) & T((T(1)<<(END-BEGIN))-1);
    };
 
    template <size_t... RANGES, bit_integral T>
    constexpr auto split_bit_ranges(T value) {
        static_assert((RANGES + ...) == bit_count<T>);
        uint64_t bits = static_cast<uint64_t>(value);
        auto extract = [&]<size_t N>(std::integral_constant<size_t, N>) {
            auto result = extract_bits<0, N>(bits);
            bits >>= N;
            return result;
        };
        return std::array {
            extract(std::integral_constant<size_t, RANGES>{})...
        };
    };
 
    template <size_t N, bit_integral T>
    constexpr bool bit_at(T bits) { return ((bits >> N) & 1) == 1; }
 
    namespace detail
    {
        template <size_t N>
        struct uintN_t_t;
        template <> struct uintN_t_t<8> { using value = uint8_t; };
        template <> struct uintN_t_t<16> { using value = uint16_t; };
        template <> struct uintN_t_t<32> { using value = uint32_t; };
        template <> struct uintN_t_t<64> { using value = uint64_t; };
        template <size_t N>
        requires (N < 8)
        struct uintN_t_t<N>
        {
            using value = uint8_t;
        };
    }

    template <size_t N>
    using uintN_t = typename detail::uintN_t_t<N>::value;
    
    template <typename T>
    using uint_sizeof_t = uintN_t<sizeof(T) * CHAR_BIT>;
 
    namespace detail
    {
        template <size_t N>
        struct intN_t_t
        {
            using value = std::make_signed_t<uintN_t<N>>;
        };
    }

    template <size_t N>
    using intN_t = typename detail::intN_t_t<N>::value;
 
    template <typename T>
    using int_sizeof_t = intN_t<sizeof(T)* CHAR_BIT>;
 
    namespace detail
    {
        template <bool SIGNED, size_t N>
        struct sintN_t_t;
        template <size_t N> struct sintN_t_t<false, N> { using value = uintN_t<N>; };
        template <size_t N> struct sintN_t_t<true, N> { using value = intN_t<N>; };
    }

    template <bool SIGNED, size_t N>
    using sintN_t = typename detail::sintN_t_t<SIGNED, N>::value;

    template <bit_integral... BIT_TYPES>
    constexpr auto cat_bits(BIT_TYPES... bits)
    {
        using sum_type = uintN_t<(bit_count<BIT_TYPES> + ...)>;
        sum_type result = 0;
        auto assign = [&]<typename T>(T value) {
            result <<= bit_count<T>;
            result |= value;
        };
        (assign(bits), ...);
        return result;
    }

    template <size_t... BIT_COUNT, bit_integral... BIT_TYPES>
    constexpr auto cat_bits_n(BIT_TYPES... values)
    {
        static_assert(requires { sizeof(uintN_t<(BIT_COUNT + ...)>); });
        static_assert(sizeof...(BIT_COUNT) == sizeof...(BIT_TYPES), "The number of bit counts must be the same as the number of values");
        using sum_type = uintN_t<(BIT_COUNT + ...)>;
        sum_type result = 0;
        auto assign = [&]<size_t N, typename T>(T value) {
            result <<= N;
            result |= n_least_significant<N>(value);
        };
        ((assign.template operator()<BIT_COUNT>(values)), ...);
        return result;
    }
 
    template <size_t N, bit_integral T>
    constexpr T n_most_significant(T value) { return (value >> T(bit_count<T> -N)) & T(bit_mask_v<0, N>); };
 
    template <size_t N, bit_integral T>
    constexpr T n_least_significant(T value) { return value & T(bit_mask_v<0, N>); };

    template <bit_integral T>
    [[nodiscard]] constexpr auto most_significant_half(T v) noexcept
    {
        constexpr auto bit_count = ghassanpl::bit_count<T>;
        constexpr auto bit_count_half = bit_count / 2;
        return static_cast<sintN_t<std::is_signed_v<T>, bit_count_half>>((v >> bit_count_half) & bit_mask_v<0, bit_count_half>);
    }

    template <bit_integral T>
    [[nodiscard]] constexpr auto least_significant_half(T v) noexcept
    {
        constexpr auto bit_count = ghassanpl::bit_count<T>;
        constexpr auto bit_count_half = bit_count / 2;
        return static_cast<sintN_t<std::is_signed_v<T>, bit_count_half>>(v & bit_mask_v<0, bit_count_half>);
    }

    template <bit_integral T>
    [[nodiscard]] constexpr auto split_bits(T v) noexcept
    {
        return std::make_pair(most_significant_half(v), least_significant_half(v));
    }

    template <std::unsigned_integral T>
    constexpr T bit_reverse(T x) noexcept
    {
        T result = 0;
        for (int i = 0; i < std::numeric_limits<T>::digits; ++i) {
            result <<= 1;
            result |= x & 1;
            x >>= 1;
        }
        return result;
    }

    template <std::unsigned_integral T>
    constexpr T bit_repeat(T x, int length) noexcept(false)
    {
        T result = 0;
        for (int i = 0; i < std::numeric_limits<T>::digits; ++i) {
            result |= ((x >> (i % length)) & 1) << i;
        }
        return result;
    }

    template <std::unsigned_integral T>
    constexpr T bit_compress(T x, T m) noexcept
    {
        T result = 0;
        for (int i = 0, j = 0; i < std::numeric_limits<T>::digits; ++i) {
            bool mask_bit = (m >> i) & 1;
            result |= (mask_bit & (x >> i)) << j;
            j += mask_bit;
        }
        return result;
    }

    template <std::unsigned_integral T>
    constexpr T bit_expand(T x, T m) noexcept
    {
        T result = 0;
        for (int i = 0, j = 0; i < std::numeric_limits<T>::digits; ++i) {
            bool mask_bit = (m >> i) & 1;
            result |= (mask_bit & (x >> j)) << i;
            j += mask_bit;
        }
        return result;
    }


    template <bit_integral B>
    [[nodiscard]] constexpr B to_big_endian(B val) noexcept { if constexpr (std::endian::native == std::endian::big) return val; else return byteswap(val); }

    template <bit_integral B>
    [[nodiscard]] constexpr B to_little_endian(B val) noexcept { if constexpr (std::endian::native == std::endian::little) return val; else return byteswap(val); }

    template <bit_integral B>
    [[nodiscard]] constexpr B from_big_endian(B val) noexcept { if constexpr (std::endian::native == std::endian::big) return val; else return byteswap(val); }

    template <bit_integral B>
    [[nodiscard]] constexpr B from_little_endian(B val) noexcept { if constexpr (std::endian::native == std::endian::little) return val; else return byteswap(val); }

    template <std::endian ENDIANNESS, bit_integral B>
    [[nodiscard]] constexpr B to_endian(B val) noexcept { if constexpr (std::endian::native == ENDIANNESS) return val; else return byteswap(val); }

    template <bit_integral B>
    [[nodiscard]] constexpr B to_endian(B val, std::endian endianness) noexcept { if (std::endian::native == endianness) return val; else return byteswap(val); }

    template <std::endian ENDIANNESS, bit_integral B>
    [[nodiscard]] constexpr B from_endian(B val) noexcept { if constexpr (std::endian::native == ENDIANNESS) return val; else return byteswap(val); }

    template <bit_integral B>
    [[nodiscard]] constexpr B from_endian(B val, std::endian endianness) noexcept { if (std::endian::native == endianness) return val; else return byteswap(val); }


    constexpr inline size_t dynamic_bit_number = size_t(-1);
 
    namespace detail
    {
        template <size_t NUM>
        using bit_num_t = std::integral_constant<size_t, NUM>;
 
        template <size_t NUM>
        constexpr inline auto bit_num = bit_num_t<NUM>{};
 
        template <bit_integral VALUE_TYPE, size_t BIT_NUM>
        struct bit_num_base
        {
            using unsigned_value_type = std::make_unsigned_t<VALUE_TYPE>;
        protected:
            static constexpr VALUE_TYPE m_bit_mask = std::bit_cast<VALUE_TYPE>(unsigned_value_type(unsigned_value_type(1) << BIT_NUM % bit_count<VALUE_TYPE>));
        };
 
        template <bit_integral VALUE_TYPE>
        struct bit_num_base<VALUE_TYPE, dynamic_bit_number>
        {
            using unsigned_value_type = std::make_unsigned_t<VALUE_TYPE>;
        protected:
            constexpr bit_num_base(size_t bitnum) noexcept : m_bit_mask(std::bit_cast<VALUE_TYPE>(unsigned_value_type(unsigned_value_type(1) << bitnum % bit_count<VALUE_TYPE>))) {}
            VALUE_TYPE m_bit_mask;
        };
    }

    template <bit_integral VALUE_TYPE, size_t BIT_NUM = dynamic_bit_number>
    struct bit_reference : public detail::bit_num_base<VALUE_TYPE, BIT_NUM>
    {
        using base_type = detail::bit_num_base<VALUE_TYPE, BIT_NUM>;
        static constexpr size_t value_bit_count = bit_count<VALUE_TYPE>;
 
        static constexpr bool is_static = BIT_NUM != dynamic_bit_number;
        static constexpr bool is_const = std::is_const_v<VALUE_TYPE>;
 
        constexpr bit_reference(VALUE_TYPE& ref, size_t bitnum) requires (!is_static)
            : base_type(bitnum)
            , m_value_ref(&ref)
        {
            if (bitnum >= value_bit_count)
                throw std::invalid_argument("bit_num can't be greater than or equal to the number of bits in the value type");
        }
 
        constexpr bit_reference(VALUE_TYPE& ref, detail::bit_num_t<BIT_NUM> = {}) noexcept requires is_static
            : m_value_ref(&ref)
        {
            static_assert(BIT_NUM < value_bit_count, "BIT_NUM template argument can't be greater than or equal to the number of bits in the value type");
        }
 
        constexpr bit_reference& operator=(bool val) noexcept requires (!is_const)
        {
            if (val)
                *m_value_ref |= this->m_bit_mask;
            else
                *m_value_ref &= ~this->m_bit_mask;
            return *this;
        }
 
        [[nodiscard]] explicit constexpr operator bool() const noexcept
        {
            return (*m_value_ref & this->m_bit_mask) != 0;
        }
 
        template <bit_integral OTHER_VALUE_TYPE, size_t OTHER_BIT_NUM>
        [[nodiscard]] constexpr bool operator==(bit_reference<OTHER_VALUE_TYPE, OTHER_BIT_NUM> const& other) const noexcept
        {
            return this->operator bool() == other.operator bool();
        }
 
        template <bit_integral OTHER_VALUE_TYPE, size_t OTHER_BIT_NUM>
        [[nodiscard]] constexpr auto operator<=>(bit_reference<OTHER_VALUE_TYPE, OTHER_BIT_NUM> const& other) const noexcept
        {
            return this->operator bool() <=> other.operator bool();
        }

        [[nodiscard]] constexpr auto& integer_value() const noexcept { return *m_value_ref; }

        [[nodiscard]] constexpr size_t bit_number() const noexcept
        {
            if constexpr (is_static)
                return BIT_NUM; 
            else
                return std::countr_zero(std::bit_cast<std::make_unsigned_t<VALUE_TYPE>>(this->m_bit_mask)); 
        }
 
    private:
 
        VALUE_TYPE* m_value_ref;
    };

    template <bit_integral VALUE_TYPE>
    bit_reference(VALUE_TYPE&, size_t) -> bit_reference<VALUE_TYPE>;
    template <bit_integral VALUE_TYPE, size_t BIT_NUM>
    bit_reference(VALUE_TYPE&, detail::bit_num_t<BIT_NUM>) -> bit_reference<VALUE_TYPE, BIT_NUM>;

}