cTypes.h

Go to the documentation of this file.

//
//
#ifndef _INC_cTypes_H
#define _INC_cTypes_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "GrayCore.h"
#include <math.h>               // isnan()
 
namespace Gray
{
        enum CTYPE_FLAG_TYPE_
        {
                CTYPE_FLAG_Numeric = 0x01,      
                CTYPE_FLAG_NumSigned = 0x02,    
                CTYPE_FLAG_Float = 0x04,        
                CTYPE_FLAG_Time = 0x08,         
                CTYPE_FLAG_Array = 0x10,        
                CTYPE_FLAG_Alloc = 0x20,        
                CTYPE_FLAG_StringA = 0x40,      
                CTYPE_FLAG_StringW = 0x80,      
                CTYPE_FLAG_UNUSED = 0xFF,       
        };
 
        // like _WIN32 MAKELPARAM(), MAKELONG() and MAKEWORD()
#define MAKEDWORD(low, high)    ((UINT32)(((WORD)(low)) | (((UINT32)((WORD)(high))) << 16)))
 
#pragma pack(push,1)
        union CATTR_PACKED cUnion16
        {
                BYTE  u_b[2];
                char  u_c[2];
                WORD  u_w;      
                short u_s;
                operator WORD() const noexcept
                {
                        return u_w;
                }
                void operator = (WORD w) noexcept
                {
                        u_w = w;
                }
                struct
                {
#ifdef USE_LITTLE_ENDIAN
                        BYTE m_Lo;      // LowPart
                        BYTE m_Hi;      // HighPart
#else
                        BYTE m_Hi;
                        BYTE m_Lo;
#endif
                } u2;
        };
 
        union CATTR_PACKED cUnion32
        {
 
                BYTE u_b[4];
                char u_c[4];
                signed char u_sc[4];
                WORD  u_w[2];   
                short u_s[2];   
                UINT32 u_dw;    
                float u_f;              
 
                operator UINT32() const noexcept
                {
                        return u_dw;
                }
                void operator = (UINT32 dw) noexcept
                {
                        u_dw = dw;
                }
 
                struct
                {
#ifdef USE_LITTLE_ENDIAN
                        cUnion16 m_Lo;  // LowPart
                        cUnion16 m_Hi;  // HighPart
#else
                        cUnion16 m_Hi;
                        cUnion16 m_Lo;
#endif
                } u2;
        };
 
        union CATTR_PACKED cUnion64
        {
 
                BYTE u_b[8];            
                char u_c[8];
                signed char u_sc[8];
                WORD  u_w[4];           
                short  u_s[4];          
                UINT32 u_dw[2];         
                float u_f[2];   
                double u_d;             
 
#ifdef USE_INT64
                UINT64 u_qw;            
                INT64 u_iq;                     
                operator UINT64() const noexcept
                {
                        return u_qw;
                }
                void operator = (UINT64 qw) noexcept
                {
                        u_qw = qw;
                }
#endif
 
                struct
                {
#ifdef USE_LITTLE_ENDIAN
                        cUnion32 m_Lo;  // LowPart
                        cUnion32 m_Hi;  // HighPart
#else
                        cUnion32 m_Hi;
                        cUnion32 m_Lo;
#endif
                } u2;
        };
 
        // __m128
 
#pragma pack(pop)
 
        template< typename TYPE = int >
        struct cTypeLimit       // static
        {
                static const TYPE k_Min;                
                static const TYPE k_Max;                
                static const BYTE k_TypeFlags;  
 
                static inline bool isNumSigned() noexcept
                {
                        return (k_TypeFlags & CTYPE_FLAG_NumSigned) ? true : false;
                }
 
                // TODO Use StrNum
                // TYPE FromString(const char* pszInp);
                // StrLen_t ToString(char* pszOut, TYPE val);
        };
 
#ifdef _MSC_VER         // M$ this is not a redundant define.
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h)  template<> const _TYPE cTypeLimit<_TYPE>::k_Min = e; template<> const _TYPE cTypeLimit<_TYPE>::k_Max = f; const BYTE cTypeLimit<_TYPE>::k_TypeFlags = (c);
#include "cTypes.tbl"
#undef CTYPE_DEF
#endif  // _MSC_VER
 
        struct GRAYCORE_LINK cTypeFloat
        {
 
                template< typename TYPE >
                static inline bool IsNaN(TYPE a) noexcept
                {
                        // return !(a >= 0 || a < 0);
                        return ::isnan(a); // k_NaN ! #NAN or #IND #INF similar to _isnan() but it works.
                }
 
                template< typename TYPE >
                static inline bool IsInfinite(TYPE a)
                {
                        return ::isinf(a);      // k_InfPos, k_InfNeg
                }
 
                template< typename TYPE >
                static inline bool IsFinite(TYPE a) noexcept
                {
                        // return !IsNaN(a) && !IsInfinite(a);
                        return a == 0 || ::isnormal(a); // ! #NAN or #IND #INF/INFINITY similar to ! _isnan() but it works.
                }
        };
} 
 
#endif