qpset.hpp

Go to the documentation of this file.

 
#ifndef QPSET_HPP
#define QPSET_HPP
 
#ifndef QF_MAX_ACTIVE
    // default value when NOT defined
    #define QF_MAX_ACTIVE 32U
#endif
 
namespace QP {
 
#if (QF_MAX_ACTIVE < 1U) || (64U < QF_MAX_ACTIVE)
    #error "QF_MAX_ACTIVE out of range. Valid range is 1U..64U"
#elif (QF_MAX_ACTIVE <= 8U)
    using QPSetBits = std::uint8_t;
#elif (QF_MAX_ACTIVE <= 16U)
    using QPSetBits = std::uint16_t;
#else
    using QPSetBits = std::uint32_t;
#endif
 
//****************************************************************************
// Log-base-2 calculations ...
#ifndef QF_LOG2
    extern "C" std::uint_fast8_t QF_LOG2(QPSetBits x) noexcept;
#endif // QF_LOG2
 
//****************************************************************************
#if (QF_MAX_ACTIVE <= 32)
struct QPSet {
 
    QPSetBits volatile m_bits;  
 
    void setEmpty(void) noexcept {
        m_bits = 0U;
    }
 
    bool isEmpty(void) const noexcept {
        return (m_bits == 0U);
    }
 
    bool notEmpty(void) const noexcept {
        return (m_bits != 0U);
    }
 
    bool hasElement(std::uint_fast8_t const n) const noexcept {
        return (m_bits & (1U << (n - 1U))) != 0U;
    }
 
    void insert(std::uint_fast8_t const n) noexcept {
        m_bits |= (1U << (n - 1U));
    }
 
    void rmove(std::uint_fast8_t const n) noexcept {
        m_bits &=
           static_cast<QPSetBits>(~(static_cast<QPSetBits>(1) << (n - 1U)));
    }
 
    std::uint_fast8_t findMax(void) const noexcept {
        return QF_LOG2(m_bits);
    }
};
 
#else // QF_MAX_ACTIVE > 32U
 
struct QPSet {
 
    std::uint32_t volatile m_bits[2];
 
    void setEmpty(void) noexcept {
        m_bits[0] = 0U;
        m_bits[1] = 0U;
    }
 
    // the following logic avoids UB in volatile access for MISRA compliantce
    bool isEmpty(void) const noexcept {
        return (m_bits[0] == 0U) ? (m_bits[1] == 0U) : false;
    }
 
    // the following logic avoids UB in volatile access for MISRA compliantce
    bool notEmpty(void) const noexcept {
        return (m_bits[0] != 0U) ? true : (m_bits[1] != 0U);
    }
 
    bool hasElement(std::uint_fast8_t const n) const noexcept {
        return (n <= 32U)
            ? ((m_bits[0] & (static_cast<std::uint32_t>(1) << (n - 1U)))
                  != 0U)
            : ((m_bits[1] & (static_cast<std::uint32_t>(1) << (n - 33U)))
                  != 0U);
    }
 
    void insert(std::uint_fast8_t const n) noexcept {
        if (n <= 32U) {
            m_bits[0] |= (static_cast<std::uint32_t>(1) << (n - 1U));
        }
        else {
            m_bits[1] |= (static_cast<std::uint32_t>(1) << (n - 33U));
        }
    }
 
    void rmove(std::uint_fast8_t const n) noexcept {
        if (n <= 32U) {
            (m_bits[0] &= ~(static_cast<std::uint32_t>(1) << (n - 1U)));
        }
        else {
            (m_bits[1] &= ~(static_cast<std::uint32_t>(1) << (n - 33U)));
        }
    }
 
    std::uint_fast8_t findMax(void) const noexcept {
        return (m_bits[1] != 0U)
            ? (QF_LOG2(m_bits[1]) + 32U)
            : (QF_LOG2(m_bits[0]));
    }
};
 
#endif // QF_MAX_ACTIVE
 
} // namespace QP
 
#endif // QPSET_HPP