gstring.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:16k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _GSTRING_H
  36. #define _GSTRING_H
  37. /*******************************************************************************
  38.  * Defines
  39.  */
  40. #define GSTRING_REFMODE     TRUE
  41. #define GSTRING_VALMODE     FALSE
  42. /*******************************************************************************
  43.  * Includes
  44.  */
  45. #include <string.h>
  46. #include "hxtypes.h"
  47. #include "hxassert.h"
  48. #include "hxstrutl.h"
  49. /*******************************************************************************
  50.  * Class definition
  51.  */
  52. class GString
  53. {
  54. protected:
  55.     enum {kDefaultCapacity = 32,
  56.   kMinimumCapacity = 32,
  57.   kMaximumCapacity = 65536};
  58.     
  59.     char    *m_pszBuffer;
  60.     ULONG32  m_ulCapacity;
  61.     ULONG32  m_ulLength;
  62.     LONG32   m_lError;
  63.     BOOL     m_bRefMode;
  64.     
  65.     ULONG32 NextPowerOfTwo(ULONG32 ulX)
  66.     {
  67.         if (ulX > 0)
  68.         {
  69.             ulX--;
  70.         }
  71.         else
  72.         {
  73.             return 1;
  74.         }
  75.         ULONG32 i = 0;
  76.         while (ulX > 0)
  77.         {
  78.             ulX >>= 1;
  79.             i++;
  80.         }
  81.         return (1 << i);
  82.     };
  83. public:
  84.     enum {ErrorMemoryFull = -1,
  85.   ErrorNone       = 0};
  86.     GString() : m_pszBuffer(0L), m_ulCapacity(0), m_ulLength(0), m_lError(ErrorNone), m_bRefMode(FALSE) {};
  87.     
  88.     GString(ULONG32 ulCapacity)
  89. : m_bRefMode(FALSE)
  90.     {
  91.         if (ulCapacity < kMinimumCapacity)
  92.         {
  93.             ulCapacity = kMinimumCapacity;
  94.         }
  95.         else if (ulCapacity > kMaximumCapacity)
  96.         {
  97.             ulCapacity = kMaximumCapacity;
  98.         }
  99.         m_ulCapacity = m_ulLength = 0;
  100.         m_lError     = ErrorNone;
  101.         m_pszBuffer  = 0L;
  102.         if (ulCapacity > 0)
  103.         {
  104.             m_pszBuffer  = new char [ulCapacity];
  105.             if (m_pszBuffer)
  106.             {
  107.                 m_ulCapacity = ulCapacity;
  108.             }
  109.             else
  110.             {
  111.                 m_lError = ErrorMemoryFull;
  112.             }
  113.         }
  114.     };
  115.     
  116.     GString(const GString & rString)
  117.     {
  118.         m_lError     = ErrorNone;
  119. m_bRefMode = rString.m_bRefMode;
  120. if (m_bRefMode)
  121. {
  122.     m_pszBuffer = rString.m_pszBuffer;
  123.     m_ulCapacity = 0;
  124.     m_ulLength = rString.length();
  125.     m_bRefMode = TRUE;
  126. }
  127. else
  128. {
  129.     m_pszBuffer  = new char [rString.capacity()];
  130.     if (m_pszBuffer)
  131.     {
  132. strcpy(m_pszBuffer, rString.m_pszBuffer); /* Flawfinder: ignore */
  133. m_ulCapacity = rString.capacity();
  134. m_ulLength = rString.length();
  135.     }
  136.     else
  137.     {
  138. m_ulCapacity = 0;
  139. m_ulLength = 0;
  140. m_lError = ErrorMemoryFull;
  141.     }
  142. }
  143.     }
  144.     
  145.     GString(const char *pszString)
  146. : m_bRefMode(FALSE)
  147.     {
  148.         m_ulCapacity = m_ulLength = 0;
  149.         m_lError     = ErrorNone;
  150.         m_pszBuffer  = 0L;
  151.         ULONG32 ulCapacity = NextPowerOfTwo(strlen(pszString) + 1);
  152.         if (ulCapacity < kMinimumCapacity)
  153.         {
  154.             ulCapacity = kMinimumCapacity;
  155.         }
  156.         else if (ulCapacity > kMaximumCapacity)
  157.         {
  158.             ulCapacity = kMaximumCapacity;
  159.         }
  160.         m_pszBuffer = new char [ulCapacity];
  161.         if (m_pszBuffer)
  162.         {
  163.             strcpy(m_pszBuffer, pszString); /* Flawfinder: ignore */
  164.             m_ulCapacity = ulCapacity;
  165.             m_ulLength   = strlen(pszString);
  166.         }
  167.         else
  168.         {
  169.             m_lError = ErrorMemoryFull;
  170.         }
  171.     };
  172.     
  173.     GString(const char *pszString, LONG32 lLen, BOOL bRefMode = FALSE)
  174. : m_bRefMode(bRefMode)
  175.     {
  176. LONG32 strLen;
  177. char* tracer;
  178. m_ulCapacity = 0;
  179. m_lError = ErrorNone;
  180. if (m_bRefMode)
  181. {
  182.     m_pszBuffer = (char *) pszString;
  183. }
  184. else
  185. {
  186.     ULONG32 ulCapacity = NextPowerOfTwo(lLen + 1);
  187.     m_pszBuffer = 0L;
  188.     m_ulLength = 0;
  189.     if (ulCapacity < kMinimumCapacity)
  190.     {
  191. ulCapacity = kMinimumCapacity;
  192.     }
  193.     else if (ulCapacity > kMaximumCapacity)
  194.     {
  195. ulCapacity = kMaximumCapacity;
  196.     }
  197.     m_pszBuffer = new char [ulCapacity];
  198.     if (m_pszBuffer)
  199.     {
  200. strncpy(m_pszBuffer, pszString, lLen); /* Flawfinder: ignore */
  201. m_pszBuffer[lLen] = '';
  202. m_ulCapacity = ulCapacity;
  203.     }
  204.     else
  205.     {
  206. m_lError = ErrorMemoryFull;
  207. return;
  208.     }
  209. }
  210. for (strLen = 0, tracer = m_pszBuffer; strLen < lLen; strLen++, tracer++)
  211. {
  212.     if (*tracer == '')
  213.     {
  214. lLen = strLen;
  215.     }
  216. }
  217. m_ulLength = lLen;
  218.     };
  219.     ~GString()
  220.     {
  221.         if ((!m_bRefMode) && m_pszBuffer)
  222.         {
  223.             delete [] m_pszBuffer;
  224.         }
  225.     };
  226.     ULONG32 length()       const { return m_ulLength;   };
  227.     ULONG32 size()         const { return m_ulLength;   };
  228.     ULONG32 capacity()     const { return m_ulCapacity; };
  229.     ULONG32 max_capacity() const { return kMaximumCapacity; }
  230.     BOOL    empty()        const { return (m_ulLength == 0 ? TRUE : FALSE); };
  231.     LONG32  error()        const { return m_lError; };
  232.     LONG32  isref()        const { return m_bRefMode; }; 
  233.     
  234.     // c_str() const method is supported for bakward compatibility 
  235.     // with the code that expects this method to be const.
  236.     // The const method does not support reference mode (m_bRefMode).
  237.     const char *c_str()    const
  238.     {
  239. HX_ASSERT(!m_bRefMode);
  240. if (m_bRefMode)
  241. {
  242.     return NULL;
  243. }
  244. return m_pszBuffer;
  245.     }
  246.     const char *c_str()
  247.     {
  248. if (m_bRefMode)
  249. {
  250.     m_lError = reserve(m_ulLength + 1);
  251.     if (m_lError != ErrorNone)
  252.     {
  253. m_pszBuffer = NULL;
  254. m_ulCapacity = 0;
  255. m_ulLength = 0;
  256. m_lError = ErrorMemoryFull;
  257.     }
  258. }
  259. return m_pszBuffer;
  260.     }
  261.     LONG32 reserve(ULONG32 ulN)
  262.     {
  263.         if (ulN > m_ulCapacity)
  264.         {
  265.             ULONG32 ulCapacity = NextPowerOfTwo(ulN);
  266.             if (ulCapacity < kMinimumCapacity)
  267.             {
  268.                 ulCapacity = kMinimumCapacity;
  269.             }
  270.             else if (ulCapacity > kMaximumCapacity)
  271.             {
  272.                 ulCapacity = kMaximumCapacity;
  273.             }
  274.             char *pszTmp = 0L;
  275.             pszTmp       = new char [ulCapacity];
  276.             if (!pszTmp)
  277.             {
  278.                 return ErrorMemoryFull;
  279.             }
  280.             if (m_ulLength > ulCapacity)
  281.             {
  282.                 m_ulLength = ulCapacity - 1;
  283.             }
  284.             if (m_ulLength > 0)
  285.             {
  286.                 strncpy(pszTmp, m_pszBuffer, m_ulLength); /* Flawfinder: ignore */
  287. pszTmp[m_ulLength] = '';
  288.             }
  289.     if (!m_bRefMode)
  290.     {
  291. delete [] m_pszBuffer;
  292.     }
  293.             m_pszBuffer  = pszTmp;
  294.             m_ulCapacity = ulCapacity;
  295.     m_bRefMode = FALSE;
  296.         }
  297.         return ErrorNone;
  298.     };
  299.     GString & operator = (const GString &rString)
  300.     {
  301. if (rString.m_bRefMode)
  302. {
  303.     if (!m_bRefMode)
  304.     {
  305. delete [] m_pszBuffer;
  306.     }
  307.     m_pszBuffer = rString.m_pszBuffer;
  308.     m_ulLength = rString.m_ulLength;
  309.     m_ulCapacity = rString.m_ulCapacity;
  310.     m_bRefMode = TRUE;
  311. }
  312. else
  313. {
  314.     m_lError = reserve(rString.m_ulLength + 1);
  315.     if (m_lError == ErrorNone)
  316.     {
  317. strcpy(m_pszBuffer, rString.m_pszBuffer); /* Flawfinder: ignore */
  318. m_ulLength = rString.m_ulLength;
  319.     }
  320. }
  321.         return *this;
  322.     };
  323.     GString & operator = (const char *pszString)
  324.     {
  325.         if (pszString == NULL)
  326.         {
  327.             return *this;
  328.         }
  329.         m_lError = reserve(strlen(pszString) + 1);
  330.         if (m_lError == ErrorNone)
  331.         {
  332.             strcpy(m_pszBuffer, pszString); /* Flawfinder: ignore */
  333.             m_ulLength = strlen(pszString);
  334.         }
  335.         return *this;
  336.     };
  337.     GString & operator += (const GString &rString)
  338.     {
  339.         m_lError = reserve(m_ulLength + rString.m_ulLength + 1);
  340.         if (m_lError == ErrorNone)
  341.         {
  342.             strncat(m_pszBuffer, rString.m_pszBuffer, rString.m_ulLength); /* Flawfinder: ignore */
  343.             m_ulLength += rString.m_ulLength;
  344.         }
  345.         return *this;
  346.     };
  347.     GString & operator += (const char *pszString)
  348.     {
  349.         m_lError = reserve(m_ulLength + strlen(pszString) + 1);
  350.         if (m_lError == ErrorNone)
  351.         {
  352.             strcat(m_pszBuffer, pszString); /* Flawfinder: ignore */
  353.             m_ulLength += strlen(pszString);
  354.         }
  355.         return *this;
  356.     };
  357.     GString operator + (const GString &rString)
  358.     {
  359.         GString cTmp(*this);
  360.         cTmp += rString;
  361.         return cTmp;
  362.     };
  363.     GString operator + (const char *pszString)
  364.     {
  365.         GString cTmp(*this);
  366.         cTmp += pszString;
  367.         return cTmp;
  368.     };
  369.     BOOL operator == (const GString &rString)
  370.     {
  371.         return (((rString.m_ulLength != m_ulLength) ||
  372.          strncmp(m_pszBuffer, rString.m_pszBuffer, m_ulLength)) ? FALSE : TRUE);
  373.     };
  374.     BOOL operator == (const char *pszString)
  375.     {
  376.         return (((m_ulLength != strlen(pszString)) ||
  377.          strncmp(m_pszBuffer, pszString, m_ulLength)) ? FALSE : TRUE);
  378.     };
  379.     BOOL operator != (const GString &rString)
  380.     {
  381.         return (((m_ulLength != rString.m_ulLength) ||
  382.          strncmp(m_pszBuffer, rString.m_pszBuffer, m_ulLength)) ? TRUE : FALSE);
  383.     };
  384.     BOOL operator != (const char *pszString)
  385.     {
  386.         return (((m_ulLength != strlen(pszString)) ||
  387.          strncmp(m_pszBuffer, pszString, m_ulLength)) ? TRUE : FALSE);
  388.     };
  389.     const char & operator [] (LONG32 lPos) const
  390.     {
  391.         if (lPos < 0)
  392.         {
  393.             lPos = 0;
  394.         }
  395.         else if ((ULONG32) lPos > m_ulLength)
  396.         {
  397.             lPos = m_ulLength;
  398.         }
  399.         return m_pszBuffer[lPos];
  400.     };
  401.     LONG32 find(const char *pszString, LONG32 lPos = 0) const
  402.     {
  403. char *pSubStr;
  404. if (m_bRefMode)
  405. {
  406.     pSubStr = StrNStr(&m_pszBuffer[lPos], pszString, m_ulLength - lPos, kMaximumCapacity);
  407. }
  408. else
  409. {
  410.     pSubStr = strstr(&m_pszBuffer[lPos], pszString);
  411. }
  412.         LONG32 lRetVal;
  413.         if (pSubStr)
  414.         {
  415.             lRetVal = pSubStr - m_pszBuffer;
  416.         }
  417.         else
  418.         {
  419.             lRetVal = -1;
  420.         }
  421.         return lRetVal;
  422.     };
  423.     LONG32 find(const GString &rString, LONG32 lPos = 0) const
  424.     {
  425. char *pSubStr;
  426. if (m_bRefMode || rString.m_bRefMode)
  427. {
  428.     pSubStr = StrNStr(&m_pszBuffer[lPos], rString.m_pszBuffer, m_ulLength - lPos, rString.m_ulLength);
  429. }
  430. else
  431. {
  432.     pSubStr = strstr(&m_pszBuffer[lPos], rString.m_pszBuffer);
  433. }
  434.         LONG32 lRetVal;
  435.         if (pSubStr)
  436.         {
  437.             lRetVal = pSubStr - m_pszBuffer;
  438.         }
  439.         else
  440.         {
  441.             lRetVal = -1;
  442.         }
  443.         return lRetVal;
  444.     };
  445.     LONG32 find(char c, LONG32 lPos = 0) const
  446.     {
  447.         char *pSubStr;
  448. if (m_bRefMode)
  449. {
  450.     pSubStr = StrNChr(&m_pszBuffer[lPos], c, m_ulLength - lPos);
  451. }
  452. else
  453. {
  454.     pSubStr = strchr(&m_pszBuffer[lPos], c);
  455. }
  456.         LONG32 lRetVal;
  457.         if (pSubStr)
  458.         {
  459.             lRetVal = pSubStr - m_pszBuffer;
  460.         }
  461.         else
  462.         {
  463.             lRetVal = -1;
  464.         }
  465.         return lRetVal;
  466.     };
  467.     LONG32 find_last_of(char c) const
  468.     {
  469. char* pSubStr;
  470. if (m_bRefMode)
  471. {
  472.     pSubStr = StrNRChr(m_pszBuffer, c, m_ulLength);
  473. }
  474. else
  475. {
  476.     pSubStr = strrchr(m_pszBuffer, c);
  477. }
  478. LONG32 lRet;
  479.         if (pSubStr)
  480. {
  481.     lRet = pSubStr - m_pszBuffer;
  482. }
  483. else
  484. {
  485.     lRet = -1;
  486. }
  487.         return lRet;
  488.     };
  489.     LONG32 find_first_of(const char *pszString, LONG32 lPos = 0) const
  490.     {
  491. LONG32 lRet;
  492. if (m_bRefMode)
  493. {
  494.     lRet = StrNCSpn(&m_pszBuffer[lPos], pszString, m_ulLength - lPos, kMaximumCapacity);
  495. }
  496. else
  497. {
  498.     lRet = strcspn(&m_pszBuffer[lPos], pszString);
  499. }
  500.         return lRet + lPos;
  501.     };
  502.     LONG32 find_first_of(const GString &rString, LONG32 lPos = 0) const
  503.     {
  504. LONG32 lRet;
  505. if (m_bRefMode || rString.m_bRefMode)
  506. {
  507.     lRet = StrNCSpn(&m_pszBuffer[lPos], rString.m_pszBuffer, m_ulLength - lPos, rString.m_ulLength);
  508. }
  509. else
  510. {
  511.     lRet = strcspn(&m_pszBuffer[lPos], rString.m_pszBuffer);
  512. }
  513.         return lRet + lPos;
  514.     };
  515.     LONG32 find_first_of(char c, LONG32 lPos = 0) const
  516.     {
  517.         return find(c, lPos);
  518.     };
  519.     LONG32 find_first_not_of(const char *pszString, LONG32 lPos = 0) const
  520.     {
  521.         LONG32 lRet;
  522. if (m_bRefMode)
  523. {
  524.     lRet = StrNSpn(&m_pszBuffer[lPos], pszString, m_ulLength - lPos, kMaximumCapacity);
  525. }
  526. else
  527. {
  528.     lRet = strspn(&m_pszBuffer[lPos], pszString);
  529. }
  530.         return lRet + lPos;
  531.     };
  532.     LONG32 find_first_not_of(const GString &rString, LONG32 lPos = 0) const
  533.     {
  534. LONG32 lRet;
  535. if (m_bRefMode || rString.m_bRefMode)
  536. {
  537.     lRet = StrNSpn(&m_pszBuffer[lPos], rString.m_pszBuffer, m_ulLength - lPos, rString.m_ulLength);
  538. }
  539. else
  540. {
  541.     lRet = strspn(&m_pszBuffer[lPos], rString.m_pszBuffer);
  542. }
  543.         return lRet + lPos;
  544.     };
  545.     GString substr(LONG32 lPos, LONG32 rPos) const
  546.     {
  547.         if (lPos < 0) lPos = 0;
  548.         if ((ULONG32) lPos >= m_ulLength) lPos = m_ulLength - 1;
  549.         if (rPos < 0) rPos = 0;
  550.         if ((ULONG32) rPos >= m_ulLength) rPos = m_ulLength - 1;
  551.         if (rPos < lPos) rPos = lPos;
  552.         GString retStr(&m_pszBuffer[lPos], rPos - lPos + 1, m_bRefMode);
  553.         return retStr;
  554.     };
  555.     void CopyN(unsigned char *pBuffer, ULONG32 ulN)
  556.     {
  557.         m_lError = reserve(ulN + 1);
  558.         if (m_lError == ErrorNone)
  559.         {
  560.             strncpy(m_pszBuffer, (const char *) pBuffer, ulN); /* Flawfinder: ignore */
  561.             m_pszBuffer[ulN] = '';
  562.             m_ulLength = strlen(m_pszBuffer);
  563.         }
  564.     };
  565.     void LowerCase()
  566.     {
  567.         for (UINT32 i = 0; i < m_ulLength; i++)
  568.         {
  569.             char c = m_pszBuffer[i];
  570.             // If character is uppercase ASCII, convert to lowercase
  571.             if (c >= 65 && c <= 90)
  572.             {
  573.                 c             += 32;
  574.                 m_pszBuffer[i] = c;
  575.             }
  576.         }
  577.     };
  578.     void UpperCase()
  579.     {
  580.         for (UINT32 i = 0; i < m_ulLength; i++)
  581.         {
  582.             char c = m_pszBuffer[i];
  583.             // If character is lowercase ASCII, convert to uppercase
  584.             if (c >= 97 && c <= 122)
  585.             {
  586.                 c             -= 32;
  587.                 m_pszBuffer[i] = c;
  588.             }
  589.         }
  590.     };
  591. };
  592. #endif  // _GSTRING_H