hxstring.h
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:15k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxstring.h,v 1.9.28.3 2004/07/09 01:45:51 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #ifndef HXSTRING_H
  50. #define HXSTRING_H
  51. #include "hxtypes.h"
  52. #include "hxassert.h"
  53. #include "hlxclib/limits.h"
  54. #include "hlxclib/string.h"
  55. #if defined(HELIX_CONFIG_NOSTATICS)
  56. # include "globals/hxglobalchxstring.h"
  57. #endif
  58. typedef INT32 (*StringGrowthFunc)(INT32 currentSize, INT32 sizeNeeded);
  59. class CHXStringRep
  60. {
  61. public:
  62.     CHXStringRep(INT32 bufSize = 1, bool bSetLength = false);
  63.     CHXStringRep(const char* pStr);
  64.     CHXStringRep(const char* pStr, INT32 bufSize);
  65.     CHXStringRep(char ch, INT32 bufSize);
  66.     ~CHXStringRep();
  67.     
  68.     void AddRef();
  69.     void Release();
  70.     char* GetBuffer();
  71.     INT32 GetStringSize() const;
  72.     INT32 GetBufferSize() const;
  73.     
  74.     void SetStringSize(INT32 strSize);
  75.     void Resize(INT32 newSize);
  76.     void ResizeAndCopy(INT32 newSize, bool bSetLength = false);
  77.     
  78.     void Copy(const char* pStr, INT32 size);
  79.     bool IsShared() const;
  80. private:
  81.     CHXStringRep(const CHXStringRep&);
  82.     CHXStringRep& operator=(const CHXStringRep&);
  83.     INT32 m_refCount;
  84.     INT32 m_strSize;
  85.     INT32 m_bufSize;
  86.     char* m_pData;
  87. };
  88. class HXEXPORT_CLASS CHXString
  89. {
  90. public:
  91.     CHXString(StringGrowthFunc pGrowthFunc = 0);
  92.     CHXString(const CHXString& rhs);
  93.     CHXString(char ch, int length = 1, StringGrowthFunc pGrowthFunc = 0);
  94.     CHXString(const char* pStr, StringGrowthFunc pGrowthFunc = 0);
  95.     CHXString(const char* pStr, int length, StringGrowthFunc pGrowthFunc = 0);
  96.     CHXString(const unsigned char* pStr, StringGrowthFunc pGrowthFunc = 0);
  97.     ~CHXString();
  98.     // Attributes & Operations
  99.     // as an array of characters
  100.     UINT32 GetLength() const;
  101.     BOOL IsEmpty() const;
  102.     void Empty();
  103.     char GetAt(INT32 i) const;
  104.     char operator[](short i) const;
  105.     char operator[](unsigned short i) const;
  106.     char operator[](int i) const;
  107.     char operator[](unsigned int i) const;
  108.     char operator[](long i) const;
  109.     char operator[](unsigned long i) const;
  110.     void SetAt(INT32 i, char ch);
  111.     operator const char*() const;
  112.     bool operator>(const CHXString& rhs) const;
  113.     bool operator>(const char* pStr) const;
  114.     bool operator>(const unsigned char* pStr) const;
  115.     bool operator>=(const CHXString& rhs) const;
  116.     bool operator>=(const char* pStr) const;
  117.     bool operator>=(const unsigned char* pStr) const;
  118.     bool operator==(const CHXString& rhs) const;
  119.     bool operator==(const char* pStr) const;
  120.     bool operator==(const unsigned char* pStr) const;
  121.     bool operator!=(const CHXString& rhs) const;
  122.     bool operator!=(const char* pStr) const;
  123.     bool operator!=(const unsigned char* pStr) const;
  124.     bool operator<=(const CHXString& rhs) const;
  125.     bool operator<=(const char* pStr) const;
  126.     bool operator<=(const unsigned char* pStr) const;
  127.     bool operator<(const CHXString& rhs) const;
  128.     bool operator<(const char* pStr) const;
  129.     bool operator<(const unsigned char* pStr) const;
  130.     const CHXString& operator=(const CHXString& rhs);
  131.     const CHXString& operator=(char ch);
  132.     const CHXString& operator=(const char* pStr);
  133.     const CHXString& operator=(const unsigned char* pStr);
  134.     const CHXString& operator+=(const CHXString& rhs);
  135.     const CHXString& operator+=(char ch);
  136.     const CHXString& operator+=(const char* pStr);
  137.     friend CHXString  operator+(const CHXString& strA, 
  138.  const CHXString& strB);
  139.     friend CHXString  operator+(const CHXString& str, char ch);
  140.     friend CHXString  operator+(char ch , const CHXString& str);
  141.     friend CHXString  operator+(const CHXString& strA, const char* pStrB);
  142.     friend CHXString  operator+(const char* pStrA, const CHXString& strB);
  143.     INT32 Compare(const char* pStr) const;
  144.     INT32 CompareNoCase(const char* pStr) const;
  145.     void Center(short length);
  146.     CHXString Mid(INT32 i, INT32 length) const;
  147.     CHXString Mid(INT32 i) const;
  148.     CHXString Left(INT32 length) const;
  149.     CHXString Right(INT32 length) const;
  150.     
  151.     ULONG32 CountFields(char delim) const;
  152.     CHXString GetNthField(char delim, ULONG32 i, UINT64& state) const;
  153.     CHXString NthField(char delim, ULONG32 i) const;
  154.     CHXString SpanIncluding(const char* pCharSet) const;
  155.     CHXString SpanExcluding(const char* pCharSet) const;
  156.     void MakeUpper();
  157.     void MakeLower();
  158.     void TrimRight();
  159.     void TrimLeft();
  160.     INT32 Find(char ch) const;
  161.     INT32 ReverseFind(char ch) const;
  162.     BOOL FindAndReplace(const char* pSearch , const char* pReplace,
  163. BOOL bReplaceAll = FALSE);
  164.     INT32 Find(const char* pStr) const;
  165.     void Format(const char* pFmt, ...);
  166.     void AppendULONG(ULONG32 value);
  167.     void AppendEndOfLine();
  168.     char* GetBuffer(INT32 minSize);
  169.     void ReleaseBuffer(INT32 newSize = -1);
  170.     char* GetBufferSetLength(INT32 newSize);
  171.     void FreeExtra();
  172.     INT32 GetAllocLength() const;
  173.     INT32 SetMinBufSize(INT32 minSize);
  174. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  175.     const CHXString& SetFromStr255(const Str255 );
  176.     
  177.     const CHXString& AppendFromStr255(const Str255 );
  178.     const CHXString& InsertFromStr255(const Str255 );
  179.     
  180.     const CHXString& SetFromIndString(short , short );
  181.     
  182.     const CHXString& operator =(FSSpec );
  183.     operator const FSSpec(void);
  184.     
  185.     HX_RESULT MakeStr255(Str255& ) const;
  186. #if !defined(_CARBON) && !defined(_MAC_UNIX)
  187.     operator Str255* (void);
  188.     operator const Str255* (void) const;
  189.     operator ConstStr255Param (void) const;
  190. #else
  191.     const CHXString& operator =(const FSRef& );
  192.     // ConstStr255Param operator disallowed since
  193.     // it's not implemented in Carbon
  194.     //operator ConstStr255Param (void) const;
  195.     operator const FSRef(void);
  196.     const CHXString& operator =(CFStringRef );
  197.     
  198.     HX_RESULT SetFromCFString(CFStringRef , CFStringEncoding );
  199.     
  200.     HX_RESULT SetFromHFSUniStr255(const HFSUniStr255& , CFStringEncoding );
  201.     HX_RESULT MakeHFSUniStr255(HFSUniStr255& , CFStringEncoding ) const;
  202. #endif /* !defined(_CARBON) */
  203. #endif /* _MACINTOSH */
  204. protected:
  205.     void Init(const char* pStr, UINT32 size = UINT_MAX );
  206.     void Nuke();
  207.     void ConcatInPlace(const char* pStr, const UINT32 size);
  208.     void EnsureUnique(); // Make sure that m_pRep is not shared
  209.     void Release();
  210.     static UINT32 SafeStrlen(const char* );
  211. //#define CHXSMEMCHK
  212. #ifdef CHXSMEMCHK
  213.     INT32 m_memchkCopied;
  214.     INT32 m_memchkChanged;
  215.     INT32 m_memchkDataLength;
  216.     static INT32 g_memchkCopiedNotChanged;
  217.     static INT32 g_memchkCopiedChanged;
  218.     static INT32 g_memchkCounter;
  219.     static INT32 g_memchkHighCount;
  220.     static INT32 g_memchkTotalBytesNotChanged;
  221.     char*        m_memchkData;
  222.     static memchkWhatever Dummy;
  223.     static void memchkLogStats(void);
  224. #endif /* CHXSMEMCHK */
  225. private:
  226.     static INT32 MinimalGrowth(INT32 currentSize, INT32 sizeNeeded);
  227.     static INT32 DoublingGrowth(INT32 currentSize, INT32 sizeNeeded);
  228.     void Append(const char* pStr, INT32 size);
  229.     void Grow(INT32 newSize);
  230.     CHXStringRep* m_pRep;
  231.     StringGrowthFunc m_pGrowthFunc;
  232. };
  233. #if !defined(HELIX_CONFIG_NOSTATICS)
  234. extern const CHXString HXEmptyString;
  235. #else
  236. extern const char* const _g_emptyString;
  237. #define HXEmptyString HXGlobalCHXString::Get(&_g_emptyString)
  238. #endif
  239. inline
  240. char* CHXStringRep::GetBuffer()
  241. {
  242.     return m_pData;
  243. }
  244. inline
  245. INT32 CHXStringRep::GetStringSize() const
  246. {
  247.     return m_strSize;
  248. }
  249. inline
  250. INT32 CHXStringRep::GetBufferSize() const
  251. {
  252.     return m_bufSize;
  253. }
  254. inline
  255. void CHXStringRep::SetStringSize(INT32 strSize)
  256. {
  257.     HX_ASSERT(strSize >= 0);
  258.     HX_ASSERT(strSize < m_bufSize);
  259.     HX_ASSERT((size_t)strSize == strlen(m_pData));
  260.     m_strSize = strSize;
  261. }
  262. inline
  263. bool CHXStringRep::IsShared() const
  264. {
  265.     return (m_refCount > 1);
  266. }
  267. inline
  268. UINT32 CHXString::GetLength() const
  269. {
  270.     return (m_pRep) ? m_pRep->GetStringSize() : 0;
  271. }
  272. inline
  273. BOOL CHXString::IsEmpty() const
  274. {
  275.     return (GetLength() == 0);
  276. }
  277. inline
  278. char CHXString::GetAt(INT32 i) const
  279. {
  280.     HX_ASSERT(m_pRep);
  281.     HX_ASSERT(i >= 0);
  282.     HX_ASSERT(i < m_pRep->GetBufferSize());
  283.     return m_pRep->GetBuffer()[i];
  284. }
  285. inline
  286. char CHXString::operator[](short i) const
  287. {
  288.     HX_ASSERT(m_pRep);
  289.     HX_ASSERT(i >= 0);
  290.     HX_ASSERT(i < m_pRep->GetBufferSize());
  291.     return m_pRep->GetBuffer()[i];
  292. }
  293. inline
  294. char CHXString::operator[](unsigned short i) const
  295. {
  296.     HX_ASSERT(m_pRep);
  297.     HX_ASSERT((INT32)i < m_pRep->GetBufferSize());
  298.     return m_pRep->GetBuffer()[i];
  299. }
  300. inline
  301. char CHXString::operator[](int i) const
  302. {
  303.     HX_ASSERT(m_pRep);
  304.     HX_ASSERT(i >= 0);
  305.     HX_ASSERT(i < m_pRep->GetBufferSize());
  306.     return m_pRep->GetBuffer()[i];
  307. }
  308. inline
  309. char CHXString::operator[](unsigned int i) const
  310. {
  311.     HX_ASSERT(m_pRep);
  312.     HX_ASSERT(i < (unsigned int)m_pRep->GetBufferSize());
  313.     return m_pRep->GetBuffer()[i];
  314. }
  315. inline
  316. char CHXString::operator[](long i) const
  317. {
  318.     HX_ASSERT(m_pRep);
  319.     HX_ASSERT(i >= 0);
  320.     HX_ASSERT(i < m_pRep->GetBufferSize());
  321.     return m_pRep->GetBuffer()[i];
  322. }
  323. inline
  324. char CHXString::operator[](unsigned long i) const
  325. {
  326.     HX_ASSERT(m_pRep);
  327.     HX_ASSERT(i < (unsigned long)m_pRep->GetBufferSize());
  328.     return m_pRep->GetBuffer()[i];
  329. }
  330. inline
  331. CHXString::operator const char*() const
  332. {
  333.     return (m_pRep) ? m_pRep->GetBuffer() : (const char*)(&m_pRep);
  334. }
  335. inline
  336. INT32 CHXString::Compare(const char* pStr) const
  337. {
  338.     return strcmp((const char*)(*this), pStr);
  339. }
  340. inline
  341. INT32 CHXString::CompareNoCase(const char* pStr) const
  342. {
  343.     return strcasecmp((const char*)(*this), pStr);
  344. }
  345. inline
  346. bool CHXString::operator>(const char* pStr) const
  347. {
  348.     return (Compare(pStr) > 0);
  349. }
  350. inline
  351. bool CHXString::operator>(const CHXString& rhs) const
  352. {
  353.     return (*this > ((const char*)rhs));
  354. }
  355. inline
  356. bool CHXString::operator>(const unsigned char* pStr) const
  357. {
  358.     return (*this > ((const char*)pStr));
  359. }
  360. inline
  361. bool operator>(const char* pA, const CHXString& b)
  362. {
  363.     return (b < pA);
  364. }
  365. inline
  366. bool operator>(const unsigned char* pA, const CHXString& b)
  367. {
  368.     return (b < pA);
  369. }
  370. inline
  371. bool CHXString::operator>=(const char* pStr) const
  372. {
  373.     return (Compare(pStr) >= 0);
  374. }
  375. inline
  376. bool CHXString::operator>=(const CHXString& rhs) const
  377. {
  378.     return (*this >= ((const char*)rhs));
  379. }
  380. inline
  381. bool CHXString::operator>=(const unsigned char* pStr) const
  382. {
  383.     return (*this >= ((const char*)pStr));
  384. }    
  385. inline
  386. bool operator>=(const char* pA, const CHXString& b)
  387. {
  388.     return (b <= pA);
  389. }
  390. inline
  391. bool operator>=(const unsigned char* pA, const CHXString& b)
  392. {
  393.     return (b <= pA);
  394. }
  395. inline
  396. bool CHXString::operator==(const char* pStr) const
  397. {
  398.     return (strcmp(((const char*)*this), pStr) == 0);
  399. }
  400. inline
  401. bool CHXString::operator==(const CHXString& rhs) const
  402. {
  403.     return ((m_pRep == rhs.m_pRep) ||
  404.     ((GetLength() == rhs.GetLength()) &&
  405.      (*this == ((const char*)rhs))));
  406. }
  407. inline
  408. bool CHXString::operator==(const unsigned char* pStr) const
  409. {
  410.     return (*this == ((const char*)pStr));
  411. }
  412. inline
  413. bool operator==(const char* pA, const CHXString& b)
  414. {
  415.     return (b == pA);
  416. }
  417. inline
  418. bool operator==(const unsigned char* pA, const CHXString& b)
  419. {
  420.     return (b == pA);
  421. }
  422. inline
  423. bool CHXString::operator!=(const char* pStr) const
  424. {
  425.     return (strcmp(((const char*)*this), pStr) != 0);
  426. }
  427. inline
  428. bool CHXString::operator!=(const CHXString& rhs) const
  429. {
  430.     return ((m_pRep != rhs.m_pRep) &&
  431.     ((GetLength() != rhs.GetLength()) ||
  432.      (*this != ((const char*)rhs))));
  433. }
  434. inline
  435. bool CHXString::operator!=(const unsigned char* pStr) const
  436. {
  437.     return (*this != ((const char*)pStr));
  438. }
  439. inline
  440. bool operator!=(const char* pA, const CHXString& b)
  441. {
  442.     return (b != pA);
  443. }
  444. inline
  445. bool operator!=(const unsigned char* pA, const CHXString& b)
  446. {
  447.     return (b != pA);
  448. }
  449. inline
  450. bool CHXString::operator<=(const char* pStr) const
  451. {
  452.     return (Compare(pStr) <= 0);
  453. }
  454. inline
  455. bool CHXString::operator<=(const CHXString& rhs) const
  456. {
  457.     return (*this <= ((const char*)rhs));
  458. }
  459. inline
  460. bool CHXString::operator<=(const unsigned char* pStr) const
  461. {
  462.     return (*this <= ((const char*)pStr));
  463. }    
  464. inline
  465. bool operator<=(const char* pA, const CHXString& b)
  466. {
  467.     return (b >= pA);
  468. }
  469. inline
  470. bool operator<=(const unsigned char* pA, const CHXString& b)
  471. {
  472.     return (b >= pA);
  473. }
  474. inline
  475. bool CHXString::operator<(const char* pStr) const
  476. {
  477.     return (Compare(pStr) < 0);
  478. }
  479. inline
  480. bool CHXString::operator<(const CHXString& rhs) const
  481. {
  482.     return (*this < ((const char*)rhs));
  483. }
  484. inline
  485. bool CHXString::operator<(const unsigned char* pStr) const
  486. {
  487.     return (*this < ((const char*)pStr));
  488. }
  489. inline
  490. bool operator<(const char* pA, const CHXString& b)
  491. {
  492.     return (b > pA);
  493. }
  494. inline
  495. bool operator<(const unsigned char* pA, const CHXString& b)
  496. {
  497.     return (b > pA);
  498. }
  499. inline
  500. UINT32 CHXString::SafeStrlen(const char* pStr)
  501. {
  502.     return (pStr) ? strlen(pStr) : 0;
  503. }
  504. #endif /* HXSTRING_H */