it_bus/FWStringHelp.h

#if !defined(IT_Bus_FWSTRINGHELP_INCLUDED_)
#define IT_Bus_FWSTRINGHELP_INCLUDED_

#include <stdio.h>

#include <it_bus/api_defines.h>

#include <it_dsa/string.h>


#if defined(_WIN32)
    #define strncasecmp _strnicmp
    #define strcasecmp _stricmp
    #define wcsncasecmp _wcsnicmp
    #define snprintf _snprintf
    #define vsnprintf _vsnprintf
#endif


    inline bool IsBlank(const char* strValue)
    {
        if (strValue == NULL)
            return true;

        long lStringLen = strlen(strValue);

        if (lStringLen == 0)
            return true; //zero length string 

        for(long lIndex = 0; lIndex < lStringLen; lIndex++)
        {
            if (strValue[lIndex] != ' ')
                return false;  //found a non-space char, not empty
        }

        return true; //spaces only
    }

    class IT_AFC_API CCountedString
    {
    protected:
        long* m_plRefCount;
        char* m_szData;

    public:
        CCountedString()
        {
            m_plRefCount = new long(1);
            m_szData = NULL;
        }

        CCountedString(const CCountedString& cs)
        {
            m_plRefCount = cs.m_plRefCount;
            m_szData = cs.m_szData;
            (*m_plRefCount)++;
        }

        CCountedString(const char* sz)
        {
            m_plRefCount = new long(1);
            m_szData = NULL;
            Alloc(strlen(sz));
            strcpy(m_szData,sz);
        }

        bool operator==(const char* val)
        {
            if ( (m_szData == NULL) || (val == NULL) )
                                return (val == m_szData);

            return (0 == strcmp(val, m_szData));
        }

        bool operator!=(const char* val)
        {
            if ( (m_szData == NULL) || (val == NULL) )
                                return (val != m_szData);

            return (0 != strcmp(val, m_szData));
        }


        bool operator==(const size_t p)
        {
            return ((char*)p == m_szData);
        }

        bool operator!=(const size_t p)
        {
            return ((char*)p != m_szData);
        }

         operator bool()
        {
            return (m_szData != NULL);
        }

        CCountedString& operator = (const CCountedString& cs)
        {
            if ( (*m_plRefCount) > 1)
            {
                throw;
            }

            if (m_szData != NULL)
                delete [] m_szData;

            delete m_plRefCount;

            m_plRefCount = cs.m_plRefCount;
            m_szData = cs.m_szData;
            (*m_plRefCount)++;

            return *this;
        }

        const char* operator = (const char* sz)
        {
            Alloc(strlen(sz));
            strcpy(m_szData,sz);
            return m_szData;
        }


        ~CCountedString()
        {
            if (m_plRefCount == NULL)
                return; 

            (*m_plRefCount)--;
            if (0 == (*m_plRefCount))
            {
                if (m_szData != NULL)
                    delete [] m_szData;

                delete m_plRefCount;
            }
        }

        void Alloc(unsigned long lSize)
        {
            if (m_szData != NULL)
            {
                if ( (*m_plRefCount) > 1)
                    throw;

                delete [] m_szData;
            }

            m_szData = new char[lSize + 1];
        }

        operator char*()
        {
            return m_szData;
        }
    
        operator const char*() const
        {
            return m_szData;
        }

        char* At(long dwPosition)
        {
            if (m_szData != NULL)
                return &m_szData[dwPosition];
    
            return NULL;
        }

        void Realloc(unsigned long lSize)
        {
            if (m_szData == NULL)
                Alloc(lSize);
            else
            {
                if ( (*m_plRefCount) > 1)
                    throw;

                char* szLocalData = new char[lSize + 1];
                strcpy(szLocalData, m_szData);
                
                delete [] m_szData;
                m_szData = szLocalData;
            }
        }

        long GetSize()
        {
            if (m_szData == NULL)
                return 0;
            else
                return strlen(m_szData);
        }
    };


/* valid mask values for NET_Escape() and NET_EscapedSize(). */
typedef enum {
    url_XAlphas        = (1<<0)
,    url_XPAlphas    = (1<<1)
,    url_Path        = (1<<2)
} nsEscapeMask;

const int netCharType[256] =
/*    Bit 0        xalpha        -- the alphas
**    Bit 1        xpalpha        -- as xalpha but 
**                             converts spaces to plus and plus to %20
**    Bit 3 ...    path        -- as xalphas but doesn't escape '/'
*/
    /*   0 1 2 3 4 5 6 7 8 9 A B C D E F */
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,    /* 0x */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,    /* 1x */
    0,0,0,0,0,0,0,0,0,0,7,0,0,7,7,4,    /* 2x   !"#$%&'()*+,-./     */  //changed entry for + from 4 to 0
    7,7,7,7,7,7,7,7,7,7,0,0,0,0,0,0,    /* 3x  0123456789:;<=>?     */
    0,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,    /* 4x  @ABCDEFGHIJKLMNO  */
    /* bits for '@' changed from 7 to 0 so '@' can be escaped   */
    /* in usernames and passwords in publishing.                */
    7,7,7,7,7,7,7,7,7,7,7,0,0,0,0,7,    /* 5X  PQRSTUVWXYZ[\]^_     */
    0,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,    /* 6x  `abcdefghijklmno     */
    7,7,7,7,7,7,7,7,7,7,7,0,0,0,0,0,    /* 7X  pqrstuvwxyz{\}~    DEL */
    0, 
};

/* decode % escaped hex codes into character values
 */
#define UNHEX(C) \
    ((C >= '0' && C <= '9') ? C - '0' : \
    ((C >= 'A' && C <= 'F') ? C - 'A' + 10 : \
    ((C >= 'a' && C <= 'f') ? C - 'a' + 10 : 0)))

#define IS_OK(C) (netCharType[((unsigned int) (C))] & (mask))

#define HEX_ESCAPE '%'

//----------------------------------------------------------------------------------------
inline bool URLEscapeCount(const char * str, long len, nsEscapeMask mask, long* out_len, char* result)
//----------------------------------------------------------------------------------------
{
    if (!str)
        return false;

    bool bCalcSize = ((NULL != out_len) && (*out_len == 0));

    int i;
    register const unsigned char* src = (const unsigned char *) str;
    const char* hexChars = "0123456789ABCDEF";

    if (bCalcSize)
    {
        int extra = 0;

        for (i = 0; i < len; i++)
        {
            if (!IS_OK(*src))
            {
                if (!( (mask > url_XAlphas) && (*src == ' ') )) //space doesn't get escaped when mask > url_XAlphas
                    extra += 2; /* the escape, plus an extra byte for each nibble */
            }
            src++;
        }

        *out_len = len + extra;
    }

    if (NULL == result)
        return true;

    register unsigned char* dst = (unsigned char *) result;
    src = (const unsigned char *) str;
    if (mask > url_XAlphas)
    {
        for (i = 0; i < len; i++)
        {
            unsigned char c = *src++;
            if (IS_OK(c))
                *dst++ = c;
            else if (c == ' ')
                *dst++ = '+'; /* convert spaces to pluses */
            else 
            {
                *dst++ = HEX_ESCAPE;
                *dst++ = hexChars[c >> 4];    /* high nibble */
                *dst++ = hexChars[c & 0x0f];    /* low nibble */
            }
        }
    }
    else
    {
        for (i = 0; i < len; i++)
        {
            unsigned char c = *src++;
            if (IS_OK(c))
                *dst++ = c;
            else 
            {
                *dst++ = HEX_ESCAPE;
                *dst++ = hexChars[c >> 4];    /* high nibble */
                *dst++ = hexChars[c & 0x0f];    /* low nibble */
            }
        }
    }

    return true;
}

//----------------------------------------------------------------------------------------
inline void URLEscape(const char * str, nsEscapeMask mask, long* out_len, char* result)
//----------------------------------------------------------------------------------------
{
    if(!str)
        return;

    URLEscapeCount(str, (long)strlen(str), mask, out_len, result);
}


//this unescapes the urlencoding.  It can be done in place, i.e., (result == str is valid)
//it does not use null-terminated strings.
//----------------------------------------------------------------------------------------
inline bool URLUnescapeCount(char * str, long len, nsEscapeMask mask, long* out_len, char* result)
//----------------------------------------------------------------------------------------
{
    if (!str)
        return false;

    bool bCalcSize = ((NULL != out_len) && (*out_len == 0));

  register char* src = str;
  register char* dst = result;

    if (bCalcSize)
    {
        int i = 0;
        *out_len = len;

        while(i < len)
        {
            if ( (src[i] == HEX_ESCAPE) && (i + 2 < len) )
            {
                *out_len -= 2;
                i+=3;
            }
            else 
                i++;
        }
    }

    if (NULL == result)
        return true;

    char* end = src + len;
  while (src < end)
        if ( (*src == '+') && (mask > url_XAlphas) )
        {
      *dst = ' ';
            dst++;
            src++;
        }
    else if (*src != HEX_ESCAPE)
      *dst++ = *src++;
    else     
        {
      src++; /* walk over escape */
      if (*src)
      {
        *dst = UNHEX(*src) << 4;
        src++;
      }

      if (*src)
      {
        *dst = (*dst + UNHEX(*src));
        src++;
      }
      dst++;
    }

  *out_len = (dst - result);
  
    return true;
} 

//----------------------------------------------------------------------------------------
inline bool URLUnescape(char * str, nsEscapeMask mask, long* out_len, char* result)
//----------------------------------------------------------------------------------------
{
    return URLUnescapeCount(str, strlen(str), mask, out_len, result);
}

//----------------------------------------------------------------------------------------
inline bool URLUnescapeInPlace(char * str, nsEscapeMask mask, long* out_len, char* /*result*/)
//----------------------------------------------------------------------------------------
{
    return URLUnescape(str, mask, out_len, str);
}



inline long FindAnyLineBreak(const char* szData, long lIndex, long lSize)
{
    const char* p = szData;

    if (lIndex > lSize)
        return -1;

    long lLastPos = lSize - 2;

    for(long lPos = lIndex; lPos <= lLastPos; lPos++)
    {
        if ( (p[lPos] == '\r') && (p[lPos + 1] == '\n') )
            return lPos;

        if ( (p[lPos] == '\n') && (p[lPos + 1] == '\r') )
            return lPos;

        if ( (p[lPos] == '\r') && (p[lPos + 1] == '\r') )
            return lPos;

        if ( (p[lPos] == '\n') && (p[lPos + 1] == '\n') )
            return lPos;
    }

    return -1;
}



inline IT_String Left(const char* szSource, long dwLength)
{
    if (dwLength == 0)
        return "";

    long lLength = strlen(szSource);

    if ( dwLength >= lLength )
        return szSource;

    return IT_String(szSource, dwLength);
}

inline IT_String Right(const char* szSource, long dwLength)
{
    if (dwLength == 0)
        return "";

    long lLength = strlen(szSource);

    if ( dwLength >= lLength )
        return szSource;

    const char* szStart = szSource;

    long dwIndex = lLength - dwLength;

    szStart+=dwIndex;

    return IT_String(szStart, dwLength);
}

inline IT_String Mid(const char* szSource, long dwIndex, long dwLength = -1)
{
    if (dwLength == 0)
        return "";

    long lLength = strlen(szSource);

    if ( (dwLength == -1) || (dwLength > lLength - dwIndex) )
        dwLength = lLength - dwIndex;

    const char* szStart = szSource + dwIndex;
    
    return IT_String(szStart, dwLength);
}

inline IT_String Hex(long dwValue)
{
    char szHex[16];
    sprintf(szHex, "%lx", dwValue);

    return IT_String(szHex);
}


inline IT_String Trim(const char* sz)
{
    if (sz == NULL)
        return "";

    long lLength = strlen(sz);
    const char* szBegin = sz;
    const char* szEnd = &szBegin[lLength - 1];

    if ((*szBegin != ' ') && (*szEnd != ' ') )
        return sz;

    long dwStrip = 0;

    while (*szBegin == ' ')
    {
        szBegin++;
        dwStrip++;
    }

    while ( (szEnd > szBegin) && (*szEnd == ' ') )
    {
        szEnd--;
        dwStrip++;
    }

    return IT_String(szBegin, lLength - dwStrip);
}


inline IT_String LTrim(const char* sz)
{
    if (sz == NULL)
        return "";

    long lLength = strlen(sz);

    const char* szBegin = sz;

    if (*szBegin != ' ')
        return sz;

    long dwStrip = 0;
    while (*szBegin == ' ')
    {
        szBegin++;
        dwStrip++;
    }

    return IT_String(szBegin, lLength - dwStrip);
}

inline char FirstChar(const char* szSource, bool bSkipBlanks = true)
{
    if ( IsBlank(szSource) )
        return 0;

    if (bSkipBlanks)
    {
        IT_String strSource = LTrim(strSource.c_str());

        if ( strSource.empty() )
            return 0;

        return ((strSource.c_str())[0]);
    }
    else
        return (szSource[0]);
}


inline IT_String EscapeSequence(const char* szInput, char wc, const char* szEscapeSequence)
{
    if (IsBlank(szInput))
        return "";

    long dwInputLen = strlen(szInput);
    long dwInputIdx = 0;

    char sz[2];
    sz[0] = 0;
    sz[1] = 0;

    IT_String strEscaped = "";

    while ( ( dwInputIdx < dwInputLen ) )
    {
        if (szInput[dwInputIdx] == wc)
        {
            strEscaped = strEscaped + szEscapeSequence;
        }
        else
        {
            sz[0] = szInput[dwInputIdx];
            strEscaped = strEscaped + sz;
        }
        dwInputIdx++;
    }

    return strEscaped;
}



    
    inline bool IsFuzzyEqual(const char* str1, const char* str2)
    {
        //this function test case and whitespace insensitive 

        if (str1 == str2)
            return true;

        const char* szLocal1 = 0;
        unsigned long iSize1 = 0;
        if (str1 != NULL)
        {
            szLocal1 = str1;
                
            //get rid of leading spaces
            while(*szLocal1 == ' ')
                szLocal1++;

            //get rid of trailing spaces
            if (*szLocal1 != 0)
            {
                const char* szLocal1End = szLocal1 + strlen(szLocal1) - 1;

                while ( *szLocal1End == ' ')
                    --szLocal1End;

                ++szLocal1End;

                iSize1 = (szLocal1End - szLocal1);
            }
        }

        const char* szLocal2 = 0;
        unsigned long iSize2 = 0;
        if (str2 != NULL)
        {
            szLocal2 = str2;
            
            while(*szLocal2 == ' ')
                ++szLocal2;

            if (*szLocal2 != 0)
            {
                const char* szLocal2End = szLocal2 + strlen(szLocal2) - 1;

                while ( *szLocal2End == ' ')
                    --szLocal2End;

                ++szLocal2End;

                iSize2 = (szLocal2End - szLocal2);
            }
        }

        if (iSize1 != iSize2)
            return false;

        if ((szLocal1==0) || (iSize1==0))
            return ((szLocal2==0) || (iSize2==0));

        if ((szLocal2==0) || (iSize2==0))
            return ((szLocal1==0) || (iSize1==0));

        return (strncasecmp(szLocal1,szLocal2,iSize1) == 0);
    }

    
#endif

---