home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 10 / ioProg_10.iso / soft / optima / hpp.z / WSTRING.HPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-08  |  26.3 KB  |  835 lines

  1. /*************************************************************************
  2.  *
  3.  * WString
  4.  *
  5.  *    This class defines the basic string type used by the library.
  6.  *    The class is DBCS-enabled when running on a DBCS version of the
  7.  *    operating system.
  8.  *
  9.  *    Some important terms to know:
  10.  *
  11.  *        length: number of characters (not bytes) in a string, excluding
  12.  *                terminating null
  13.  *
  14.  *        size: number of bytes (not characters) in a string, excluding
  15.  *              terminating null
  16.  *
  17.  *        empty string: string of length 0
  18.  *
  19.  *        null string: a string with no length or data
  20.  *
  21.  *************************************************************************/
  22.  
  23. #ifndef _WSTRING_HPP_INCLUDED
  24. #define _WSTRING_HPP_INCLUDED
  25.  
  26. #ifndef _WNO_PRAGMA_PUSH
  27. #pragma pack(push,4);
  28. #pragma enum int;
  29. #endif
  30.  
  31. #ifndef _WOBJECT_HPP_INCLUDED
  32. #  include "wobject.hpp"
  33. #endif
  34. #ifndef _WARRAY_HPP_INCLUDED
  35. #  include "warray.hpp"
  36. #endif
  37.  
  38. extern "C" {
  39.     #include <string.h>
  40.     #include <mbstring.h>
  41.     #include <stdarg.h>
  42. };
  43.  
  44. class ostream;
  45. class istream;
  46.  
  47. class WResourceID;
  48. class WModule;   
  49. class WStringReference;
  50. class WString;
  51.  
  52. enum WStringType {
  53.     WAnsiString = 0,
  54.     WUnicodeString = 1,
  55.  
  56.     #ifdef _UNICODE
  57.         WDefaultString = WUnicodeString
  58.     #else
  59.         WDefaultString = WAnsiString
  60.     #endif
  61. };
  62.  
  63. #define USE_STR_LEN                 0xFFFFFFFF
  64. #define NOT_FOUND                   0xFFFFFFFF
  65. #define WSTRING_DEFAULT_QUOTELIST   __WTEXT("\"\"''")
  66.  
  67. #undef LoadString
  68. #if defined( _UNICODE )
  69.     #define LoadString LoadStringW
  70. #else
  71.     #define LoadString LoadStringA
  72. #endif
  73.  
  74. //
  75. // WString
  76. //
  77.  
  78. extern template WArrayReference<WString>;
  79. extern template WArray<WString>;
  80.  
  81. typedef WArray<WString> WStringArray;
  82.  
  83. class WCMCLASS WString : public WObject {
  84.     WDeclareSubclass( WString, WObject )
  85.  
  86.     public:
  87.  
  88.         /**********************************************************
  89.          * WStringElement
  90.          *********************************************************/
  91.  
  92.         //
  93.         // WStringElement
  94.         //
  95.         //    This class represents an individual character in a string
  96.         //    and is used in conjunction with the [] operator on WString
  97.         //    to ensure that characters get inserted into the proper
  98.         //    area in the string (mostly for DBCS strings).
  99.         //
  100.  
  101.         class WCMCLASS WStringElement {
  102.  
  103.             friend class WString;
  104.  
  105.             public:
  106.  
  107.                 WStringElement& operator=( const WWidestChar ch )
  108.                     { string->SetCharacter( index, ch ); return *this; }
  109.  
  110.                 WStringElement& operator=( const WStringElement & e )
  111.                     { string->SetCharacter( index,
  112.                                            e.string->GetCharacter( e.index ) );
  113.                       return *this; }
  114.  
  115.                 operator WWidestChar() const
  116.                     { return string->GetCharacter( index ); }
  117.  
  118.             private:
  119.                 WStringElement( WString *str ) : string( str ), index( 0 ) {}
  120.  
  121.                 WStringElement( const WStringElement & e );
  122.  
  123.                 ~WStringElement() {}
  124.  
  125.             private:
  126.                 WString *string;
  127.                 WULong   index;
  128.         };
  129.  
  130.         /**********************************************************
  131.          * Constructors and Destructors
  132.          *********************************************************/
  133.  
  134.         WString();
  135.         WString( const WChar *string, WULong numChars=USE_STR_LEN );
  136.         WString( const WResourceID & id, WModuleHandle module=_ApplicationModule );
  137.         WString( const WString & s, WBool makeCopy=FALSE );
  138.  
  139.         ~WString();
  140.  
  141.         /**********************************************************
  142.          * Properties
  143.          *********************************************************/
  144.  
  145.         // Character
  146.         //
  147.         //    Set/get an individual character in the string.  Forces
  148.         //    the string to be the default type.
  149.  
  150.         WWidestChar GetCharacter( WULong index ) const;
  151.         WBool       SetCharacter( WULong index, WWidestChar ch );
  152.  
  153.         // Dirty
  154.  
  155.         WBool         GetDirty() const { return _dirty; }
  156.         virtual WBool SetDirty( WBool dirty=TRUE );
  157.  
  158.         // Double
  159.         //
  160.         //    Convert the string to a WDouble, optionally setting an error
  161.         //    flag.
  162.  
  163.         WDouble WCMRETURNSFLOAT GetDouble( WBool *ok=NULL ) const;
  164.  
  165.         // Empty
  166.         //
  167.         //    TRUE if the string is null or is empty.
  168.  
  169.         WBool GetEmpty() const;
  170.  
  171.         // Length
  172.         //
  173.         //    Returns the length of the string in characters, not
  174.         //    including the null terminator.
  175.  
  176.         WULong GetAnsiLength() const;
  177.         WULong GetUnicodeLength() const;
  178.  
  179.         #ifdef _UNICODE
  180.             WULong GetLength() const { return GetUnicodeLength(); }
  181.         #else
  182.             WULong GetLength() const { return GetAnsiLength(); }
  183.         #endif
  184.  
  185.         // Long
  186.         //
  187.         //    Convert the string to a WLong, optionally setting an error
  188.         //    flag.
  189.  
  190.         WLong GetLong( WBool *ok=NULL ) const;
  191.  
  192.         // Null
  193.         //
  194.         //    TRUE if the string is a null (but not an empty) string.
  195.  
  196.         WBool GetNull() const;
  197.  
  198.         // Size
  199.         //
  200.         //    Returns the size of the string in bytes, not including
  201.         //    the null terminator.
  202.  
  203.         WULong GetAnsiSize() const;
  204.         WULong GetUnicodeSize() const;
  205.  
  206.         #ifdef _UNICODE
  207.             WULong GetSize() const { return GetUnicodeSize(); }
  208.         #else
  209.             WULong GetSize() const { return GetAnsiSize(); }
  210.         #endif
  211.  
  212.         // Text
  213.         //
  214.         //    Set/get the actual text of the string.  The optional parm
  215.         //    on the set controls whether or not the string should store
  216.         //    just a pointer to the text or make a copy of the text.
  217.  
  218.         const WAnsiChar    *const GetAnsiText() const;
  219.         WBool                     SetAnsiText( const WAnsiChar *text,
  220.                                                WBool makeCopy=TRUE );
  221.  
  222.         const WUnicodeChar *const GetUnicodeText() const;
  223.         WBool                     SetUnicodeText( const WUnicodeChar *text,
  224.                                                   WBool makeCopy=TRUE );
  225.  
  226.         #ifdef _UNICODE
  227.         const WChar *const GetText() const { return GetUnicodeText(); }
  228.         WBool              SetText( const WChar *str, WBool makeCopy=TRUE )
  229.                                 { return SetUnicodeText( str, makeCopy ); }
  230.         #else
  231.         const WChar *const GetText() const { return GetAnsiText(); }
  232.         WBool              SetText( const WChar *str, WBool makeCopy=TRUE )
  233.                                 { return SetAnsiText( str, makeCopy ); }
  234.         #endif
  235.  
  236.         // Type
  237.         //
  238.         //    Sets/gets the primary type of a string.
  239.  
  240.         WStringType GetType() const;
  241.         WBool       SetType( WStringType type ) const;
  242.  
  243.         // ULong
  244.         //
  245.         //    Convert the string to a WULong, optionally setting an error
  246.         //    flag.
  247.  
  248.         WULong GetULong( WBool *ok=NULL ) const;
  249.  
  250.         /**********************************************************
  251.          * Methods
  252.          *********************************************************/
  253.  
  254.         // Chop
  255.         //
  256.         //    If given a non-negative value, removes all the characters
  257.         //    up to but not including charPos.  If given a negative value,
  258.         //    removes the last charPos*-1 characters.
  259.  
  260.         WBool Chop( WLong charPos );
  261.  
  262.         // Clear
  263.         //
  264.         //    Frees the string, leaving a null string.
  265.  
  266.         void Clear();
  267.     
  268.         // Compare
  269.  
  270.         static int Compare( const WString & a, const WString & b,
  271.                             WBool caseSensitive=TRUE, WULong numChars=0 );
  272.         static int Compare( const WString & a, const WAnsiChar *b );
  273.         static int Compare( const WString & a, const WUnicodeChar *b );
  274.         static int Compare( const WAnsiChar *a, const WString & b );
  275.         static int Compare( const WUnicodeChar *a, const WString & b );
  276.  
  277.         // CompareToSelf
  278.         //
  279.         //    Used by WVector/WMTVector for sorting.
  280.  
  281.         int CompareToSelf( const WString & obj ) const;
  282.  
  283.         // Concat
  284.         //
  285.         //    Concatenate a string onto another.
  286.  
  287.         WBool Concat( const WString & suffix );
  288.         WBool Concat( const WAnsiChar *string );
  289.         WBool Concat( const WUnicodeChar *string );
  290.         WBool Concat( WWidestChar singleChar );
  291.  
  292.         // Concatf
  293.  
  294.         WBool Concatf( const WAnsiChar *parms, ... );
  295.         WBool Concatf( const WUnicodeChar *parms, ... );
  296.  
  297.         // ConvertToInteger
  298.  
  299.         WInt ConvertToInteger() const;
  300.  
  301.         // ConvertToLong
  302.  
  303.         WLong ConvertToLong() const;
  304.  
  305.         // Create
  306.         //
  307.         //    Various constructors for building a new string.  First
  308.         //    frees the old string.  
  309.  
  310.         WBool Create();
  311.         WBool Create( const WResourceID & id, WModuleHandle module=_ApplicationModule );
  312.         WBool Create( const WString & s, WBool makeCopy=FALSE );
  313.  
  314.         WBool CreateAnsi( const WAnsiChar *string,
  315.                           WULong numChars=USE_STR_LEN );
  316.         WBool CreateUnicode( const WUnicodeChar *string,
  317.                              WULong numChars=USE_STR_LEN );
  318.  
  319.         #ifdef _UNICODE
  320.         WBool Create( const WChar *string, WULong numChars=USE_STR_LEN )
  321.             { return CreateUnicode( string, numChars ); }
  322.         #else
  323.         WBool Create( const WChar *string, WULong numChars=USE_STR_LEN )
  324.             { return CreateAnsi( string, numChars ); }
  325.         #endif
  326.  
  327.         // Format
  328.         //
  329.         //    Formats a message.  
  330.         //    Returns number of characters
  331.         //    (not bytes) copied into the string.
  332.  
  333.         WULong Format( const WChar *format, ... );
  334.         WULong Format( WULong messageID, WULong langID, ... );
  335.         WULong Format( const WModule *module, WULong messageID,
  336.                        WULong langID, ... );
  337.  
  338.         // FormatEx
  339.         //
  340.         //    Formats a message, but with more options.
  341.  
  342.         #define WSTRF_NOFORMAT   0x0200
  343.         #define WSTRF_FROMSTRING 0x0400
  344.         #define WSTRF_FROMMODULE 0x0800
  345.         #define WSTRF_FROMSYSTEM 0x1000
  346.         #define WSTRF_USEARRAY   0x2000
  347.  
  348.         WULong FormatEx( WULong flags, const WChar *format,
  349.                          WByte maxWidth, ... );
  350.         WULong FormatEx( WULong flags, const WModule *module,
  351.                          WULong messageID, WULong langID,
  352.                          WByte maxWidth, ... );
  353.  
  354.         // FormatV
  355.         //
  356.         //    The basic form of Format/FormatEx.
  357.  
  358.         WULong FormatV( WULong flags, const WChar *format,
  359.                         WByte maxWidth, va_list args );
  360.         WULong FormatV( WULong flags, const WModule *module,
  361.                         WULong messageID, WULong langID,
  362.                         WByte maxWidth, va_list args );
  363.         // Left
  364.         //
  365.         //    Returns the n leftmost characters of a string.  If string
  366.         //    is smaller than n, just returns the string.
  367.  
  368.         WString Left( WULong numChars ) const;
  369.  
  370.         // Lock
  371.         //
  372.         //    Call this if you want to work directly on the buffer
  373.         //    inside the WString.  It will ensure that no one else
  374.         //    is referencing it, that it has a minimum size (in bytes),
  375.         //    return its pointer.  Call Unlock when you're done.
  376.  
  377.         WChar *Lock( WULong minimumSize=0, WStringType type=WDefaultString );
  378.  
  379.         // Parse
  380.         //
  381.         //    Parse a string into an array of substrings.  The original
  382.         //    string is left unchanged.  The delimeterList specifies
  383.         //    the list of characters that delimit the substrings
  384.         //    (default is whitespace).  If quoteList is non-NULL,
  385.         //    it consists of pairs of begin-end characters which are
  386.         //    used to declare a substring with delimiter characters
  387.         //    embedded in it.  If ignoreMultiple is TRUE, multiple
  388.         //    delimiter characters (such as multiple spaces) are
  389.         //    ignored.  Finally, you can specify an index to start at
  390.         //    and to end at.
  391.  
  392.         WStringArray Parse( const WChar *delimiterList=NULL,
  393.                             WBool ignoreMultiples=TRUE,
  394.                             const WChar *quoteList=WSTRING_DEFAULT_QUOTELIST,
  395.                             WBool stripQuotes=TRUE,
  396.                             WULong startAt=0,
  397.                             WULong endAt=USE_STR_LEN,
  398.                             WBool allowEscapes=TRUE ) const;
  399.  
  400.         // Position
  401.         //
  402.         //    Search for a given character or substring in the string
  403.         //    and return its position. NOT_FOUND is returned if not
  404.         //    found.
  405.  
  406.         WULong Position( const WWidestChar character, WULong startAt=0,
  407.                          WBool ignoreCase=FALSE ) const;
  408.         WULong Position( const WChar *substring, WULong startAt=0,
  409.                          WBool ignoreCase=FALSE ) const;
  410.         WULong Position( const WString & substring, WULong startAt=0,
  411.                          WBool ignoreCase=FALSE ) const;
  412.  
  413.         // Right
  414.         //
  415.         //    Return the n rightmost characters of a string.  If string
  416.         //    is smaller than n, just returns the string.
  417.  
  418.         WString Right( WULong numChars ) const;
  419.  
  420.         // Sprintf
  421.         //
  422.         //    Calls with the C function sprintf functionality.
  423.  
  424.         WULong Sprintf( const WAnsiChar *parms, ... );
  425.         WULong Sprintf( const WUnicodeChar *parms, ... );
  426.  
  427.         // Strip
  428.         //
  429.         //    Remove spaces from one or both ends.
  430.  
  431.         WString Strip( WBool fromBeg=TRUE, WBool fromEnd=TRUE ) const;
  432.  
  433.         // SubString
  434.         //
  435.         //    Returns the substring starting at position start and
  436.         //    of length n.  Start is 0-based.  If n is not specified,
  437.         //    the rest of the string is returned.
  438.  
  439.         WString Substring( WULong startAt, WULong numChars=USE_STR_LEN ) const;
  440.  
  441.         // ToLowercase
  442.         //
  443.         //    Convert the string (in-place) to lowercase.
  444.  
  445.         WBool ToLowercase();
  446.  
  447.         // ToUppercase
  448.         //
  449.         //    Convert the string (in-place) to uppercase.
  450.  
  451.         WBool ToUppercase();
  452.  
  453.         // Trim
  454.         //
  455.         //    Strip the string in place.
  456.  
  457.         WBool Trim( WBool fromBeg=TRUE, WBool fromEnd=TRUE );
  458.  
  459.         // Truncate
  460.         //
  461.         //    Truncate the string to the given length.
  462.  
  463.         WBool Truncate( WULong length );
  464.  
  465.         // Unlock
  466.         //
  467.         //    Call this when done writing directly to the buffer.
  468.         //    The string then recalculates its size and length.
  469.  
  470.         WBool Unlock();
  471.  
  472.         // OSIsMultiByte
  473.  
  474.         static WBool OSIsMultiByte() { return WString::_osIsMultiByte; }
  475.  
  476.         // OSIsUnicode
  477.  
  478.         static WBool OSIsUnicode() { return WString::_osIsUnicode; }
  479.  
  480.         // StringLength 
  481.         //
  482.         //    Returns length in characters, not including null.
  483.  
  484.         static WULong StringLength( const WAnsiChar *str );
  485.         static WULong StringLength( const WUnicodeChar *str );
  486.  
  487.         // StringSize 
  488.         //
  489.         //    Returns size in bytes, not including null.
  490.  
  491.         static WULong StringSize( const WAnsiChar *str );
  492.         static WULong StringSize( const WUnicodeChar *str );
  493.  
  494.         /**********************************************************
  495.          * Static Methods
  496.          *********************************************************/
  497.  
  498.         // LoadString
  499.         //
  500.         //    Load a string directly into a user-allocated buffer.
  501.  
  502.         static WBool LoadString( const WResourceID & id, WChar *buffer,
  503.                                  WULong bufferLength,
  504.                                  WModuleHandle module=_ApplicationModule );
  505.  
  506.         /**********************************************************
  507.          * Static Properties
  508.          *********************************************************/
  509.  
  510.         // DefaultDelimiterList
  511.  
  512.         static const WChar *const GetDefaultDelimiterList();
  513.  
  514.         // DefaultQuoteList
  515.  
  516.         static const WChar *const GetDefaultQuoteList();
  517.  
  518.         // EmptyAnsiCString
  519.  
  520.         static const WAnsiChar    *const GetEmptyAnsiCString();
  521.  
  522.         // EmptyCString
  523.  
  524.         static const WChar        *const GetEmptyCString();
  525.  
  526.         // EmptyString
  527.  
  528.         static const WString & GetEmptyString();
  529.  
  530.         // EmptyUnicodeCString
  531.  
  532.         static const WUnicodeChar *const GetEmptyUnicodeCString();
  533.  
  534.         // NullString
  535.  
  536.         static const WString & GetNullString();
  537.  
  538.         /*********************************************************
  539.          * Operators
  540.          *********************************************************/
  541.  
  542.         //
  543.         // [] operator -- Note that a WWidestChar is always used,
  544.         //                not a WChar, to ensure that the result
  545.         //                can handle the largest type of char.
  546.  
  547.         const WStringElement& operator[]( int index ) const;
  548.  
  549.         WStringElement& operator[]( int index );
  550.  
  551.         //
  552.         // casting operators
  553.         //
  554.  
  555.         operator const WAnsiChar*() const { return GetAnsiText(); }
  556.         operator const WUnicodeChar*() const { return GetUnicodeText(); }
  557.  
  558.         /*********************************************************
  559.          * Cache
  560.          *********************************************************/
  561.  
  562.         // CacheSize
  563.  
  564.         static WULong GetCacheSize();
  565.         static WBool  SetCacheSize( WULong size );
  566.  
  567.         // FlushCache
  568.  
  569.         static void FlushCache();
  570.  
  571.  
  572.     private:
  573.         // Note: This operator should not be used.  Instead, call Lock().
  574.         operator WChar*() const;
  575.  
  576.     public:
  577.  
  578.         //
  579.         // = operator
  580.         //
  581.  
  582.         WString & operator=( const WAnsiChar *s );
  583.         WString & operator=( const WUnicodeChar *s );
  584.         WString & operator=( const WString & s );
  585.  
  586.         //
  587.         // == operator
  588.         //
  589.  
  590.         friend int WEXPORT operator==( const WString & a, const WString & b );
  591.         friend int WEXPORT operator==( const WString & a, const WAnsiChar *b );
  592.         friend int WEXPORT operator==( const WString & a, const WUnicodeChar *b );
  593.         friend int WEXPORT operator==( const WAnsiChar *a, const WString & b );
  594.         friend int WEXPORT operator==( const WUnicodeChar *a, const WString & b );
  595.  
  596.         //
  597.         // <= operator
  598.         //
  599.  
  600.         friend int WEXPORT operator<=( const WString & a, const WString & b );
  601.         friend int WEXPORT operator<=( const WString & a, const WAnsiChar *b );
  602.         friend int WEXPORT operator<=( const WString & a, const WUnicodeChar *b );
  603.         friend int WEXPORT operator<=( const WAnsiChar *a, const WString & b );
  604.         friend int WEXPORT operator<=( const WUnicodeChar *a, const WString & b );
  605.  
  606.         //
  607.         // < operator
  608.         //
  609.  
  610.         friend int WEXPORT operator<( const WString & a, const WString & b );
  611.         friend int WEXPORT operator<( const WString & a, const WAnsiChar *b );
  612.         friend int WEXPORT operator<( const WString & a, const WUnicodeChar *b );
  613.         friend int WEXPORT operator<( const WAnsiChar *a, const WString & b );
  614.         friend int WEXPORT operator<( const WUnicodeChar *a, const WString & b );
  615.  
  616.         //
  617.         // >= operator
  618.         //
  619.  
  620.         friend int WEXPORT operator>=( const WString & a, const WString & b );
  621.         friend int WEXPORT operator>=( const WString & a, const WAnsiChar *b );
  622.         friend int WEXPORT operator>=( const WString & a, const WUnicodeChar *b );
  623.         friend int WEXPORT operator>=( const WAnsiChar *a, const WString & b );
  624.         friend int WEXPORT operator>=( const WUnicodeChar *a, const WString & b );
  625.  
  626.         //
  627.         // > operator
  628.         //
  629.  
  630.         friend int WEXPORT operator>( const WString & a, const WString & b );
  631.         friend int WEXPORT operator>( const WString & a, const WAnsiChar *b );
  632.         friend int WEXPORT operator>( const WString & a, const WUnicodeChar *b );
  633.         friend int WEXPORT operator>( const WAnsiChar *a, const WString & b );
  634.         friend int WEXPORT operator>( const WUnicodeChar *a, const WString & b );
  635.  
  636.         //
  637.         // != operator
  638.         //
  639.  
  640.         friend int WEXPORT operator!=( const WString & a, const WString & b );
  641.         friend int WEXPORT operator!=( const WString & a, const WAnsiChar *b );
  642.         friend int WEXPORT operator!=( const WString & a, const WUnicodeChar *b );
  643.         friend int WEXPORT operator!=( const WAnsiChar *a, const WString & b );
  644.         friend int WEXPORT operator!=( const WUnicodeChar *a, const WString & b );
  645.  
  646.         //
  647.         // << operator
  648.         //
  649.  
  650.         friend ostream& WEXPORT operator<<( ostream & out, const WString & str );
  651.         friend ostream& WEXPORT operator<<( ostream & out, const WUnicodeChar *str );
  652.  
  653.         //
  654.         // >> operator
  655.         //
  656.  
  657.         friend istream& WEXPORT operator>>( istream & in, WString & str );
  658.         friend istream& WEXPORT operator>>( istream & in, WUnicodeChar *str );
  659.  
  660.         //
  661.         // += operator
  662.         //
  663.  
  664.         WString& operator+=( const WString & a );
  665.         WString& operator+=( const WAnsiChar * a );
  666.         WString& operator+=( const WUnicodeChar * a );
  667.         WString& operator+=( WAnsiChar a );
  668.         WString& operator+=( WUnicodeChar a );
  669.  
  670.         //
  671.         // + operator
  672.         //
  673.  
  674.         WString operator+( const WString & a );
  675.         WString operator+( const WAnsiChar * a );
  676.         WString operator+( const WUnicodeChar * a );
  677.         WString operator+( WAnsiChar a );
  678.         WString operator+( WUnicodeChar a );
  679.         friend WString WEXPORT operator+( const WAnsiChar * a, const WString & b );
  680.         friend WString WEXPORT operator+( const WUnicodeChar * a, const WString & b );
  681.  
  682.         /**********************************************************
  683.          * Private
  684.          *********************************************************/
  685.  
  686.     protected:
  687.  
  688.         virtual WBool CopyOnWrite( WStringType type=WDefaultString );
  689.         virtual WBool PrepareForRead() const;
  690.  
  691.         WBool  ReallocateRef( WByte newType, WULong minimumSize );
  692.         WBool  GrowTo( WULong size );
  693.         WULong SearchFor( const WChar *buf, WULong size, WULong at,
  694.                           WBool ignoreCase ) const;
  695.  
  696.     protected:
  697.  
  698.         WStringReference *_ref;
  699.         const WChar      *_stringData;  // for easier debugging only!
  700.         WStringElement    _element;
  701.  
  702.         static WBool      _osIsMultiByte;
  703.         static WBool      _osIsUnicode;
  704.  
  705.     private:
  706.  
  707.         WBool             _dirty;
  708. };
  709.  
  710. //
  711. // WResourceString
  712. //
  713.  
  714. class WCMCLASS WResourceString : public WString {
  715.     WDeclareSubclass( WResourceString, WString )
  716.  
  717.     public:
  718.         WResourceString( const WResourceID & id, WModuleHandle module=_ApplicationModule );
  719.         WResourceString( const WResourceString & other );
  720.  
  721.         ~WResourceString();
  722.  
  723.         WResourceString & operator=( const WResourceString & other );
  724.         WResourceString & operator=( const WAnsiChar *s );
  725.         WResourceString & operator=( const WUnicodeChar *s );
  726.         WResourceString & operator=( const WString & s );
  727.  
  728.     protected:
  729.         virtual WBool    PrepareForRead() const;
  730.  
  731.         WULong           _id;
  732.         WModuleHandle    _handle;
  733. };
  734.  
  735. //
  736. // WConstantString
  737. //
  738.  
  739. class WCMCLASS WConstantString : public WString {
  740.     WDeclareSubclass( WConstantString, WString )
  741.  
  742.     public:
  743.         WConstantString( const WChar *fixedString );
  744.         WConstantString( const WConstantString & other );
  745.  
  746.         ~WConstantString();
  747.  
  748.         WConstantString & operator=( const WConstantString & other );
  749.         WConstantString & operator=( const WAnsiChar *s );
  750.         WConstantString & operator=( const WUnicodeChar *s );
  751.         WConstantString & operator=( const WString & s );
  752.  
  753.         /**********************************************************
  754.          * Overrides
  755.          *********************************************************/
  756. };
  757.  
  758. /*******************************************************************
  759.  *
  760.  * Library functions and macros
  761.  *
  762.  *   The following macros and functions are covers for the appropriate
  763.  *   C library functions and expand out to the correct function
  764.  *   depending on the _UNICODE, _DBCS and _SBCS macro settings.
  765.  *
  766.  *   You should use the functions wherever possible, not the macros,
  767.  *   as the functions provide type checking.
  768.  *
  769.  *   Remember that the length of a string is not necessarily the
  770.  *   same as its size!
  771.  *
  772.  ******************************************************************/
  773.  
  774. #define _MBCast1(x) ((const unsigned char *)(x))
  775. #define _MBCast2(x) ((unsigned char *)(x))
  776.  
  777. #ifdef _SBCS
  778. #define A_StrLen(x)   strlen(x)
  779. #define A_StrSize(x)  strlen(x)
  780. #define A_StrCpy(d,s) strcpy(d,s)
  781. #else
  782. #define A_StrLen(x)   (WString::OSIsMultiByte()?_mbslen(_MBCast1(x)):strlen(x))
  783. #define A_StrSize(x)  strlen(x)
  784. #define A_StrCpy(d,s) (WString::OSIsMultiByte()?_mbscpy(_MBCast2(d),_MBCast1(s)):\
  785.                        strcpy(d,s))
  786. #endif
  787.  
  788. #define U_StrLen(x)   wcslen(x)
  789. #define U_StrSize(x)  (wcslen(x)*sizeof(WUnicodeChar))
  790. #define U_StrCpy(d,s) wcscpy(d,s)
  791.  
  792. #ifdef _UNICODE
  793. #define D_StrLen(x)   U_StrLen(x)
  794. #define D_StrSize(x)  U_StrSize(x)
  795. #define D_StrCpy(d,s) U_StrCpy(d,s)
  796. #else
  797. #define D_StrLen(x)   A_StrLen(x)
  798. #define D_StrSize(x)  A_StrSize(x)
  799. #define D_StrCpy(d,s) A_StrCpy(d,s)
  800. #endif
  801.  
  802. //
  803. // WStrLen -- Return length of string in characters. (See StrSize for bytes.)
  804. //
  805.  
  806. inline WULong WStrLen( const WChar *string ){
  807.     return D_StrLen( string );
  808. }
  809.  
  810. //
  811. // WStrSize -- Return length of string in bytes.  (See StrLen for characters.)
  812. //
  813.  
  814. inline WULong WStrSize( const WChar *string ){
  815.     return D_StrSize( string );
  816. }
  817.  
  818. //
  819. // WStrCpy -- Cover for strcpy.
  820. //
  821.  
  822. inline WChar *WStrCpy( WChar *dst, const WChar *src ){
  823.     return D_StrCpy( dst, src );
  824. }
  825.  
  826. #define WNullString     WString::GetNullString()
  827. #define WEmptyString    WString::GetEmptyString()
  828.  
  829. #ifndef _WNO_PRAGMA_PUSH
  830. #pragma enum pop;
  831. #pragma pack(pop);
  832. #endif
  833.  
  834. #endif // _WSTRING_HPP_INCLUDED
  835.