bit_segment.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UTILITY_BIT_SEGMENT_HPP
#define M5_UTILITY_BIT_SEGMENT_HPP
 
#include <cstddef>
#include <type_traits>
 
namespace m5 {
namespace utility {
 
template <size_t LowerBits, typename T>
class BitSegment {
public:
    using base_type              = typename std::remove_const<typename std::remove_reference<T>::type>::type;
    constexpr static bool SIGNED = std::is_signed<base_type>::value;
    static_assert(std::is_integral<base_type>::value, "Base type must be integral");
    static_assert(LowerBits > 0, "LowerBits must be not zero");
    static_assert(LowerBits <= (sizeof(base_type) * 8 - (SIGNED ? 1 : 0)), "LowerBits too large");
    using unsigned_type                        = typename std::make_unsigned<base_type>::type;
    constexpr static unsigned_type UPPER_BITS  = sizeof(unsigned_type) * 8U - LowerBits - (SIGNED ? 1 : 0);
    constexpr static unsigned_type LOWER_BITS  = static_cast<unsigned_type>(LowerBits);
    constexpr static unsigned_type UPPER_SHIFT = LOWER_BITS;
    constexpr static unsigned_type UPPER_MASK  = ((unsigned_type)1 << UPPER_BITS) - 1;
    constexpr static unsigned_type LOWER_MASK  = ((unsigned_type)1 << LOWER_BITS) - 1;
 
    inline constexpr BitSegment() = default;  
    inline constexpr BitSegment(const BitSegment& o) : _v(o._v)
    {
    }
    inline constexpr BitSegment(const base_type v) : _v(v)
    {
    }
 
    BitSegment& operator=(const BitSegment& o)
    {
        if (this != &o) {
            _v = o._v;
        }
        return *this;
    }
    BitSegment& operator=(const base_type v)
    {
        _v = v;
        return *this;
    }
 
 
    inline constexpr explicit operator bool() const
    {
        return _v;
    }
    inline constexpr operator base_type() const
    {
        return _v;
    }
 
 
    inline constexpr unsigned_type upper() const
    {
        return (static_cast<unsigned_type>(_v) >> UPPER_SHIFT) & UPPER_MASK;
    }
    inline constexpr unsigned_type lower() const
    {
        return _v & LOWER_MASK;
    }
    inline constexpr base_type raw() const
    {
        return _v;
    }
 
 
    inline void upper(const unsigned_type v)
    {
        _v = static_cast<base_type>((static_cast<unsigned_type>(_v) & ~(UPPER_MASK << UPPER_SHIFT)) |
                                    ((v & UPPER_MASK) << UPPER_SHIFT));
    }
    inline void lower(const unsigned_type v)
    {
        _v = (_v & ~LOWER_MASK) | (v & LOWER_MASK);
    }
    inline void raw(const base_type v)
    {
        _v = v;
    }
 
private:
    base_type _v{};
};
 
template <size_t LowerBits, typename T>
bool operator==(const BitSegment<LowerBits, T>& a, const BitSegment<LowerBits, T>& b)
{
    return a.raw() == b.raw();
}
template <size_t LowerBits, typename T>
bool operator!=(const BitSegment<LowerBits, T>& a, const BitSegment<LowerBits, T>& b)
{
    return !(a == b);
}
template <size_t LowerBits, typename T>
bool operator<(const BitSegment<LowerBits, T>& a, const BitSegment<LowerBits, T>& b)
{
    return a.raw() < b.raw();
}
template <size_t LowerBits, typename T>
bool operator>(const BitSegment<LowerBits, T>& a, const BitSegment<LowerBits, T>& b)
{
    return b < a;
}
template <size_t LowerBits, typename T>
bool operator<=(const BitSegment<LowerBits, T>& a, const BitSegment<LowerBits, T>& b)
{
    return !(a > b);
}
template <size_t LowerBits, typename T>
bool operator>=(const BitSegment<LowerBits, T>& a, const BitSegment<LowerBits, T>& b)
{
    return !(a < b);
}
 
template <size_t LowerBits, typename T>
bool operator==(const BitSegment<LowerBits, T>& a, const int b)
{
    return a.raw() == b;
}
template <size_t LowerBits, typename T>
bool operator!=(const BitSegment<LowerBits, T>& a, const int b)
{
    return !(a == b);
}
template <size_t LowerBits, typename T>
bool operator<(const BitSegment<LowerBits, T>& a, const int b)
{
    return a.raw() < b;
}
template <size_t LowerBits, typename T>
bool operator>(const BitSegment<LowerBits, T>& a, const int b)
{
    return b < a;
}
template <size_t LowerBits, typename T>
bool operator<=(const BitSegment<LowerBits, T>& a, const int b)
{
    return !(a > b);
}
template <size_t LowerBits, typename T>
bool operator>=(const BitSegment<LowerBits, T>& a, const int b)
{
    return !(a < b);
}
 
template <size_t LowerBits, typename T>
bool operator==(const int a, const BitSegment<LowerBits, T>& b)
{
    return a == b.raw();
}
template <size_t LowerBits, typename T>
bool operator!=(const int a, const BitSegment<LowerBits, T>& b)
{
    return !(a == b);
}
template <size_t LowerBits, typename T>
bool operator<(const int a, const BitSegment<LowerBits, T>& b)
{
    return a < b.raw();
}
template <size_t LowerBits, typename T>
bool operator>(const int a, const BitSegment<LowerBits, T>& b)
{
    return b < a;
}
 
template <size_t LowerBits, typename T>
bool operator<=(const int a, const BitSegment<LowerBits, T>& b)
{
    return !(a > b);
}
template <size_t LowerBits, typename T>
bool operator>=(const int a, const BitSegment<LowerBits, T>& b)
{
    return !(a < b);
}
 
}  // namespace utility
}  // namespace m5
#endif