TnbStrLib.h

[詳解]

#pragma once
#include "TnbDef.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
#include <stdlib.h>
#include <WinNls.h>
 
 
 
//TNB Library
namespace TNB {
namespace STRLIB 
{
 
    inline size_t GetLen(LPCSTR lpsz)
    {
        size_t r = 0;
        LPCSTR P = lpsz;
        if ( P != NULL )
        {
            while ( *P++ != 0 )
            {
                r++;
            }
            ASSERTLIB(r == strlen(lpsz));
        }
        return r;
    }
 
    inline size_t GetLen(LPCWSTR lpsz)
    {
        size_t r = 0;
        LPCWSTR P = lpsz;
        if ( P != NULL )
        {
            while ( *P++ != 0 )
            {
                r++;
            }
            ASSERTLIB(r == wcslen(lpsz));
        }
        return r;
    }
 
    inline void Copy(LPSTR _dst, LPCSTR src)
    {
        ASSERT(! ::IsBadWritePtr(_dst, GetLen(src)));
        do
        {
            *_dst = *src++;
        }
        while ( *_dst++ != 0 );
    }
 
    inline void Copy(LPWSTR _dst, LPCWSTR src)
    {
        ASSERT(! ::IsBadWritePtr(_dst, GetLen(src) * sizeof(WCHAR)));
        do
        {
            *_dst = *src++;
        }
        while ( *_dst++ != 0 );
    }
 
    inline int Compare(LPCSTR P1, LPCSTR P2, INT_PTR len = -1, DWORD dwCmpFlags = 0)
    {
        if ( P2 == NULL ){ P2 = ""; }
        int l = ToInt(len);
        #ifndef _WIN32_WCE
            return ::CompareStringA(LOCALE_USER_DEFAULT, dwCmpFlags, P1, l, P2, l) - CSTR_EQUAL;
        #else
            DWORD f = NORM_IGNOREKANATYPE | NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS;
            if ( (dwCmpFlags & f) != 0 )
            {
                ASSERT0(false, "STRLIB::Compare()", "一部のフラグは無視されます");
            }
            if ( (dwCmpFlags & NORM_IGNORECASE) != 0 )
            {
                return (l < 0) ? ::_stricmp(P1, P2) : ::_strnicmp(P1, P2, l);
            }
            return (l < 0) ? ::strcmp(P1, P2) : ::strncmp(P1, P2, l);
        #endif
    }
 
    inline int Compare(LPCWSTR P1, LPCWSTR P2, INT_PTR len = -1, DWORD dwCmpFlags = 0)
    {
        if ( P2 == NULL ){ P2 = L""; }
        int l = ToInt(len);
        return ::CompareStringW(LOCALE_USER_DEFAULT, dwCmpFlags, P1, l, P2, l) - CSTR_EQUAL;
    }
 
    inline INT_PTR IndexOf(LPCSTR lpszText, char c, INDEX iFromIndex = 0)
    {
        LPCSTR P = ::strchr(&lpszText[iFromIndex], c);
        return (P == NULL) ? (-1) : (P - lpszText);
    }
 
    inline INT_PTR IndexOf(LPCWSTR lpszText, WCHAR c, INDEX iFromIndex = 0)
    {
        LPCWSTR P = ::wcschr(&lpszText[iFromIndex], c);
        return (P == NULL) ? (-1) : (P - lpszText);
    }
 
    inline INT_PTR IndexOneOf(LPCSTR lpszText, LPCSTR lpszMark, INDEX iFromIndex = 0)
    {
        size_t l = GetLen(&lpszText[iFromIndex]);
        size_t r = ::strcspn(&lpszText[iFromIndex], lpszMark);
        return (r >= l) ? -1 : r + iFromIndex;
    }
 
    inline INT_PTR IndexOneOf(LPCWSTR lpszText, LPCWSTR lpszMark, INDEX iFromIndex = 0)
    {
        size_t l = GetLen(&lpszText[iFromIndex]);
        size_t r = ::wcscspn(&lpszText[iFromIndex], lpszMark);
        return (r >= l) ? -1 : r + iFromIndex;
    }
 
    inline INT_PTR ReverseIndexOf(LPCSTR lpszText, char c)
    {
        LPCSTR P = ::strrchr(lpszText, c);
        return (P == NULL) ? (-1) : (P - lpszText);
    }
 
    inline INT_PTR ReverseIndexOf(LPCWSTR lpszText, char c)
    {
        LPCWSTR P = ::wcsrchr(lpszText, c);
        return (P == NULL) ? (-1) : (P - lpszText);
    }
 
    inline INT_PTR IndexOf(LPCSTR lpszText, LPCSTR lpszWord, INDEX iFromIndex = 0)
    {
        LPCSTR P = strstr(&lpszText[iFromIndex], lpszWord);
        return (P == NULL) ? (-1) : (P - lpszText);
    }
 
    inline INT_PTR IndexOf(LPCWSTR lpszText, LPCWSTR lpszWord, INDEX iFromIndex = 0)
    {
        LPCWSTR P = wcsstr(&lpszText[iFromIndex], lpszWord);
        return (P == NULL) ? (-1) : (P - lpszText);
    }
 
    inline INT_PTR PathIndexOf(LPCSTR lpszText)
    {
        INT_PTR p1 = ReverseIndexOf(lpszText, '\\');
        INT_PTR p2 = ReverseIndexOf(lpszText, '/');
        return (p1 < p2) ? p2 : p1;
    }
 
    inline INT_PTR PathIndexOf(LPCWSTR lpszText)
    {
        INT_PTR p1 = ReverseIndexOf(lpszText, '\\');
        INT_PTR p2 = ReverseIndexOf(lpszText, '/');
        return (p1 < p2) ? p2 : p1;
    }
 
    inline int GetCharSize(char c)
    {
        return ::IsDBCSLeadByte(c) ? 2 : 1;
    }
 
    inline int GetCharSize(WCHAR c)
    {
        return 1; 
    }
 
    inline int ToInt(LPCSTR lpsz, int iBase = 10) 
    {
        return strtol(lpsz, NULL, iBase);
    }
 
    inline int ToInt(LPCWSTR lpsz, int iBase = 10)
    {
        return wcstol(lpsz, NULL, iBase); 
    }
 
    inline DWORD ToDword(LPCSTR lpsz, int iBase = 10)
    {
        return strtoul(lpsz, NULL, iBase);
    }
 
    inline DWORD ToDword(LPCWSTR lpsz, int iBase = 10)
    {
        return wcstoul(lpsz, NULL, iBase);
    }
 
    inline double ToDouble(LPCSTR lpsz) 
    {
        return strtod(lpsz, NULL); 
    }
 
    inline double ToDouble(LPCWSTR lpsz) 
    { 
        return wcstod(lpsz, NULL); 
    }
 
    inline LONGLONG ToLonglong(LPCSTR lpsz)
    {
        return _atoi64(lpsz); 
    }
 
    inline LONGLONG ToLonglong(LPCWSTR lpsz)
    {
        return _wtoi64(lpsz);
    }
 
    inline bool IsAsciiOnly(LPCSTR lpsz)
    {
        while ( *lpsz != 0 )
        {
            if ( GetCharSize(*lpsz++) != 1 )
            {
                return false;// ASCII以外発見
            }
        }
        return true;
    }
 
    inline int HexCharToInt(int c)
    {
        int r = -1;
        if ( c >= 'a' && c <= 'f' )
        {
            r = (c - 'a') + 10;
        }
        else if ( c >= 'A' && c <= 'F' )
        {
            r = (c - 'A') + 10;
        }
        else if ( c >= '0' && c <= '9' )
        {
            r = c - '0';
        }
        return r;
    }
 
    inline char IntToHexChar(int c)
    {
        return "0123456789ABCDEF"[c & 0x000F];
    }
 
    template<typename TYP>
    inline int EscCharToInt(const TYP*& _lpsz)
    {
        if ( *_lpsz != '\\' ){ return -1; }
        int r = -1;
        const TYP* P = _lpsz;
        P++;
        TYP c = *P++;
        switch ( c )
        {
        case 't':   // タブ文字
            r = '\t';
            break;
        case 'n':   // 改行文字
            r = '\n';
            break;
        case 'r':   // キャリッジリターン
            r = '\r';
            break;
        case 'e':
            r = '\x1B';
            break;
        case '\\':
            r = '\\';
            break;
        case 'x':   // \xhh     16進数値を持つ文字
        case 'u':   // \uhhhh   16進数値を持つ文字
            loop( i, (c == 'x') ? 2 : 4 )
            {
                int c = STRLIB::HexCharToInt(*P);
                if ( c < 0 ) { break; }
                if ( r < 0 ) { r = 0; }
                r *= 16;
                r += c;
                P++;
            }
            break;
        case '0':
            if ( *P >= '0' && *P <= '9' )
            {
                loop ( i, 3 )
                {
                    if ( *P < '0' || *P > '7' ) { break; }
                    if ( r < 0 ) { r = 0; }
                    r *= 8;
                    r += (*P - '0');
                    P++;
                }
            }
            break;
        default:
            break;
        }
        if ( r >= 0 )
        {
            _lpsz = P;
        }
        return r;
    }
 
}; // STRLIB
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")