StrChar.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_StrChar_H
#define _INC_StrChar_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cUnitTestDecl.h"
#include "cValT.h"
 
#ifdef _WIN32
#include <wtypes.h>     // BSTR
 
#elif defined(__linux__)
#include <wchar.h>      // wcslen()
#else
 
#error NOOS
#endif
 
namespace Gray
{
        typedef WORD RADIX_t;           
 
#ifdef _WIN32
        typedef UINT CODEPAGE_t;        
#else
        enum CODEPAGE_t
        {
                CP_ACP = 0,           
                CP_OEMCP = 1,           
                CP_UTF8 = 65001,       
        };
#endif
 
        struct GRAYCORE_LINK StrChar // static
        {
 
                static const char k_BEL = '\a';         
                static const char k_BS = '\b';          
                static const char k_HT = '\t';          
                static const char k_NL = '\n';          
                static const char k_VT = '\v';          
                static const char k_FF = '\f';          
                static const char k_CR = '\r';          
 
                // Other C escape chars are "\'\"\?\\"
 
                static const char k_Space = ' ';                
                static const char k_ASCII = 127;        
 
                static const RADIX_t k_uRadixMin = 2;           
                static const RADIX_t k_uRadixDef = 10;          
                static const RADIX_t k_uRadixMax = 10 + 26;     
 
                static const char k_Vowels[5];  
 
                static constexpr bool IsAscii(wchar_t ch) noexcept
                {
                        return ((unsigned)ch) <= k_ASCII;
                }
 
                static constexpr bool IsPrint(wchar_t ch) noexcept
                {
                        return ch >= k_Space && ch < k_ASCII;
                }
                static inline bool IsAlNum(wchar_t ch) noexcept
                {
                        return IsAlphaA(ch) || IsDigit(ch);
                }
 
                // single space, tab, vertical tab, form feed, carriage return, or newline
                static inline bool IsNL(wchar_t ch) noexcept
                {
                        return ch == k_NL || ch == k_CR;
                }
                static inline bool IsSpace(wchar_t ch) noexcept
                {
                        return ch == k_HT || ch == k_Space;
                }
                static inline bool IsSpaceX(wchar_t ch) noexcept
                {
 
                        return ch == k_Space || (ch >= k_BS && ch <= k_CR);
                }
 
                static inline bool IsDigit(wchar_t ch) noexcept
                {
                        return ch >= '0' && ch <= '9';
                }
                static inline bool IsUpperA(wchar_t ch) noexcept
                {
                        return  ch >= 'A' && ch <= 'Z';
                }
                static inline bool IsLowerA(wchar_t ch) noexcept
                {
                        return ch >= 'a' && ch <= 'z';
                }
                static inline bool IsAlphaA(wchar_t ch) noexcept
                {
                        return IsUpperA(ch) || IsLowerA(ch);
                }
 
                static const BYTE k_AXU = 0xC0;         
                static const BYTE k_AXL = 0xE0;         
 
                // Is upper case in extended ASCII, NOT UTF8
                static inline bool IsUpperAXSet(wchar_t ch) noexcept
                {
                        return ((unsigned)ch) >= k_AXU && ((unsigned)ch) <= 0xDF;
                }
                static inline bool IsLowerAXSet(wchar_t ch) noexcept
                {
                        return ((unsigned)ch) >= k_AXL && ((unsigned)ch) <= 0xFF;
                }
 
                static inline bool IsAlphaUSet(wchar_t ch) noexcept
                {
                        return ((unsigned)ch) >= 0x100 && ((unsigned)ch) <= 0x1FF;
                }
                static inline bool IsUpperUSet(wchar_t ch) noexcept
                {
                        return IsAlphaUSet(ch) && (ch & 1) == 0;
                }
                static inline bool IsLowerUSet(wchar_t ch) noexcept
                {
                        return IsAlphaUSet(ch) && (ch & 1) == 1;
                }
 
                static inline bool IsUpperAX(wchar_t ch) noexcept
                {
                        return IsUpperA(ch) || IsUpperAXSet(ch);
                }
                static inline bool IsLowerAX(wchar_t ch) noexcept
                {
                        return IsLowerA(ch) || IsLowerAXSet(ch);
                }
 
                static inline bool IsUpper(wchar_t ch) noexcept
                {
                        if (IsAscii(ch))
                        {
                                return IsUpperA(ch);
                        }
                        return IsUpperAXSet(ch) || IsUpperUSet(ch);
                }
                static inline bool IsLower(wchar_t ch) noexcept
                {
                        if (IsAscii(ch))
                        {
                                return IsLowerA(ch);
                        }
                        return IsLowerAXSet(ch) || IsLowerUSet(ch);
                }
 
                static inline bool IsAlpha(wchar_t ch) noexcept
                {
                        return IsLowerAX(ch) || IsUpperAX(ch) || IsAlphaUSet(ch);
                }
                static inline bool IsCSymF(wchar_t ch) noexcept
                {
                        return IsAlphaA(ch) || ch == '_';
                }
                static inline bool IsCSym(wchar_t ch) noexcept
                {
                        return IsAlphaA(ch) || ch == '_' || IsDigit(ch);
                }
 
                static inline wchar_t ToUpperA(wchar_t ch) noexcept
                {
                        if (IsLowerA(ch))
                                return ((ch)-'a') + 'A';
                        return ch;
                }
                static inline wchar_t ToUpperW(wchar_t ch) noexcept
                {
                        if (IsAscii(ch))
                        {
                                if (IsLowerA(ch))
                                        return ((ch)-'a') + 'A';
                        }
                        else
                        {
                                if (IsLowerAXSet(ch))
                                        return ((ch)-k_AXL) + k_AXU;
                                if (IsLowerUSet(ch))
                                        return (wchar_t)(ch + 1);
                        }
                        return ch;
                }
                static inline wchar_t ToLowerA(wchar_t ch) noexcept
                {
                        if (IsUpperA(ch))
                                return ((ch)-'A') + 'a';
                        return ch;
                }
                static inline wchar_t ToLowerW(wchar_t ch) noexcept
                {
                        if (IsAscii(ch))
                        {
                                if (IsUpperA(ch))
                                        return ((ch)-'A') + 'a';
                        }
                        else
                        {
                                if (IsUpperAXSet(ch))
                                        return ((ch)-k_AXU) + k_AXL;
                                else if (IsUpperUSet(ch))
                                        return (wchar_t)(ch - 1);
                        }
                        return ch;
                }
 
                static inline COMPARE_t CmpI(char a, char b) noexcept
                {
                        if (a == b)
                                return 0;
                        wchar_t ch1 = ToLowerA(a);
                        wchar_t ch2 = ToLowerA(b);
                        return ch1 - ch2;
                }
 
                static inline COMPARE_t CmpI(wchar_t a, wchar_t b) noexcept
                {
                        if (a == b)
                                return 0;
                        wchar_t ch1 = ToLowerW(a);
                        wchar_t ch2 = ToLowerW(b);
                        return ch1 - ch2;
                }
 
                static inline int Dec2U(wchar_t ch) noexcept
                {
                        // ASSERT(ch>='0'&&ch<=??);
                        return(ch - '0');
                }
 
                static bool GRAYCALL IsDigitF(wchar_t ch);
                static bool GRAYCALL IsDigitX(wchar_t ch, RADIX_t uRadix = 0x10);
                static bool GRAYCALL IsVowel(wchar_t ch);
                static char GRAYCALL U2Hex(UINT uVal);
                static int  GRAYCALL Hex2U(wchar_t ch);
                static char GRAYCALL U2Radix(UINT uVal, RADIX_t uRadix = 10);
                static int GRAYCALL Radix2U(wchar_t ch, RADIX_t uRadix = 10);
 
                UNITTEST_FRIEND(StrChar);
        };
}
#endif // StrChar