home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Controls / Visual Basic Controls.iso / vbcontrol / sregexpf / smallstr.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-23  |  5.0 KB  |  283 lines
  1.  
  2. #ifndef sgSmallString_H
  3. #define sgSmallString_H
  4.  
  5. #ifdef __ATLBASE_H__  
  6.     inline HINSTANCE GetResInstance() { return _Module.GetResourceInstance(); }
  7. #else
  8.     extern HINSTANCE GetResInstance();
  9. #endif
  10.  
  11. class SString {
  12. public:
  13.     SString();
  14.     SString(const SString& s);
  15.     SString(LPCTSTR psz);
  16.     SString(int len, TCHAR c);
  17.     ~SString();
  18.  
  19.     bool        loadString(UINT id);
  20.     LPCTSTR    c_str() const            { return m_pData ? m_pData : _T(""); }
  21.     LPTSTR    getBuffer(int len);
  22.     void        releaseBuffer(int newLen = -1);
  23.     int        length() const            { return m_nStrLen; }
  24.     int        buffLength() const    { return m_nBuffLen; }
  25.     void        clear();
  26.     bool        empty() const            { return length() == 0; }
  27.     void        lower();
  28.     void        upper();
  29.  
  30.     const SString& operator = (const SString& s);
  31.     const SString& operator = (LPCTSTR psz);
  32.     const SString& operator = (TCHAR ch);
  33.     const SString& operator += (const SString& s);
  34.     const SString& operator += (LPCTSTR psz);
  35.     const SString& operator += (TCHAR ch);
  36.     const TCHAR&    operator [] (int index) const;
  37.     TCHAR&            operator [] (int index);
  38.  
  39.     const bool operator == (const SString& s) const;
  40.     const bool operator == (LPCTSTR psz) const;
  41.  
  42. private:
  43.     TCHAR* m_pData;
  44.     int    m_nBuffLen;
  45.     int    m_nStrLen;
  46.  
  47.     void    allocate(LPCTSTR psz, int len);
  48. };
  49.  
  50. SString operator + (const SString& s, LPCTSTR pszStr);
  51.  
  52. inline SString::SString()
  53. {
  54.     m_pData = 0;
  55.     m_nBuffLen = 0;
  56.     m_nStrLen = 0;
  57. }
  58.  
  59. inline SString::SString(const SString& s)
  60. {
  61.     m_pData = 0;
  62.     m_nBuffLen = 0;
  63.     m_nStrLen = 0;
  64.     *this = s;
  65. }
  66.  
  67. inline SString::SString(LPCTSTR psz)
  68. {
  69.     m_pData = 0;
  70.     m_nBuffLen = 0;
  71.     m_nStrLen = 0;
  72.     if (HIWORD(psz) == 0)
  73.         loadString(LOWORD(psz));
  74.     else
  75.         *this = psz;
  76. }
  77.  
  78. inline SString::SString(int len, TCHAR c)
  79. {
  80.     if (len < 0)
  81.         len = -len;
  82.     m_pData = new TCHAR[len+1];
  83.     if (m_pData != 0)
  84.     {
  85.         m_nBuffLen = len+1;
  86.         for (int i = 0; i < len; m_pData[i++] = c);
  87.         m_pData[len] = 0;
  88.         m_nStrLen = lstrlen(m_pData);
  89.     }
  90.     else
  91.     {
  92.         m_nBuffLen = 0;
  93.         m_nStrLen = 0;
  94.     }
  95. }
  96.  
  97. inline SString::~SString()
  98. {
  99.     clear();
  100. }
  101.  
  102. inline bool SString::loadString(UINT id)
  103. {
  104.     HINSTANCE hInst = GetResInstance();
  105.  
  106.     const nBuffSize = 256;
  107.     TCHAR szBuff[nBuffSize]; 
  108.     int nSize = LoadString(hInst, id, szBuff, nBuffSize);
  109.     if (nSize == 0)
  110.     {
  111.         clear();
  112.         return false;
  113.     }
  114.     allocate(szBuff, nSize+1);
  115.     return true;
  116. }
  117.  
  118. inline void SString::clear()
  119. {
  120.     delete m_pData;
  121.     m_pData = 0;
  122.     m_nBuffLen = 0;
  123.     m_nStrLen = 0;
  124. }
  125.  
  126. inline void SString::allocate(LPCTSTR psz, int len)
  127. {
  128.     clear();
  129.     m_pData = new TCHAR[len];
  130.     if (m_pData != 0)
  131.     {
  132.         m_pData[0] = 0;
  133.         m_nBuffLen = len;
  134.         m_nStrLen = 0;
  135.  
  136.         if (psz != 0)
  137.         {
  138.             lstrcpy(m_pData, psz);
  139.             m_nStrLen = lstrlen(m_pData);
  140.         }
  141.     }
  142. }
  143.  
  144. inline LPTSTR SString::getBuffer(int len)
  145. {
  146.     if (len > m_nBuffLen)
  147.         allocate(0, len);
  148.     if (len > 0)
  149.         memset(m_pData, 0, m_nBuffLen);
  150.     return m_pData;
  151. }
  152.  
  153. inline void SString::releaseBuffer(int newLen)
  154. {
  155.     if (m_pData == 0)
  156.         return;
  157.  
  158.     if (newLen == -1)
  159.     {
  160.         m_nStrLen = lstrlen(m_pData);
  161.     }
  162.     else if (newLen < m_nBuffLen)
  163.     {
  164.         m_pData[newLen] = 0;
  165.         m_nStrLen = newLen;
  166.     }
  167. }
  168.  
  169. inline void SString::lower()
  170. {
  171.     if (m_pData == 0)
  172.         return;
  173.     strlwr(m_pData);
  174. }
  175.  
  176. inline void SString::upper()
  177. {
  178.     if (m_pData == 0)
  179.         return;
  180.     strupr(m_pData);
  181. }
  182.  
  183. inline const SString& SString::operator = (const SString& s)
  184. {
  185.     if (this != &s)
  186.         allocate(s.c_str(), s.length() + 1);
  187.  
  188.     return *this;
  189. }
  190.  
  191. inline const SString& SString::operator = (LPCTSTR psz)
  192. {
  193.     if (psz == 0)
  194.         clear();
  195.     else
  196.     {
  197.         if (m_pData != psz)
  198.             allocate(psz, lstrlen(psz)+1);
  199.     }
  200.  
  201.     return *this;
  202. }
  203.  
  204. inline const SString& SString::operator = (TCHAR ch)
  205. {
  206.     TCHAR sz[2];
  207.     sz[0] = ch;
  208.     sz[1] = 0;
  209.     return operator=(sz);
  210. }
  211.  
  212. inline const bool SString::operator == (const SString& s) const
  213. {
  214.     return (lstrcmp(c_str(), s.c_str()) == 0) ? true : false;
  215. }
  216.  
  217. inline const bool SString::operator == (LPCTSTR psz) const
  218. {
  219.     if (psz == 0)
  220.         return false;
  221.  
  222.     return (lstrcmp(c_str(), psz) == 0) ? true : false;
  223. }
  224.  
  225. inline SString operator + (const SString& s, LPCTSTR pszStr)
  226. {
  227.     SString result(s);
  228.     result += pszStr;
  229.     return result;
  230. }
  231.  
  232. inline const SString& SString::operator += (const SString& s)
  233. {
  234.     return operator+=(s.c_str());
  235. }
  236.  
  237. inline const SString& SString::operator += (LPCTSTR psz)
  238. {
  239.     if (psz == 0)
  240.         return *this;
  241.  
  242.     int nLen = length() + lstrlen(psz);
  243.     if (nLen < buffLength())
  244.     {
  245.         lstrcat(m_pData, psz);
  246.     }
  247.     else
  248.     {
  249.         SString res(nLen + 1, 0);
  250.         res += c_str();
  251.         res += psz;
  252.         *this = res;
  253.     }
  254.     m_nStrLen = m_pData ? lstrlen(m_pData) : 0;
  255.     return *this;
  256. }
  257.  
  258. inline const SString& SString::operator += (TCHAR ch)
  259. {
  260.     TCHAR sz[2];
  261.     sz[0] = ch;
  262.     sz[1] = 0;
  263.     return operator+=(sz);
  264. }
  265.  
  266. inline const TCHAR& SString::operator [] (int index) const
  267. {
  268.     if ((index < 0) || (index >= m_nStrLen))
  269.         throw 0;
  270.  
  271.     return m_pData[index];
  272. }
  273.  
  274. inline TCHAR& SString::operator [] (int index)
  275. {
  276.     if ((index < 0) || (index >= m_nStrLen))
  277.         throw 0;
  278.  
  279.     return m_pData[index];
  280. }
  281.  
  282. #endif // sgSmallString_H
  283.