helper.hpp

#ifndef QOS_CPP_HELPER
#define QOS_CPP_HELPER
 
#include "include/types.hpp"
 
namespace qOS {
 
    namespace bits {
        /*cstat -CERT-INT34-C_a -MISRAC++2008-5-0-10*/
        template <typename T, typename W>
        inline void multipleSet( T &dst, W xBits )
        {
            dst = dst | static_cast<T>( xBits );
        }
        template <typename T, typename W>
        inline void multipleClear( T &dst, W xBits )
        {
            dst = dst & ~static_cast<T>( xBits );
        }
        template <typename T>
        inline void singleSet( T &dst, const size_t xBit )
        {
            dst = dst | ( static_cast<T>( 1U ) << static_cast<T>( xBit ) );
        }
        template <typename T>
        inline void singleClear( T &dst, const size_t xBit )
        {
            dst = dst & ~( static_cast<T>( 1U ) << static_cast<T>( xBit ) );
        }
        template <typename T>
        inline bool singleRead( T dst, const size_t xBit )
        {
            return ( static_cast<T>( 0U ) != ( dst & ( static_cast<T>( 1U ) << static_cast<T>( xBit ) ) ) );
        }
        template <typename T>
        inline void singleToggle( T &dst, const size_t xBit )
        {
            dst = dst ^ ( static_cast<T>( 1U ) << static_cast<T>( xBit ) );
        }
        /*cstat +CERT-INT34-C_a +MISRAC++2008-5-0-10*/
        template <typename T>
        inline void singleWrite( T &dst, const size_t xBit, const bool value )
        {
            ( value ) ? bits::singleSet( dst, xBit ) : bits::singleClear( dst, xBit );
        }
        template <typename T, typename W>
        inline bool multipleGet( T reg, W xBits )
        {
            return ( 0U != ( reg & xBits) );
        }
    }
 
    template <typename DT, typename ST>
    inline DT aligned_cast( ST& src )
    {
        /*cstat -CERT-EXP33-C_a*/
        DT dst;
        (void)memcpy( &dst, &src, sizeof(ST) );
        return dst;
        /*cstat +CERT-EXP33-C_a*/
    }
    template <typename T>
    constexpr size_t arraySize( const T& ) noexcept
    {
        return 1;
    }
    template <typename T, size_t n>
    constexpr size_t arraySize( const T (&arr)[n] ) noexcept // skipcq: CXX-W2066
    {
        return n*arraySize(*arr);
    }
    template <typename T>
    inline T clip( T x, const T Min, const T Max )
    {
        return ( x < Min ) ? Min : ( ( x > Max ) ? Max : x );
    }
    template <typename T>
    inline T clipUpper( T x, const T Max )
    {
        return ( x > Max ) ? Max : x ;
    }
    template <typename T>
    inline T clipLower( T x, const T Min )
    {
        return ( x < Min ) ? Min : x ;
    }
    template <typename T>
    inline T isBetween( T x, const T Low, const T High )
    {
        return ( x >= Low ) && ( x <= High );
    }
    inline uint8_t byteNibbleHigh( uint8_t x )
    {
        return static_cast<uint8_t>( x >> 4U );
    }
    inline uint8_t byteNibbleLow( uint8_t x )
    {
        return static_cast<uint8_t>( x & 0x0FU );
    }
    inline uint8_t byteMergeNibbles( uint8_t h, uint8_t l )
    {
        return static_cast<uint8_t>( ( h << 4U ) | ( 0x0FU & l ) );
    }
    inline uint16_t wordByteHigh( uint16_t x )
    {
        return static_cast<uint16_t>( x >> 8U );
    }
    inline uint16_t wordByteLow( uint16_t x )
    {
        return static_cast<uint16_t>( x & 0x00FFU );
    }
    inline uint16_t wordMergeBytes( uint16_t h, uint16_t l )
    {
        return static_cast<uint16_t>( ( h << 8U ) | ( 0x00FFU & l ) );
    }
    inline uint32_t dWordWordHigh( uint32_t x )
    {
        return static_cast<uint32_t>( x >> 16U );
    }
    inline uint32_t dWordWordLow( uint32_t x )
    {
        return static_cast<uint32_t>( x & 0xFFFFU );
    }
    inline uint32_t dwordMergeWords( uint32_t h, uint32_t l )
    {
        return static_cast<uint32_t>( ( h << 16U ) | ( 0xFFFFU & l ) );
    }
 
}
 
#endif /*QOS_CPP_HELPER*/