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