home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Vcl / dstring.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  13KB  |  384 lines
  1. // DSTRING.H - Support for delphi strings in C++
  2. //            (AnsiString and template<sz> SmallString)
  3. // $Revision:   1.33.1.3  $
  4. // $Date:   14 Dec 1999 17:58:10  $
  5. //
  6. // Copyright (c) 1997, 1999 Borland International
  7.  
  8. #ifndef DSTRING_H
  9. #define DSTRING_H
  10.  
  11. #pragma delphiheader begin
  12.  
  13. #include <sysmac.h>
  14. #include <stdarg.h>
  15.  
  16.  
  17. namespace System
  18. {
  19.   class                  TVarRec;
  20.   class RTL_DELPHIRETURN Currency;
  21.   class RTL_DELPHIRETURN WideString;
  22.  
  23.   /////////////////////////////////////////////////////////////////////////////
  24.   // AnsiString: String class compatible with Delphi's Native 'string' type
  25.   /////////////////////////////////////////////////////////////////////////////
  26.   class RTL_DELPHIRETURN AnsiString
  27.   {
  28.     friend AnsiString __fastcall operator +(const char*, const AnsiString& rhs);
  29.   public:
  30.     // the TStringFloatFormat enum is used by FloatToStrF
  31.     enum TStringFloatFormat
  32.     {sffGeneral, sffExponent, sffFixed, sffNumber, sffCurrency};
  33.     static AnsiString __fastcall StringOfChar(char ch, int count);
  34.     static AnsiString __fastcall LoadStr(int ident);
  35.     static AnsiString __fastcall LoadStr(HINSTANCE hInstance, int ident);
  36.     static AnsiString __fastcall FmtLoadStr(int ident, const TVarRec *args,
  37.                         int size);
  38.  
  39.     AnsiString& __fastcall       LoadString(HINSTANCE hInstance, int ident);
  40.  
  41.     // Delphi style 'Format'
  42.     //
  43.     static AnsiString __fastcall Format(const AnsiString& format,
  44.                       const TVarRec *args, int size);
  45.  
  46.     // C style 'sprintf' (NOTE: Target buffer is the string)
  47.     //
  48.     AnsiString& __cdecl         sprintf(const char* format, ...); // Returns *this
  49.     int         __cdecl          printf(const char* format, ...); // Returns formatted length
  50.     int         __cdecl         vprintf(const char* format, va_list); // Returns formatted length
  51.  
  52.  
  53.     // Like above, but appends to the string rather than overwrite
  54.     AnsiString& __cdecl     cat_sprintf(const char* format, ...); // Returns *this
  55.     int         __cdecl     cat_printf(const char* format, ...); // Returns formatted length
  56.     int         __cdecl     cat_vprintf(const char* format, va_list); // Returns formatted length
  57.  
  58.     static AnsiString __fastcall FormatFloat(const AnsiString& format,
  59.                          const long double& value);
  60.     static AnsiString __fastcall FloatToStrF(long double value,
  61.                          TStringFloatFormat format, int precision, int digits);
  62.     static AnsiString __fastcall IntToHex(int value, int digits);
  63.     static AnsiString __fastcall CurrToStr(Currency value);
  64.     static AnsiString __fastcall CurrToStrF(Currency value,
  65.                         TStringFloatFormat format, int digits);
  66.  
  67.     // Constructors
  68.     __fastcall AnsiString(): Data(0) {}
  69.     __fastcall AnsiString(const char* src);
  70.     __fastcall AnsiString(const AnsiString& src);
  71. //    __fastcall AnsiString(const char* src, unsigned char len);
  72.     __fastcall AnsiString(const char* src, unsigned int len);
  73.     __fastcall AnsiString(const wchar_t* src);
  74.     __fastcall AnsiString(char src);
  75.     __fastcall AnsiString(short);
  76.     __fastcall AnsiString(unsigned short);
  77.     __fastcall AnsiString(int src);
  78.     __fastcall AnsiString(unsigned int);
  79.     __fastcall AnsiString(long);
  80.     __fastcall AnsiString(unsigned long);
  81.     __fastcall AnsiString(__int64);
  82.     __fastcall AnsiString(unsigned __int64);
  83.     __fastcall AnsiString(double src);
  84.     __fastcall AnsiString(const WideString &src);
  85.  
  86.     // Destructor
  87.     __fastcall ~AnsiString();
  88.  
  89.     // Assignments
  90.     AnsiString& __fastcall operator =(const AnsiString& rhs);
  91.     AnsiString& __fastcall operator +=(const AnsiString& rhs);
  92.  
  93.     // Comparisons
  94.     bool __fastcall operator ==(const AnsiString& rhs) const;
  95.     bool __fastcall operator !=(const AnsiString& rhs) const;
  96.     bool __fastcall operator <(const AnsiString& rhs) const;
  97.     bool __fastcall operator >(const AnsiString& rhs) const;
  98.     bool __fastcall operator <=(const AnsiString& rhs) const;
  99.     bool __fastcall operator >=(const AnsiString& rhs) const;
  100.     int  __fastcall AnsiCompare(const AnsiString& rhs) const;
  101.     int  __fastcall AnsiCompareIC(const AnsiString& rhs) const; //ignorecase
  102.  
  103.     // Accessing character at specified index
  104.  
  105.     char __fastcall operator [](const int idx) const
  106.     {
  107.       ThrowIfOutOfRange(idx);   // Should Range-checking be optional to avoid overhead ??
  108.       return Data[idx-1];
  109.     }
  110.  
  111. #if defined(ANSISTRING_USE_PROXY_FOR_SUBSCRIPT)
  112.  
  113.     // The use of a proxy class optimizes the case where Unique() must be called
  114.     // when accessing the string via the subscript operator. However, the use of
  115.     // of the proxy class has some drawbacks. First, it breaks code that apply
  116.     // operators to the return value. For example, &MyString[i]. Second, it
  117.     // fails in cases where a implicit conversion was relied upon. For example,
  118.     //       callFuncThatTakesAnObjectWithACharCtr(MyString[i]);
  119.     // In that case, two implicit conversions would be required...
  120.     // The first issue can be remedied by enhancing the proxy class to support
  121.     // all valid operators. The second issue can be lessened but not completely
  122.     // eliminated. Hence, the use of the PROXY class is not the default!
  123.     //
  124.   private:
  125.     class  TCharProxy;
  126.     friend TCharProxy;
  127.     class  TCharProxy
  128.     {
  129.       public:
  130.         TCharProxy(AnsiString& strRef, int index) : m_Ref(strRef), m_Index(index) {}
  131.         TCharProxy& operator=(char c) { m_Ref.Unique(); m_Ref.Data[m_Index-1] = c; return *this; }
  132.         operator char() const         { return m_Ref.Data[m_Index-1]; }
  133.  
  134.       protected:
  135.         AnsiString&         m_Ref;
  136.         int                 m_Index;
  137.     };
  138.  
  139.   public:
  140.     TCharProxy __fastcall operator [](const int idx)
  141.     {
  142.       ThrowIfOutOfRange(idx);   // Should Range-checking be optional to avoid overhead ??
  143.       return TCharProxy(*this, idx);
  144.     }
  145.  
  146. #else
  147.  
  148.     char& __fastcall operator [](const int idx)
  149.     {
  150.       ThrowIfOutOfRange(idx);   // Should Range-checking be optional to avoid overhead ??
  151.       Unique();                 // Ensure we're not ref-counted
  152.       return Data[idx-1];
  153.     }
  154.  
  155. #endif
  156.  
  157.     // Concatenation
  158.     AnsiString __fastcall operator +(const AnsiString& rhs) const;
  159.  
  160.     // C string operator
  161.     char* __fastcall c_str() const        { return (Data)? Data: "";}
  162.  
  163.     // Read access to raw Data ptr.  Will be NULL for an empty string.
  164.     const void* __fastcall data() const   { return Data; }
  165.  
  166.     // Query attributes of string
  167.     int  __fastcall Length()  const;
  168.     bool __fastcall IsEmpty() const { return Data == NULL; }
  169.  
  170.     // Make string unique (refcnt == 1)
  171.     AnsiString&  __fastcall Unique();
  172.  
  173.     // Modify string
  174.     AnsiString&  __fastcall Insert(const AnsiString& str, int index);
  175.     AnsiString&  __fastcall Delete(int index, int count);
  176.     AnsiString&  __fastcall SetLength(int newLength);
  177.  
  178.     int __fastcall Pos(const AnsiString& subStr) const;
  179.     AnsiString   __fastcall LowerCase() const;
  180.     AnsiString   __fastcall UpperCase() const;
  181.     AnsiString   __fastcall Trim() const;
  182.     AnsiString   __fastcall TrimLeft() const;
  183.     AnsiString   __fastcall TrimRight() const;
  184.     AnsiString   __fastcall SubString(int index, int count) const;
  185.  
  186.     int          __fastcall ToInt() const;
  187.     int          __fastcall ToIntDef(int defaultValue) const;
  188.     double       __fastcall ToDouble() const;
  189.  
  190.     // Convert to Unicode
  191.     int          __fastcall WideCharBufSize() const;
  192.     wchar_t*     __fastcall WideChar(wchar_t* dest, int destSize) const;
  193.  
  194.     // MBCS support
  195.     enum TStringMbcsByteType
  196.     {mbSingleByte, mbLeadByte, mbTrailByte};
  197.  
  198.     TStringMbcsByteType __fastcall ByteType(int index) const;
  199.     bool         __fastcall IsLeadByte(int index) const;
  200.     bool         __fastcall IsTrailByte(int index) const;
  201.     bool         __fastcall IsDelimiter(const AnsiString& delimiters, int index) const;
  202.     bool         __fastcall IsPathDelimiter(int index) const;
  203.     int          __fastcall LastDelimiter(const AnsiString& delimiters) const;
  204.     int          __fastcall AnsiPos(const AnsiString& subStr) const;
  205.     char*        __fastcall AnsiLastChar() const;
  206.  
  207.   protected:
  208.     void  ThrowIfOutOfRange(int idx) const;
  209.  
  210.     struct StrRec {
  211.       int allocSiz;
  212.       int refCnt;
  213.       int length;
  214.     };
  215.  
  216.     const StrRec &GetRec() const;
  217.     StrRec &GetRec();
  218.  
  219.   private:
  220.     // assert(offsetof(AnsiString, Data) == 0);
  221.     char *Data;
  222.   };
  223.  
  224.   extern AnsiString __fastcall operator +(const char*, const AnsiString&);
  225.  
  226. #if defined(VCL_IOSTREAM)
  227.   // see <sysclass.h>
  228.   ostream& operator << (ostream& os, const AnsiString& arg);
  229.   istream& operator >> (istream& is, AnsiString& arg);
  230. #endif
  231.  
  232. #if !defined(__CODEGUARD__)
  233.  
  234.   // Codeguard is not very happy about our "reverse indexing" of the
  235.   // Data pointer.  We'll address this by violating the ODR:  when
  236.   // Codeguard compile checks are enabled, these methods will not be
  237.   // inlined.  When building dstring.cpp, __DSTRING_INLINE will be
  238.   // defined to generate out-of-line implementations of these methods.
  239.  
  240.   #if !defined(__DSTRING_INLINE)
  241.   #define __DSTRING_INLINE inline
  242.   #endif
  243.  
  244.   __DSTRING_INLINE const AnsiString::StrRec &AnsiString::GetRec() const
  245.   {
  246.     return reinterpret_cast<const StrRec *>(Data)[-1];
  247.   }
  248.  
  249.   __DSTRING_INLINE AnsiString::StrRec &AnsiString::GetRec()
  250.   {
  251.     return reinterpret_cast<StrRec *>(Data)[-1];
  252.   }
  253.  
  254.   __DSTRING_INLINE int __fastcall AnsiString::Length() const
  255.   {
  256.     return (Data)? GetRec().length : 0;
  257.   }
  258.  
  259. #undef __DSTRING_INLINE
  260. #endif // !defined(__CODEGUARD__)
  261.  
  262.   /////////////////////////////////////////////////////////////////////////////
  263.   // SmallStringBase
  264.   /////////////////////////////////////////////////////////////////////////////
  265.   template <unsigned char sz> class SmallStringBase
  266.   {
  267.   protected:
  268.     unsigned char Len;
  269.     char Data[sz];
  270.   };
  271.  
  272.  
  273.   /////////////////////////////////////////////////////////////////////////////
  274.   // SmallString
  275.   /////////////////////////////////////////////////////////////////////////////
  276.   template <unsigned char sz> class SmallString : SmallStringBase<sz>
  277.   {
  278.  
  279.   public:
  280.     __fastcall SmallString() { Len = 0; }
  281.     __fastcall SmallString(const SmallString& src);
  282.     __fastcall SmallString(const char* src);
  283.  
  284.     __fastcall SmallString(const AnsiString& src)
  285.     {
  286.       long len = src.Length();
  287.       Len = (unsigned char)((len > sz)? sz: len);
  288.       strncpy(Data, src.c_str(), Len);
  289.     }
  290.  
  291.     char& __fastcall operator [](const unsigned char idx)
  292.     {return Data[idx-1];}
  293.  
  294.     SmallString& __fastcall operator =(const SmallString& rhs);
  295.  
  296.     __fastcall operator AnsiString() const;
  297.   };
  298.  
  299.   // used when SmallStrings are in unions (can't have a ctor)
  300.   // must cast DummySmallString to SmallString to do anything useful
  301.  
  302.   template<unsigned char sz> __fastcall
  303.   SmallString<sz>::SmallString(const char* src)
  304.   {
  305.     long len = strlen(src);
  306.     Len = (unsigned char)((len > sz)? sz: len);
  307.     strncpy(Data, src, Len);
  308.   }
  309.  
  310.   template<unsigned char sz> __fastcall
  311.   SmallString<sz>::SmallString(const SmallString& src)
  312.   {
  313.     Len = src.Len;
  314.     for (int i = 0; i < Len; i++)
  315.       Data[i] = src.Data[i];
  316.   }
  317.  
  318.   template<unsigned char sz> SmallString<sz>& __fastcall
  319.   SmallString<sz>::operator =(const SmallString& rhs)
  320.   {
  321.     if (this != &rhs)
  322.     {
  323.       Len = rhs.Len;
  324.       for (int i = 0; i < Len; i++)
  325.         Data[i] = rhs.Data[i];
  326.     }
  327.     return *this;
  328.   }
  329.  
  330.   template<unsigned char sz>
  331.   inline __fastcall SmallString<sz>::operator AnsiString() const
  332.   {
  333.     return AnsiString(Data, Len);
  334.   }
  335.  
  336. #if defined(VCL_IOSTREAM)
  337.   // see sysclass.h
  338.   template<unsigned char sz>
  339.   ostream& operator <<(ostream& os, const SmallString<sz>& arg);
  340.  
  341.   template<unsigned char sz>
  342.   istream& operator >>(istream& is, SmallString<sz>& arg);
  343. #endif
  344.  
  345. }
  346. using namespace System;
  347.  
  348. // The following is provided for backward compatibility.
  349. // Otherwise, the new IntToStr(__int64) causes ambiguity for old code
  350. // that used other integral types.
  351. //
  352. namespace Sysutils
  353. {
  354.   extern PACKAGE AnsiString __fastcall IntToStr(int Value)/* overload */;
  355.   extern PACKAGE AnsiString __fastcall IntToStr(__int64 Value)/* overload */;
  356. }
  357.  
  358. #pragma option push -w-inl
  359.  
  360. inline AnsiString __fastcall IntToStr(bool value)
  361. {
  362.   return Sysutils::IntToStr(int(value));
  363. }
  364. inline AnsiString __fastcall IntToStr(unsigned int value)
  365. {
  366.   return Sysutils::IntToStr(int(value));
  367. }
  368. inline AnsiString __fastcall IntToStr(long value)
  369. {
  370.   return Sysutils::IntToStr(int(value));
  371. }
  372. inline AnsiString __fastcall IntToStr(unsigned long value)
  373. {
  374.   return Sysutils::IntToStr(int(value));
  375. }
  376.  
  377. #pragma option pop
  378.  
  379. #pragma delphiheader end.
  380.  
  381. #endif  // DSTRING_H
  382.  
  383.  
  384.