home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / include / istring.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-22  |  29.3 KB  |  818 lines
  1.  
  2. #ifndef _ISTRING_
  3. #define _ISTRING_
  4. /*******************************************************************************
  5. * FILE NAME: istring.hpp                                                       *
  6. *                                                                              *
  7. * DESCRIPTION:                                                                 *
  8. *   Declaration of the classes:                                                *
  9. *     IString                                                                  *
  10. *                                                                              *
  11. * COPYRIGHT:                                                                   *
  12. *   IBM Open Class Library                                                     *
  13. *   (C) Copyright International Business Machines Corporation 1992, 1996       *
  14. *   Licensed Material - Program-Property of IBM - All Rights Reserved.         *
  15. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  16. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  17. *                                                                              *
  18. *******************************************************************************/
  19. #if !defined( _IBASE_ )
  20.   #include <ibase.hpp>
  21. #endif
  22.  
  23. #include <istrenum.hpp>
  24.  
  25. #pragma pack(4)
  26.  
  27. extern "C"
  28.   {
  29.   #include <limits.h>
  30.   }
  31.  
  32. class ostream;
  33. class istream;
  34.  
  35.  
  36.  
  37.  
  38. class IStringTest;
  39. class IBuffer;
  40.  
  41. class IString : public IBase {
  42. public:
  43. /*------------------------- Constructors -------------------------------------*/
  44.   IString           ( );
  45.   IString           ( const IString &aString );
  46.  
  47.   IString           ( int  anInt );
  48.   IString           ( unsigned  anUnsigned );
  49.   IString           ( long  aLong );
  50.   IString           ( unsigned long  anUnsignedLong );
  51. #ifdef _LONG_LONG
  52.   IString           ( long long  aLongLong );
  53.   IString           ( unsigned long long  anUnsignedLongLong );
  54. #endif
  55.   IString           ( short  aShort );
  56.   IString           ( unsigned short  anUnsignedShort );
  57.   IString           ( double  aDouble );
  58.  
  59.   IString           ( char  aChar );
  60.   IString           ( unsigned char  anUnsignedChar );
  61.   IString           ( signed char  aSignedChar);
  62.  
  63.   IString           ( const char  *pChar );
  64.   IString           ( const unsigned char  *pUnsignedChar );
  65.   IString           ( const signed char  *pSignedChar );
  66.  
  67.   IString           ( const void *pBuffer1,
  68.                       unsigned    lenBuffer1,
  69.                       char        padCharacter = ' ' );
  70.   IString           ( const void *pBuffer1,
  71.                       unsigned     lenBuffer1,
  72.                       const void  *pBuffer2,
  73.                       unsigned     lenBuffer2,
  74.                       char         padCharacter = ' ' );
  75.   IString           ( const void *pBuffer1,
  76.                       unsigned     lenBuffer1,
  77.                       const void  *pBuffer2,
  78.                       unsigned     lenBuffer2,
  79.                       const void  *pBuffer3,
  80.                       unsigned     lenBuffer3,
  81.                       char         padCharacter = ' ' );
  82.  
  83.   ~IString          ( );
  84.  
  85. /*------------------------- Diagnostics --------------------------------------*/
  86. IString
  87.   asString          ( ) const,
  88.   asDebugInfo       ( ) const;
  89.  
  90. friend ostream
  91.  &operator <<       ( ostream       &aStream,
  92.                       const IString &aString );
  93.  
  94. /*------------------------- Stream Input -------------------------------------*/
  95. friend istream
  96.  &operator >>       ( istream &aStream,
  97.                       IString &aString );
  98.  
  99. static IString
  100.   lineFrom          ( istream &aStream,
  101.                       char     delim = '\n' );
  102.  
  103. /*------------------------- Testing ------------------------------------------*/
  104. Boolean
  105.   isAlphanumeric    ( ) const,
  106.   isAlphabetic      ( ) const,
  107.   isASCII           ( ) const,
  108.   isBinaryDigits    ( ) const,
  109.   isControl         ( ) const,
  110.   isDigits          ( ) const,
  111.   isGraphics        ( ) const,
  112.   isHexDigits       ( ) const,
  113.   isLowerCase       ( ) const,
  114.   isPrintable       ( ) const,
  115.   isPunctuation     ( ) const,
  116.   isUpperCase       ( ) const,
  117.   isWhiteSpace      ( ) const;
  118.  
  119. /*------------------------- NLS Testing --------------------------------------*/
  120. Boolean
  121.   isMBCS            ( ) const,
  122.   isDBCS            ( ) const,
  123.   isSBCS            ( ) const,
  124.   isValidMBCS       ( ) const,
  125.   isValidDBCS       ( ) const,
  126.   includesMBCS      ( ) const,
  127.   includesDBCS      ( ) const,
  128.   includesSBCS      ( ) const;
  129.  
  130.  
  131. /*------------------------- Pattern Matching ---------------------------------*/
  132. Boolean
  133.   isLike            ( const IString &aPattern,
  134.                       char           zeroOrMore = '*',
  135.                       char           anyChar    = '?' ) const,
  136.   isLike            ( const char    *pPattern,
  137.                       char           zeroOrMore = '*',
  138.                       char           anyChar    = '?' ) const,
  139.  
  140.   isAbbreviationFor ( const IString &fullString,
  141.                       unsigned       minAbbrevLength = 0 ) const,
  142.   isAbbreviationFor ( const char    *pFullString,
  143.                       unsigned       minAbbrevLength = 0 ) const,
  144.  
  145.   includes          ( const IString     &aString ) const,
  146.   includes          ( const char        *pString ) const,
  147.   includes          ( char               aChar   ) const,
  148.   includes          ( const IStringTest &aTest   ) const;
  149.  
  150. /*------------------------- Comparisons --------------------------------------*/
  151. friend Boolean
  152.   operator ==      ( const IString &string1,
  153.                      const IString &string2  ),
  154.   operator ==      ( const IString &string1,
  155.                      const char    *pString2 ),
  156.   operator ==      ( const char    *pString1,
  157.                      const IString &string2  ),
  158.  
  159.   operator !=      ( const IString &string1,
  160.                      const IString &string2  ),
  161.   operator !=      ( const IString &string1,
  162.                      const char    *pString2 ),
  163.   operator !=      ( const char    *pString1,
  164.                      const IString &string2  ),
  165.  
  166.   operator <       ( const IString &string1,
  167.                      const IString &string2  ),
  168.   operator <       ( const IString &string1,
  169.                      const char    *pString2 ),
  170.   operator <       ( const char    *pString1,
  171.                      const IString &string2  ),
  172.  
  173.   operator <=      ( const IString &string1,
  174.                      const IString &string2  ),
  175.   operator <=      ( const IString &string1,
  176.                      const char    *pString2 ),
  177.   operator <=      ( const char    *pString1,
  178.                      const IString &string2  ),
  179.  
  180.   operator >       ( const IString &string1,
  181.                      const IString &string2  ),
  182.   operator >       ( const IString &string1,
  183.                      const char    *pString2 ),
  184.   operator >       ( const char    *pString1,
  185.                      const IString &string2  ),
  186.  
  187.   operator >=      ( const IString &string1,
  188.                      const IString &string2  ),
  189.   operator >=      ( const IString &string1,
  190.                      const char    *pString2 ),
  191.   operator >=      ( const char    *pString1,
  192.                      const IString &string2  );
  193.  
  194. /*------------------------- Type Conversions ---------------------------------*/
  195.   operator char*          ( ) const;
  196.   operator unsigned char* ( ) const;
  197.   operator signed char*   ( ) const;
  198.  
  199.  
  200. long
  201.   asInt                   ( ) const;
  202.  
  203. unsigned long
  204.   asUnsigned              ( ) const;
  205.  
  206. #ifdef _LONG_LONG
  207. long long
  208.   asLongLong              ( ) const;
  209.  
  210. unsigned long long
  211.   asUnsignedLongLong      ( ) const;
  212. #endif
  213.  
  214. double
  215.   asDouble                ( ) const;
  216.  
  217. /*------------------------- Binary Conversions -------------------------------*/
  218. IString
  219.  &b2c              ( ),
  220.  &b2d              ( ),
  221.  &b2x              ( );
  222.  
  223. static IString
  224.   b2c              ( const IString &aString ),
  225.   b2d              ( const IString &aString ),
  226.   b2x              ( const IString &aString );
  227.  
  228. /*------------------------- Character Conversions ----------------------------*/
  229. IString
  230.  &c2b              ( ),
  231.  &c2d              ( ),
  232.  &c2x              ( );
  233.  
  234. static IString
  235.   c2b              ( const IString &aString ),
  236.   c2d              ( const IString &aString ),
  237.   c2x              ( const IString &aString );
  238.  
  239. /*------------------------- Numeric Conversions ------------------------------*/
  240. IString
  241.  &d2b              ( ),
  242.  &d2c              ( ),
  243.  &d2x              ( );
  244.  
  245. static IString
  246.   d2b              ( const IString &aString ),
  247.   d2c              ( const IString &aString ),
  248.   d2x              ( const IString &aString );
  249.  
  250. /*------------------------- Hex Conversions ----------------------------------*/
  251. IString
  252.  &x2b              ( ),
  253.  &x2c              ( ),
  254.  &x2d              ( );
  255.  
  256. static IString
  257.   x2b              ( const IString &aString ),
  258.   x2c              ( const IString &aString ),
  259.   x2d              ( const IString &aString );
  260.  
  261.  
  262. /*------------------------- Manipulations ------------------------------------*/
  263. IString
  264.  &operator =       ( const IString &aString ),
  265.   operator ~       (                        ) const,
  266.   operator +       ( const IString &aString ) const,
  267.   operator +       ( const char    *pString ) const,
  268.  &operator +=      ( const IString &aString ),
  269.  &operator +=      ( const char    *pString ),
  270.   operator &       ( const IString &aString ) const,
  271.   operator &       ( const char    *pString ) const,
  272.  &operator &=      ( const IString &aString ),
  273.  &operator &=      ( const char    *pString ),
  274.   operator |       ( const IString &aString ) const,
  275.   operator |       ( const char    *pString ) const,
  276.  &operator |=      ( const IString &aString ),
  277.  &operator |=      ( const char    *pString ),
  278.   operator ^       ( const IString &aString ) const,
  279.   operator ^       ( const char    *pString ) const,
  280.  &operator ^=      ( const IString &aString ),
  281.  &operator ^=      ( const char    *pString );
  282.  
  283. friend IString
  284.   operator +       ( const char    *pString,
  285.                      const IString &aString ),
  286.   operator &       ( const char    *pString,
  287.                      const IString &aString ),
  288.   operator |       ( const char    *pString,
  289.                      const IString &aString ),
  290.   operator ^       ( const char    *pString,
  291.                      const IString &aString );
  292.  
  293. /*------------------------- Queries ------------------------------------------*/
  294. unsigned
  295.   size              ( ) const,
  296.   length            ( ) const;
  297.  
  298. IString
  299.   subString         ( unsigned startPos ) const,
  300.   subString         ( unsigned startPos,
  301.                       unsigned length,
  302.                       char     padCharacter = ' ' ) const;
  303.  
  304. char
  305.  &operator []       ( unsigned index );
  306.  
  307. const char
  308.  &operator []       ( unsigned index ) const;
  309.  
  310. char
  311.  &operator []       ( signed index );
  312.  
  313. const char
  314.  &operator []       ( signed index ) const;
  315.  
  316. char
  317.  &operator []       ( unsigned long index );
  318.  
  319. const char
  320.  &operator []       ( unsigned long index ) const;
  321.  
  322. char
  323.  &operator []       ( signed long index );
  324.  
  325. const char
  326.  &operator []       ( signed long index ) const;
  327.  
  328. IStringEnum::CharType
  329.   charType          ( unsigned index ) const;
  330.  
  331. /*------------------------- Forward Searches ---------------------------------*/
  332. unsigned
  333.   indexOf           ( const IString     &aString,
  334.                       unsigned           startPos = 1 ) const,
  335.   indexOf           ( const char        *pString,
  336.                       unsigned           startPos = 1 ) const,
  337.   indexOf           ( char              aCharacter,
  338.                       unsigned           startPos = 1 ) const,
  339.   indexOf           ( const IStringTest &aTest,
  340.                       unsigned           startPos = 1 ) const,
  341.  
  342.   indexOfAnyBut     ( const IString     &validChars,
  343.                       unsigned           startPos = 1 ) const,
  344.   indexOfAnyBut     ( const char        *pValidChars,
  345.                       unsigned           startPos = 1 ) const,
  346.   indexOfAnyBut     ( char               validChar,
  347.                      unsigned           startPos = 1 ) const,
  348.   indexOfAnyBut     ( const IStringTest &aTest,
  349.                       unsigned           startPos = 1 ) const,
  350.  
  351.   indexOfAnyOf      ( const IString     &searchChars,
  352.                       unsigned           startPos = 1 ) const,
  353.   indexOfAnyOf      ( const char        *pSearchChars,
  354.                       unsigned           startPos = 1 ) const,
  355.   indexOfAnyOf      ( char               searchChar,
  356.                       unsigned           startPos = 1 ) const,
  357.   indexOfAnyOf      ( const IStringTest &aTest,
  358.                       unsigned           startPos = 1 ) const,
  359.  
  360.   occurrencesOf     ( const IString     &aString,
  361.                       unsigned           startPos = 1 ) const,
  362.   occurrencesOf     ( const char        *pString,
  363.                       unsigned           startPos = 1 ) const,
  364.   occurrencesOf     ( char              aCharacter,
  365.                       unsigned           startPos = 1 ) const,
  366.   occurrencesOf     ( const IStringTest &aTest,
  367.                       unsigned           startPos = 1 ) const;
  368.  
  369.  
  370. /*------------------------- Reverse Searches ---------------------------------*/
  371. unsigned
  372.   lastIndexOf       ( const IString &aString,
  373.                       unsigned       startPos = (unsigned)UINT_MAX ) const,
  374.   lastIndexOf       ( const char    *pString,
  375.                       unsigned       startPos = (unsigned)UINT_MAX ) const,
  376.   lastIndexOf       ( char          aCharacter,
  377.                       unsigned       startPos = (unsigned)UINT_MAX ) const,
  378.   lastIndexOf       ( const IStringTest &aTest,
  379.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  380.  
  381.   lastIndexOfAnyBut ( const IString     &validChars,
  382.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  383.   lastIndexOfAnyBut ( const char        *pValidChars,
  384.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  385.   lastIndexOfAnyBut ( char               validChar,
  386.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  387.   lastIndexOfAnyBut ( const IStringTest &aTest,
  388.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  389.  
  390.   lastIndexOfAnyOf  ( const IString     &searchChars,
  391.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  392.   lastIndexOfAnyOf  ( const char        *pSearchChars,
  393.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  394.   lastIndexOfAnyOf  ( char               searchChar,
  395.                       unsigned           startPos = (unsigned)UINT_MAX ) const,
  396.   lastIndexOfAnyOf  ( const IStringTest &aTest,
  397.                       unsigned           startPos = (unsigned)UINT_MAX ) const;
  398.  
  399. /*------------------------- Editing ------------------------------------------*/
  400. IString
  401.  ¢er            ( unsigned length,
  402.                       char     padCharacter = ' ' ),
  403.  
  404.  &change            ( const IString &inputString,
  405.                       const IString &outputString,
  406.                       unsigned       startPos = 1,
  407.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  408.  &change            ( const IString &inputString,
  409.                       const char    *pOutputString,
  410.                       unsigned       startPos = 1,
  411.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  412.  &change            ( const char    *pInputString,
  413.                       const IString &outputString,
  414.                       unsigned       startPos = 1,
  415.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  416.  &change            ( const char    *pInputString,
  417.                       const char    *pOutputString,
  418.                       unsigned       startPos = 1,
  419.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  420.  
  421.  ©              ( unsigned numCopies ),
  422.  
  423.  &insert            ( const IString &aString,
  424.                       unsigned       index = 0,
  425.                       char           padCharacter = ' ' ),
  426.  &insert            ( const char    *pString,
  427.                       unsigned       index = 0,
  428.                       char           padCharacter = ' ' ),
  429.  
  430.  &leftJustify       ( unsigned length,
  431.                       char     padCharacter = ' ' ),
  432.  
  433.  &lowerCase         ( ),
  434.  
  435.  &overlayWith       ( const IString &aString,
  436.                       unsigned       index        = 1,
  437.                       char           padCharacter = ' ' ),
  438.  &overlayWith       ( const char    *pString,
  439.                       unsigned       index        = 1,
  440.                       char           padCharacter = ' ' ),
  441.  
  442.  &remove            ( unsigned startPos ),
  443.  &remove            ( unsigned startPos,
  444.                       unsigned numChars ),
  445.  
  446.  &reverse           ( ),
  447.  
  448.  &rightJustify      ( unsigned length,
  449.                       char     padCharacter = ' ' ),
  450.  
  451.  &strip             ( ),
  452.  &strip             ( char               aCharacter ),
  453.  &strip             ( const IString     &aString ),
  454.  &strip             ( const char        *pString ),
  455.  &strip             ( const IStringTest &aTest ),
  456.  
  457.  &stripLeading      ( ),
  458.  &stripLeading      ( char               aCharacter ),
  459.  &stripLeading      ( const IString     &aString ),
  460.  &stripLeading      ( const char        *pString ),
  461.  &stripLeading      ( const IStringTest &aTest ),
  462.  
  463.  &stripTrailing     ( ),
  464.  &stripTrailing     ( char               aCharacter ),
  465.  &stripTrailing     ( const IString     &aString ),
  466.  &stripTrailing     ( const char        *pString ),
  467.  &stripTrailing     ( const IStringTest &aTest ),
  468.  
  469.  &translate         ( const IString &inputChars,
  470.                       const IString &outputChars,
  471.                       char           padCharacter = ' ' ),
  472.  &translate         ( const IString &inputChars,
  473.                       const char    *pOutputChars,
  474.                       char           padCharacter = ' ' ),
  475.  &translate         ( const char    *pInputChars,
  476.                       const IString &outputChars,
  477.                       char           padCharacter = ' ' ),
  478.  &translate         ( const char    *pInputChars,
  479.                       const char    *pOutputChars,
  480.                       char           padCharacter = ' ' ),
  481.  
  482.  &upperCase         ( );
  483.  
  484. static IString
  485.   center            ( const IString &aString,
  486.                       unsigned       length,
  487.                       char           padCharacter = ' ' ),
  488.  
  489.   change            ( const IString &aString,
  490.                       const IString &inputString,
  491.                       const IString &outputString,
  492.                       unsigned       startPos = 1,
  493.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  494.   change            ( const IString &aString,
  495.                       const IString &inputString,
  496.                       const char    *pOutputString,
  497.                       unsigned       startPos = 1,
  498.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  499.   change            ( const IString &aString,
  500.                       const char    *pInputString,
  501.                       const IString &outputString,
  502.                       unsigned       startPos = 1,
  503.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  504.   change            ( const IString &aString,
  505.                       const char    *pInputString,
  506.                       const char    *pOutputString,
  507.                       unsigned       startPos = 1,
  508.                       unsigned       numChanges = (unsigned)UINT_MAX ),
  509.  
  510.   copy              ( const IString &aString,
  511.                       unsigned       numCopies ),
  512.  
  513.   insert            ( const IString &aString,
  514.                       const IString &anInsert,
  515.                       unsigned       index = 0,
  516.                       char           padCharacter = ' ' ),
  517.   insert            ( const IString &aString,
  518.                       const char    *pInsert,
  519.                       unsigned       index = 0,
  520.                       char           padCharacter = ' ' ),
  521.  
  522.   leftJustify       ( const IString &aString,
  523.                       unsigned       length,
  524.                       char           padCharacter = ' ' ),
  525.  
  526.   lowerCase         ( const IString &aString ),
  527.  
  528.   overlayWith       ( const IString &aString,
  529.                       const IString &anOverlay,
  530.                       unsigned       index        = 1,
  531.                       char           padCharacter = ' ' ),
  532.   overlayWith       ( const IString &aString,
  533.                       const char    *pOverlay,
  534.                       unsigned       index        = 1,
  535.                       char           padCharacter = ' ' ),
  536.  
  537.   remove            ( const IString &aString,
  538.                       unsigned       startPos ),
  539.   remove            ( const IString &aString,
  540.                       unsigned       startPos,
  541.                       unsigned       numChars ),
  542.  
  543.   reverse           ( const IString &aString ),
  544.  
  545.   rightJustify      ( const IString &aString,
  546.                       unsigned       length,
  547.                       char           padCharacter = ' ' ),
  548.  
  549.   stripBlanks       ( const IString &aString ),
  550.   strip             ( const IString &aString,
  551.                       char           aChar ),
  552.   strip             ( const IString &aString,
  553.                       const IString &aStringOfChars ),
  554.   strip             ( const IString &aString,
  555.                       const char    *pStringOfChars ),
  556.   strip             ( const IString &aString,
  557.                       const IStringTest &aTest ),
  558.  
  559.   stripLeadingBlanks ( const IString &aString ),
  560.   stripLeading      ( const IString &aString,
  561.                       char           aChar ),
  562.   stripLeading      ( const IString &aString,
  563.                       const IString &aStringOfChars ),
  564.   stripLeading      ( const IString &aString,
  565.                       const char    *pStringOfChars ),
  566.   stripLeading      ( const IString &aString,
  567.                       const IStringTest &aTest ),
  568.  
  569.   stripTrailingBlanks ( const IString &aString ),
  570.   stripTrailing     ( const IString &aString,
  571.                       char           aChar ),
  572.   stripTrailing     ( const IString &aString,
  573.                       const IString &aStringOfChars ),
  574.   stripTrailing     ( const IString &aString,
  575.                       const char    *pStringOfChars ),
  576.   stripTrailing     ( const IString &aString,
  577.                       const IStringTest &aTest ),
  578.  
  579.   translate         ( const IString &aString,
  580.                       const IString &inputChars,
  581.                       const IString &outputChars,
  582.                       char           padCharacter = ' ' ),
  583.   translate         ( const IString &aString,
  584.                       const IString &inputChars,
  585.                       const char    *pOutputChars,
  586.                       char           padCharacter = ' ' ),
  587.   translate         ( const IString &aString,
  588.                       const char    *pInputChars,
  589.                       const IString &outputChars,
  590.                       char           padCharacter = ' ' ),
  591.   translate         ( const IString &aString,
  592.                       const char    *pInputChars,
  593.                       const char    *pOutputChars,
  594.                       char           padCharacter = ' ' ),
  595.  
  596.   upperCase         ( const IString &aString );
  597.  
  598. /*------------------------- Word Operations ----------------------------------*/
  599. IString
  600.  &removeWords       ( unsigned firstWord ),
  601.  &removeWords       ( unsigned firstWord,
  602.                       unsigned numWords ),
  603.  
  604.  &space             ( unsigned numSpaces = 1,
  605.                       char     spaceChar = ' ' ),
  606.  
  607.   word              ( unsigned  wordNumber ) const,
  608.  
  609.   words             ( unsigned  firstWord ) const,
  610.   words             ( unsigned  firstWord,
  611.                       unsigned  numWords  ) const;
  612.  
  613. unsigned
  614.   indexOfPhrase     ( const IString &wordString,
  615.                       unsigned       startWord = 1 ) const,
  616.  
  617.   indexOfWord       ( unsigned wordNumber ) const,
  618.  
  619.   lengthOfWord      ( unsigned wordNumber ) const,
  620.  
  621.   numWords          ( ) const,
  622.  
  623.   wordIndexOfPhrase ( const IString &aPhrase,
  624.                       unsigned       startWord = 1 ) const;
  625.  
  626. static IString
  627.   space             ( const IString &aString,
  628.                       unsigned       numSpaces = 1,
  629.                       char           spaceChar = ' ' ),
  630.  
  631.   removeWords       ( const IString &aString,
  632.                       unsigned       startWord ),
  633.   removeWords       ( const IString &aString,
  634.                       unsigned       startWord,
  635.                       unsigned       numWords  );
  636. #ifdef IC_NLS
  637. static void     enableInternationalization(Boolean enable = true),
  638.                 disableInternationalization();
  639.  
  640. static Boolean  isInternationalized();
  641. #endif
  642.  
  643. protected:
  644. /*------------------------- Utility Data -------------------------------------*/
  645. static const char
  646.  IC_IMPORTB * const null,
  647.  IC_IMPORTB * const zero,
  648.  IC_IMPORTB * const maxLong;
  649.  
  650. /*-------------------------- To Get at the nullBuffer ------------------------*/
  651. static const char * nullBuf();
  652.  
  653.  
  654. /*-------------------------- Initialize --------------------------------------*/
  655. IString
  656.  &setBuffer         ( IBuffer *ibuff ),
  657.  
  658.  &initBuffer        ( const void *p1,
  659.                       unsigned    len1,
  660.                       const void *p2      = 0,
  661.                       unsigned    len2    = 0,
  662.                       const void *p3      = 0,
  663.                       unsigned    len3    = 0,
  664.                       char        padChar = 0 ),
  665.  &initBuffer        ( long  aLong ),
  666.  &initBuffer        ( unsigned long  anUnsignedLong ),
  667. #ifdef _LONG_LONG
  668.  &initBuffer        ( long long  aLongLong ),
  669.  &initBuffer        ( unsigned long long  anUnsignedLongLong ),
  670. #endif
  671.  &initBuffer        ( double  aDouble );
  672.  
  673.  
  674. /*-------------------------- Protected Queries -------------------------------*/
  675. char
  676.  *data              ( ) const;
  677.  
  678. IBuffer
  679.  *buffer            ( ) const;
  680.  
  681. static unsigned
  682.   lengthOf          ( const char *pChar );
  683.  
  684. static char
  685.  *defaultBuffer     ( );
  686.  
  687.  
  688. /*------------------------- Protected Searches/Testing -----------------------*/
  689. typedef enum {
  690.   charIndex,
  691.   wordIndex
  692.   } IndexType;
  693.  
  694. unsigned
  695.   indexOfWord       ( unsigned wordNumber,
  696.                       unsigned startPos,
  697.                       unsigned numWords ) const,
  698.  
  699.   occurrencesOf     ( const char *pSearchString,
  700.                       unsigned    searchLen,
  701.                       unsigned    startPos ) const,
  702.  
  703.  
  704.   findPhrase        ( const IString &aPhrase,
  705.                       unsigned       startWord,
  706.                       IndexType      charOrWord ) const;
  707.  
  708. Boolean
  709.   isLike            ( const char *pPattern,
  710.                       unsigned    patternLen,
  711.                       char        zeroOrMore,
  712.                       char        anyChar ) const,
  713.  
  714.   isAbbrevFor       ( const char *pFullString,
  715.                       unsigned    fullLen,
  716.                       unsigned    minLen ) const;
  717.  
  718. /*------------------------- Protected Editing --------------------------------*/
  719. IString
  720.  &change            ( const char *pPattern,
  721.                       unsigned    patternLen,
  722.                       const char *pReplacement,
  723.                       unsigned    replacementLen,
  724.                       unsigned    startPos,
  725.                       unsigned    numChanges ),
  726.  
  727.  &insert            ( const char *pInsert,
  728.                       unsigned    insertLen,
  729.                       unsigned    startPos,
  730.                       char        padCharacter ),
  731.  
  732.  &overlayWith       ( const char *pOverlay,
  733.                       unsigned    overlayLen,
  734.                       unsigned    index,
  735.                       char        padCharacter ),
  736.  
  737.  &strip             ( const char             *pChar,
  738.                       unsigned                len,
  739.                       IStringEnum::StripMode  mode ),
  740.  
  741.  &strip             ( const IStringTest      &aTest,
  742.                       IStringEnum::StripMode  mode ),
  743.  
  744.  &translate         ( const char *pInputChars,
  745.                       unsigned    inputLen,
  746.                       const char *pOutputChars,
  747.                       unsigned    outputLen,
  748.                       char        padCharacter );
  749.  
  750.  
  751. /*------------------------- Bit Operations -----------------------------------*/
  752. typedef enum {
  753.   bitAnd,
  754.   bitOr,
  755.   bitExclusiveOr
  756. #if ( IC_OBSOLETE <= IC_OBSOLETE_2 )
  757. #ifndef __DIGRAPHS__
  758.   ,
  759.   and = bitAnd,
  760.   or  = bitOr,
  761.   exclusiveOr = bitExclusiveOr
  762. #endif
  763. #endif
  764.   } BitOperator;
  765.  
  766. IString
  767.  &applyBitOp        ( const char *pArg,
  768.                       unsigned    argLen,
  769.                       BitOperator op );
  770.  
  771.  
  772. private:
  773. /*----------------------------- Private --------------------------------------*/
  774.   IString           ( IBuffer *pBuffer );
  775. void
  776.   binaryMath        ( unsigned char newDigit ),
  777.   decimalMath       ( unsigned char newDigit );
  778. IString
  779.  &prepareToChange   ( );
  780. char
  781.  *pBuffer;
  782.  
  783. static void
  784.   setDefaultBuffer  ( char * );
  785.  
  786. static char
  787.   *nullBuffer;
  788.  
  789. friend class IBuffer;
  790.  
  791. #ifdef IC_NLS
  792. typedef enum {                     /*  I18N states definition   */
  793.   i18nOff = 0,
  794.   i18nOn
  795.   } I18NStates;
  796.  
  797. static I18NStates
  798.    fgI18NState;
  799. #endif
  800.  
  801.  
  802.  
  803.  
  804.  
  805.  
  806. }; // class IString
  807.  
  808.  
  809.  
  810. #pragma pack()
  811.  
  812.   #include <istring.inl>
  813.  
  814. #endif /* _ISTRING_ */
  815.  
  816.  
  817.  
  818.