gstring.h

linux下的一款播放器

	    {
		delete [] m_pszBuffer;
	    }

	    m_pszBuffer = rString.m_pszBuffer;
	    m_ulLength = rString.m_ulLength;
	    m_ulCapacity = rString.m_ulCapacity;
	    m_bRefMode = TRUE;
	}
	else
	{
	    m_lError = reserve(rString.m_ulLength + 1);
	    if (m_lError == ErrorNone)
	    {
		strcpy(m_pszBuffer, rString.m_pszBuffer); /* Flawfinder: ignore */
		m_ulLength = rString.m_ulLength;
	    }
	}

        return *this;
    };

    GString & operator = (const char *pszString)
    {
        if (pszString == NULL)
        {
            return *this;
        }
        m_lError = reserve(strlen(pszString) + 1);
        if (m_lError == ErrorNone)
        {
            strcpy(m_pszBuffer, pszString); /* Flawfinder: ignore */
            m_ulLength = strlen(pszString);
        }

        return *this;
    };

    GString & operator += (const GString &rString)
    {
        m_lError = reserve(m_ulLength + rString.m_ulLength + 1);
        if (m_lError == ErrorNone)
        {
            strncat(m_pszBuffer, rString.m_pszBuffer, rString.m_ulLength); /* Flawfinder: ignore */
            m_ulLength += rString.m_ulLength;
        }

        return *this;
    };

    GString & operator += (const char *pszString)
    {
        m_lError = reserve(m_ulLength + strlen(pszString) + 1);
        if (m_lError == ErrorNone)
        {
            strcat(m_pszBuffer, pszString); /* Flawfinder: ignore */
            m_ulLength += strlen(pszString);
        }

        return *this;
    };

    GString operator + (const GString &rString)
    {
        GString cTmp(*this);
        cTmp += rString;
        return cTmp;
    };

    GString operator + (const char *pszString)
    {
        GString cTmp(*this);
        cTmp += pszString;
        return cTmp;
    };

    BOOL operator == (const GString &rString)
    {
        return (((rString.m_ulLength != m_ulLength) ||
	         strncmp(m_pszBuffer, rString.m_pszBuffer, m_ulLength)) ? FALSE : TRUE);
    };

    BOOL operator == (const char *pszString)
    {
        return (((m_ulLength != strlen(pszString)) ||
	         strncmp(m_pszBuffer, pszString, m_ulLength)) ? FALSE : TRUE);
    };

    BOOL operator != (const GString &rString)
    {
        return (((m_ulLength != rString.m_ulLength) ||
	         strncmp(m_pszBuffer, rString.m_pszBuffer, m_ulLength)) ? TRUE : FALSE);
    };

    BOOL operator != (const char *pszString)
    {
        return (((m_ulLength != strlen(pszString)) ||
	         strncmp(m_pszBuffer, pszString, m_ulLength)) ? TRUE : FALSE);
    };

    const char & operator [] (LONG32 lPos) const
    {
        if (lPos < 0)
        {
            lPos = 0;
        }
        else if ((ULONG32) lPos > m_ulLength)
        {
            lPos = m_ulLength;
        }
        return m_pszBuffer[lPos];
    };

    LONG32 find(const char *pszString, LONG32 lPos = 0) const
    {
	char *pSubStr;

	if (m_bRefMode)
	{
	    pSubStr = StrNStr(&m_pszBuffer[lPos], pszString, m_ulLength - lPos, kMaximumCapacity);
	}
	else
	{
	    pSubStr = strstr(&m_pszBuffer[lPos], pszString);
	}

        LONG32 lRetVal;
        if (pSubStr)
        {
            lRetVal = pSubStr - m_pszBuffer;
        }
        else
        {
            lRetVal = -1;
        }

        return lRetVal;
    };

    LONG32 find(const GString &rString, LONG32 lPos = 0) const
    {
	char *pSubStr;

	if (m_bRefMode || rString.m_bRefMode)
	{
	    pSubStr = StrNStr(&m_pszBuffer[lPos], rString.m_pszBuffer, m_ulLength - lPos, rString.m_ulLength);
	}
	else
	{
	    pSubStr = strstr(&m_pszBuffer[lPos], rString.m_pszBuffer);
	}

        LONG32 lRetVal;
        if (pSubStr)
        {
            lRetVal = pSubStr - m_pszBuffer;
        }
        else
        {
            lRetVal = -1;
        }

        return lRetVal;
    };

    LONG32 find(char c, LONG32 lPos = 0) const
    {
        char *pSubStr;
	
	if (m_bRefMode)
	{
	    pSubStr = StrNChr(&m_pszBuffer[lPos], c, m_ulLength - lPos);
	}
	else
	{
	    pSubStr = strchr(&m_pszBuffer[lPos], c);
	}

        LONG32 lRetVal;
        if (pSubStr)
        {
            lRetVal = pSubStr - m_pszBuffer;
        }
        else
        {
            lRetVal = -1;
        }

        return lRetVal;
    };

    LONG32 find_last_of(char c) const
    {
	char* pSubStr;
	
	if (m_bRefMode)
	{
	    pSubStr = StrNRChr(m_pszBuffer, c, m_ulLength);
	}
	else
	{
	    pSubStr = strrchr(m_pszBuffer, c);
	}

	LONG32 lRet;
        if (pSubStr)
	{
	    lRet = pSubStr - m_pszBuffer;
	}
	else
	{
	    lRet = -1;
	}

        return lRet;
    };

    LONG32 find_first_of(const char *pszString, LONG32 lPos = 0) const
    {
	LONG32 lRet;

	if (m_bRefMode)
	{
	    lRet = StrNCSpn(&m_pszBuffer[lPos], pszString, m_ulLength - lPos, kMaximumCapacity);
	}
	else
	{
	    lRet = strcspn(&m_pszBuffer[lPos], pszString);
	}

        return lRet + lPos;
    };

    LONG32 find_first_of(const GString &rString, LONG32 lPos = 0) const
    {
	LONG32 lRet;

	if (m_bRefMode || rString.m_bRefMode)
	{
	    lRet = StrNCSpn(&m_pszBuffer[lPos], rString.m_pszBuffer, m_ulLength - lPos, rString.m_ulLength);
	}
	else
	{
	    lRet = strcspn(&m_pszBuffer[lPos], rString.m_pszBuffer);
	}

        return lRet + lPos;
    };

    LONG32 find_first_of(char c, LONG32 lPos = 0) const
    {
        return find(c, lPos);
    };

    LONG32 find_first_not_of(const char *pszString, LONG32 lPos = 0) const
    {
        LONG32 lRet;
	
	if (m_bRefMode)
	{
	    lRet = StrNSpn(&m_pszBuffer[lPos], pszString, m_ulLength - lPos, kMaximumCapacity);
	}
	else
	{
	    lRet = strspn(&m_pszBuffer[lPos], pszString);
	}

        return lRet + lPos;
    };

    LONG32 find_first_not_of(const GString &rString, LONG32 lPos = 0) const
    {
	LONG32 lRet;
	
	if (m_bRefMode || rString.m_bRefMode)
	{
	    lRet = StrNSpn(&m_pszBuffer[lPos], rString.m_pszBuffer, m_ulLength - lPos, rString.m_ulLength);
	}
	else
	{
	    lRet = strspn(&m_pszBuffer[lPos], rString.m_pszBuffer);
	}

        return lRet + lPos;
    };

    GString substr(LONG32 lPos, LONG32 rPos) const
    {
        if (lPos < 0) lPos = 0;
        if ((ULONG32) lPos >= m_ulLength) lPos = m_ulLength - 1;
        if (rPos < 0) rPos = 0;
        if ((ULONG32) rPos >= m_ulLength) rPos = m_ulLength - 1;
        if (rPos < lPos) rPos = lPos;

        GString retStr(&m_pszBuffer[lPos], rPos - lPos + 1, m_bRefMode);

        return retStr;
    };

    void CopyN(unsigned char *pBuffer, ULONG32 ulN)
    {
        m_lError = reserve(ulN + 1);
        if (m_lError == ErrorNone)
        {
            strncpy(m_pszBuffer, (const char *) pBuffer, ulN); /* Flawfinder: ignore */
            m_pszBuffer[ulN] = '\0';
            m_ulLength = strlen(m_pszBuffer);
        }
    };

    void LowerCase()
    {
        for (UINT32 i = 0; i < m_ulLength; i++)
        {
            char c = m_pszBuffer[i];

            // If character is uppercase ASCII, convert to lowercase
            if (c >= 65 && c <= 90)
            {
                c             += 32;
                m_pszBuffer[i] = c;
            }
        }
    };

    void UpperCase()
    {
        for (UINT32 i = 0; i < m_ulLength; i++)
        {
            char c = m_pszBuffer[i];

            // If character is lowercase ASCII, convert to uppercase
            if (c >= 97 && c <= 122)
            {
                c             -= 32;
                m_pszBuffer[i] = c;
            }
        }
    };
};

#endif  // _GSTRING_H