cValT.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cValT_H
#define _INC_cValT_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "Index.h"
 
namespace Gray
{
        typedef int COMPARE_t;  
        enum COMPARE_TYPE
        {
                COMPARE_Less = -1,              
                COMPARE_Equal = 0,              
                COMPARE_Greater = 1,    
        };
 
        struct GRAYCORE_LINK cValT      // static. Value/Object of some type in memory.
        {
 
                template <class TYPE>
                static inline void Swap(TYPE& a, TYPE& b) noexcept
                {
                        register TYPE x = a;
                        a = b;
                        b = x;
                }
 
                template <class TYPE>
                static inline COMPARE_t Compare(const TYPE& a, const TYPE& b) noexcept
                {
                        if (a > b)
                                return COMPARE_Greater; // is greater than.
                        if (a == b)
                                return COMPARE_Equal;   // is equal.
                        return COMPARE_Less;    // must be less than.
                }
        };
 
        struct GRAYCORE_LINK cValArray  // static. array of Value of some TYPE.
        {
 
                template <class TYPE>
                static inline bool IsFilledQty(const TYPE* pArray, ITERATE_t nBlocks, TYPE nFillValue) noexcept
                {
                        for (ITERATE_t i = 0; i < nBlocks; i++)
                        {
                                if (pArray[i] != nFillValue)
                                        return false;
                        }
                        return true;
                }
                template <class TYPE>
                static inline bool IsFilledSize(const void* pArray, size_t nArraySizeBytes, TYPE nFillValue) noexcept
                {
                        return IsFilledQty((const TYPE*)pArray, (ITERATE_t)(nArraySizeBytes / sizeof(TYPE)), nFillValue);
                }
 
                template <class TYPE>
                static inline bool IsEqualQty(const TYPE* pArray1, const TYPE* pArray2, ITERATE_t nBlocks) noexcept
                {
                        for (ITERATE_t i = 0; i < nBlocks; i++)
                        {
                                if (pArray1[i] != pArray2[i])
                                        return false;
                        }
                        return true;
                }
 
                template <class TYPE>
                static inline COMPARE_t CompareQty(const TYPE* pArray1, const TYPE* pArray2, ITERATE_t nBlocks) noexcept
                {
                        for (ITERATE_t i = 0; i < nBlocks; i++)
                        {
                                if (pArray1[i] != pArray2[i])
                                        return (COMPARE_t)(pArray1[i] - pArray2[i]);
                        }
                        return COMPARE_Equal;
                }
 
                template <class TYPE>
                static inline void FillQty(TYPE* pArray, ITERATE_t nBlocks, TYPE nFillValue=0) noexcept
                {
 
                        for (ITERATE_t i = 0; i < nBlocks; i++)
                        {
                                pArray[i] = nFillValue;
                        }
                }
                template <class TYPE>
                static inline void ZeroQty(TYPE* pArray, ITERATE_t nBlocks) noexcept
                {
                        for (ITERATE_t i = 0; i < nBlocks; i++)
                        {
                                pArray[i] = 0;
                        }
                }
 
                template <class TYPE>
                static inline void FillSize(void* pArray, size_t nArraySizeBytes, TYPE nFillValue) noexcept
                {
                        FillQty((TYPE*)pArray, (ITERATE_t)(nArraySizeBytes / sizeof(TYPE)), nFillValue);
                }
 
                template <class TYPE>
                static inline void CopyQty(TYPE* pDst, const TYPE* pSrc, ITERATE_t nBlocks) noexcept
                {
                        for (ITERATE_t i = 0; i < nBlocks; i++)
                        {
                                pDst[i] = pSrc[i];
                        }
                }
 
                template <class TYPE>
                static inline void CopyQtyRev(TYPE* pDst, const TYPE* pSrc, ITERATE_t nBlocks) noexcept
                {
                        for (ITERATE_t i = nBlocks; i > 0;)
                        {
                                i--;
                                pDst[i] = pSrc[i];
                        }
                }
 
                template <class TYPE>
                static inline void ReverseArray(TYPE* pArray, size_t nArraySizeBytes) noexcept
                {
                        size_t nQty = nArraySizeBytes / sizeof(TYPE);
                        TYPE* pMemBS = pArray;
                        TYPE* pMemBE = pArray + (nQty - 1);
                        for (; pMemBS < pMemBE; pMemBS++, pMemBE--)
                        {
                                cValT::Swap<TYPE>(*pMemBS, *pMemBE);
                        }
                }
                static void GRAYCALL ReverseArrayBlocks(void* pArray, size_t nArraySizeBytes, size_t iBlockSize);
        };
 
        template <>
        inline void cValArray::FillQty<BYTE>(BYTE* pData, ITERATE_t nBlocks, BYTE bFill) noexcept // static
        {
                ::memset(pData, bFill, (size_t)nBlocks);
        }
        template <>
        inline void cValArray::FillSize<BYTE>(void* pData, size_t nSizeBlock, BYTE bFill) noexcept // static
        {
                ::memset(pData, bFill, nSizeBlock);
        }
}
 
#endif // _INC_cValT_H