home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 May / VPR9705A.ISO / VPR_DATA / PROGRAM / CBTRIAL / SETUP / DATA.Z / DSTRING.H < prev    next >
C/C++ Source or Header  |  1997-02-14  |  8KB  |  210 lines
  1. //---------------------------------------------------------------------------
  2. //    dstring.h - support for delphi strings in c++
  3. //                (AnsiString and template<sz> SmallString)
  4. //---------------------------------------------------------------------------
  5. // $Revision:   1.29  $
  6. //-------------------------------------------------------------------------
  7. //    copyright (c) 1997 Borland International
  8. //----------------------------------------------------------------------------
  9. #ifndef DSTRING_H
  10. #define DSTRING_H
  11.  
  12. //---------------------------------------------------------------------------
  13. // VCL files must be built with namespace option enabled to eliminate
  14. //     ambiguities such as Graphics and Windows TBitmap.
  15. //---------------------------------------------------------------------------
  16.  
  17. #include <iostream.h>
  18.  
  19. //---------------------------------------------------------------------------
  20. extern void __fastcall InitExe();
  21. //---------------------------------------------------------------------------
  22. // forward declarations
  23. namespace System
  24. {
  25.  
  26. class TVarRec;
  27. class __declspec(delphireturn) Currency;
  28. //---------------------------------------------------------------------------
  29. class __declspec(delphireturn) AnsiString
  30. {
  31.   friend AnsiString __fastcall operator +(const char*, const AnsiString& rhs);
  32.   public:
  33.     // the TStringFloatFormat enum is used by FloatToStrF
  34.     enum TStringFloatFormat
  35.       { sffGeneral, sffExponent, sffFixed, sffNumber, sffCurrency };
  36.     static AnsiString __fastcall StringOfChar(char ch, int count);
  37.     static AnsiString __fastcall LoadStr(int ident);
  38.     static AnsiString __fastcall FmtLoadStr(int ident, const TVarRec *args,
  39.       int size);
  40.     static AnsiString __fastcall Format(const AnsiString& format,
  41.       const TVarRec *args, int size);
  42.     static AnsiString __fastcall FormatFloat(const AnsiString& format,
  43.       const long double& value);
  44.     static AnsiString __fastcall FloatToStrF(long double value,
  45.       TStringFloatFormat format, int precision, int digits);
  46.     static AnsiString __fastcall IntToHex(int value, int digits);
  47.     static AnsiString __fastcall CurrToStr(Currency value);
  48.     static AnsiString __fastcall CurrToStrF(Currency value,
  49.       TStringFloatFormat format, int digits);
  50.  
  51.     // Constructors
  52.     __fastcall AnsiString(): Data(0) {}
  53.     __fastcall AnsiString(const char* src);
  54.     __fastcall AnsiString(const AnsiString& src);
  55.     __fastcall AnsiString(const char* src, unsigned char len);
  56.     __fastcall AnsiString(const wchar_t* src);
  57.     __fastcall AnsiString(char src);
  58.     __fastcall AnsiString(int src);
  59.     __fastcall AnsiString(double src);
  60.  
  61.     // Destructor
  62.     __fastcall ~AnsiString();
  63.  
  64.     // Assignments
  65.     AnsiString& __fastcall operator =(const AnsiString& rhs);
  66.     AnsiString& __fastcall operator +=(const AnsiString& rhs);
  67.  
  68.     //Comparisons
  69.     bool __fastcall operator ==(const AnsiString& rhs) const;
  70.     bool __fastcall operator !=(const AnsiString& rhs) const;
  71.     bool __fastcall operator <(const AnsiString& rhs) const;
  72.     bool __fastcall operator >(const AnsiString& rhs) const;
  73.     bool __fastcall operator <=(const AnsiString& rhs) const;
  74.     bool __fastcall operator >=(const AnsiString& rhs) const;
  75.     int __fastcall AnsiCompare(const AnsiString& rhs) const;
  76.     int __fastcall AnsiCompareIC(const AnsiString& rhs) const; //ignorecase
  77.  
  78.     // Index
  79.     char& __fastcall operator [](const int idx) {return Data[idx-1];}
  80.  
  81.     // Concatenation
  82.     AnsiString __fastcall operator +(const AnsiString& rhs) const;
  83.  
  84.     // C string operator
  85.     char* __fastcall c_str() const
  86.       {return (Data)? Data: "";}
  87.  
  88.     int __fastcall Length() const; 
  89.  
  90.     bool __fastcall IsEmpty() const;
  91.  
  92.     // make string unique (refcnt == 1)
  93.     void __fastcall Unique();
  94.  
  95.     void __fastcall Insert(const AnsiString& str, int index);
  96.     void __fastcall Delete(int index, int count);
  97.     void __fastcall SetLength(int newLength);
  98.  
  99.     int __fastcall Pos(const AnsiString& subStr) const;
  100.     AnsiString __fastcall LowerCase() const;
  101.     AnsiString __fastcall UpperCase() const;
  102.     AnsiString __fastcall Trim() const;
  103.     AnsiString __fastcall TrimLeft() const;
  104.     AnsiString __fastcall TrimRight() const;
  105.     AnsiString __fastcall SubString(int index, int count) const;
  106.  
  107.     int __fastcall ToInt() const;
  108.     int __fastcall ToIntDef(int defaultValue) const;
  109.     double __fastcall ToDouble() const;
  110.  
  111.     //Convert to Unicode
  112.     int __fastcall WideCharBufSize() const;
  113.     wchar_t* __fastcall WideChar(wchar_t* dest, int destSize) const;
  114.  
  115.     // mbcs support
  116.     enum TStringMbcsByteType { mbSingleByte, mbLeadByte, mbTrailByte };
  117.  
  118.     TStringMbcsByteType __fastcall ByteType(int index) const;
  119.     bool __fastcall IsLeadByte(int index) const;
  120.     bool __fastcall IsTrailByte(int index) const;
  121.     bool __fastcall IsDelimiter(const AnsiString& delimiters, int index) const;
  122.     bool __fastcall IsPathDelimiter(int index) const;
  123.     int __fastcall LastDelimiter(const AnsiString& delimiters) const;
  124.     int __fastcall AnsiPos(const AnsiString& subStr) const;
  125.     char* __fastcall AnsiLastChar() const;
  126.  
  127.   private:
  128.     char *Data;
  129. };
  130. //---------------------------------------------------------------------------
  131. AnsiString __fastcall operator +(const char*, const AnsiString& rhs);
  132. inline ostream& operator <<(ostream& os, const AnsiString& arg)
  133.   {os << arg.c_str(); return os;}
  134. istream& operator >>(istream& is, AnsiString& arg);
  135. //---------------------------------------------------------------------------
  136. template <unsigned char sz> class SmallString
  137. {
  138.   friend ostream& operator <<(ostream& os, const SmallString& arg)
  139.     {os << AnsiString(arg).c_str(); return os;}
  140.   friend istream& operator >>(istream& is, SmallString& arg)
  141.     {AnsiString s; is >> s; arg = s; return is;}
  142.   public:
  143.     // Constrctors
  144.     __fastcall SmallString(): Len(0) {}
  145.  
  146.     __fastcall SmallString(const char* src)
  147.     {
  148.     long len = strlen(src);
  149.       Len = (unsigned char)((len > sz)? sz: len);
  150.       strncpy(Data, src, Len);
  151.     }
  152.     __fastcall SmallString(const SmallString& src)
  153.     {
  154.       Len = src.Len;
  155.       for (int i = 0; i < Len; i++)
  156.         Data[i] = src.Data[i];
  157.     }
  158.     __fastcall SmallString(const AnsiString& src)
  159.     {
  160.       long len = src.Length();
  161.       Len = (unsigned char)((len > sz)? sz: len);
  162.       strncpy(Data, src.c_str(), Len);
  163.     }
  164.  
  165.     char& __fastcall operator [](const unsigned char idx)
  166.       {return Data[idx-1];}
  167.  
  168.     SmallString& __fastcall operator =(const SmallString& rhs);
  169.  
  170.     __fastcall operator AnsiString() const;
  171.  
  172.   protected:
  173.     unsigned char Len;
  174.     char Data[sz];
  175. };
  176. //---------------------------------------------------------------------------
  177. // used when SmallStrings are in unions (can't have a ctor)
  178. // must cast DummySmallString to SmallString to do anything useful
  179.  
  180. template <unsigned char sz> class DummySmallString
  181. {
  182.     protected:
  183.         unsigned char Len;
  184.         char Data[sz];
  185. };
  186. //---------------------------------------------------------------------------
  187. template<unsigned char sz> inline
  188. SmallString& __fastcall SmallString<sz>::operator =(const SmallString& rhs)
  189. {
  190.     if (this != &rhs)
  191.     {
  192.         Len = rhs.Len;
  193.         for (int i = 0; i < Len; i++)
  194.             Data[i] = rhs.Data[i];
  195.     }
  196.     return *this;
  197. }
  198. //---------------------------------------------------------------------------
  199. template<unsigned char sz> inline
  200. __fastcall SmallString<sz>::operator AnsiString() const
  201. {
  202.   return AnsiString(Data, Len);
  203. }
  204.  
  205. }
  206. using namespace System;
  207.  
  208. #endif
  209.  
  210.