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