home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / include / i0string.inl < prev    next >
Encoding:
Text File  |  1996-02-22  |  20.5 KB  |  532 lines
  1. #ifndef _I0STRING_INL_
  2. #define _I0STRING_INL_ 0
  3. /*******************************************************************************
  4. * FILE NAME: i0string.inl                                                      *
  5. *                                                                              *
  6. * DESCRIPTION:                                                                 *
  7. *   This file contains the definition of the inline functions for the          *
  8. *   classes declared in i0string.hpp.                                          *
  9. *                                                                              *
  10. * COPYRIGHT:                                                                   *
  11. *   IBM Open Class Library                                                     *
  12. *   (C) Copyright International Business Machines Corporation 1992, 1996       *
  13. *   Licensed Material - Program-Property of IBM - All Rights Reserved.         *
  14. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  15. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  16. *                                                                              *
  17. *******************************************************************************/
  18. #ifndef _I0STRING_
  19.   #undef  _I0STRING_INL_
  20.   #define _I0STRING_INL_ 1
  21.   #include <i0string.hpp>
  22. #endif
  23.  
  24. #include <istrtest.hpp>
  25.  
  26. #if _I0STRING_INL_
  27.   #define inline
  28. #endif
  29.  
  30. inline unsigned I0String :: adjustArg ( unsigned argIndex )
  31.   {
  32.   return argIndex + 1;
  33.   }
  34. inline unsigned I0String :: adjustResult ( unsigned resIndex )
  35.   {
  36.   return resIndex - 1;
  37.   }
  38.  
  39. inline signed I0String :: adjustArg ( signed argIndex )
  40.   {
  41.   return argIndex + 1;
  42.   }
  43. inline signed I0String :: adjustResult ( signed resIndex )
  44.   {
  45.   return resIndex - 1;
  46.   }
  47.  
  48. inline I0String :: I0String ( )
  49.   : IString( )
  50.   {
  51.   }
  52. inline I0String :: I0String ( const IString &aString )
  53.   : IString( aString )
  54.   {
  55.   }
  56. inline I0String :: I0String ( int anInt )
  57.   : IString( anInt )
  58.   {
  59.   }
  60. inline I0String :: I0String ( unsigned anUnsigned )
  61.   : IString( anUnsigned )
  62.   {
  63.   }
  64. inline I0String :: I0String ( long aLong )
  65.   : IString( aLong )
  66.   {
  67.   }
  68. inline I0String :: I0String ( unsigned long anUnsignedLong )
  69.   : IString( anUnsignedLong )
  70.   {
  71.   }
  72. #ifdef _LONG_LONG
  73. inline I0String :: I0String ( long long aLongLong )
  74.   : IString( aLongLong )
  75.   {
  76.   }
  77. inline I0String :: I0String ( unsigned long long anUnsignedLongLong )
  78.   : IString( anUnsignedLongLong )
  79.   {
  80.   }
  81. #endif
  82. inline I0String :: I0String ( short aShort )
  83.   : IString( aShort )
  84.   {
  85.   }
  86. inline I0String :: I0String ( unsigned short anUnsignedShort )
  87.   : IString( anUnsignedShort )
  88.   {
  89.   }
  90. inline I0String :: I0String ( double aDouble )
  91.   : IString( aDouble )
  92.   {
  93.   }
  94. inline I0String :: I0String ( char aChar )
  95.   : IString( aChar )
  96.   {
  97.   }
  98. inline I0String :: I0String ( unsigned char anUnsignedChar )
  99.   : IString( anUnsignedChar )
  100.   {
  101.   }
  102. inline I0String :: I0String ( signed char aSignedChar )
  103.   : IString( aSignedChar )
  104.   {
  105.   }
  106. inline I0String :: I0String ( const char *pChar )
  107.   : IString( pChar )
  108.   {
  109.   }
  110. inline I0String :: I0String ( const unsigned char *pUnsignedChar )
  111.   : IString( pUnsignedChar )
  112.   {
  113.   }
  114. inline I0String :: I0String ( const signed char *pSignedChar )
  115.   : IString( pSignedChar )
  116.   {
  117.   }
  118. inline I0String :: I0String ( const void *p1,
  119.                               unsigned    len1,
  120.                               char        padChar )
  121.   : IString( p1, len1, padChar )
  122.   {
  123.   }
  124. inline I0String :: I0String ( const void *p1,
  125.                               unsigned    len1,
  126.                               const void *p2,
  127.                               unsigned    len2,
  128.                               char        padChar )
  129.   : IString( p1, len1, p2, len2, padChar )
  130.   {
  131.   }
  132. inline I0String :: I0String ( const void *p1,
  133.                               unsigned    len1,
  134.                               const void *p2,
  135.                               unsigned    len2,
  136.                               const void *p3,
  137.                               unsigned    len3,
  138.                               char        padChar )
  139.   : IString( p1, len1, p2, len2, p3, len3, padChar )
  140.   {
  141.   }
  142.  
  143. inline I0String I0String :: subString ( unsigned startPos ) const
  144.   {
  145.   return IString::subString( adjustArg( startPos ) );
  146.   }
  147. inline I0String I0String :: subString ( unsigned startPos,
  148.                                         unsigned len,
  149.                                         char     padChar ) const
  150.   {
  151.   return IString::subString( adjustArg( startPos ), len, padChar );
  152.   }
  153. inline char &I0String :: operator [] ( unsigned index )
  154.   {
  155.   return IString::operator[]( adjustArg( index ) );
  156.   }
  157. inline const char &I0String :: operator [] ( unsigned index ) const
  158.   {
  159.   return IString::operator[]( adjustArg( index ) );
  160.   }
  161. inline char &I0String :: operator [] ( signed index )
  162.   {
  163.   return IString::operator[]( adjustArg( index ) );
  164.   }
  165. inline const char &I0String :: operator [] ( signed index ) const
  166.   {
  167.   return IString::operator[]( adjustArg( index ) );
  168.   }
  169. inline char &I0String :: operator [] ( unsigned long index )
  170.   {
  171.   return IString::operator[]( adjustArg( (unsigned) index ) );
  172.   }
  173. inline const char &I0String :: operator [] ( unsigned long index ) const
  174.   {
  175.   return IString::operator[]( adjustArg( (unsigned) index ) );
  176.   }
  177. inline char &I0String :: operator [] ( signed long index )
  178.   {
  179.   return IString::operator[]( adjustArg( (signed) index ) );
  180.   }
  181. inline const char &I0String :: operator [] ( signed long index ) const
  182.   {
  183.   return IString::operator[]( adjustArg( (signed) index ) );
  184.   }
  185. inline IStringEnum::CharType I0String :: charType ( unsigned index ) const
  186.   {
  187.   return IString::charType( adjustArg( index ) );
  188.   }
  189.  
  190. inline unsigned I0String :: indexOf ( const IString &aString,
  191.                                       unsigned       startPos ) const
  192.   {
  193.   return adjustResult( IString::indexOf( aString, adjustArg( startPos ) ) );
  194.   }
  195. inline unsigned I0String :: indexOf ( const char *pString,
  196.                                       unsigned    startPos ) const
  197.   {
  198.   return adjustResult( IString::indexOf( pString, adjustArg( startPos ) ) );
  199.   }
  200. inline unsigned I0String :: indexOf ( char     aChar,
  201.                                       unsigned startPos ) const
  202.   {
  203.   return adjustResult( IString::indexOf( aChar, adjustArg( startPos ) ) );
  204.   }
  205. inline unsigned I0String :: indexOf ( const IStringTest &aTest,
  206.                                       unsigned           startPos ) const
  207.   {
  208.   return adjustResult( IString::indexOf( aTest, adjustArg( startPos ) ) );
  209.   }
  210. inline unsigned I0String :: indexOfAnyBut ( const IString &aString,
  211.                                             unsigned       startPos ) const
  212.   {
  213.   return adjustResult( IString::indexOfAnyBut( aString,
  214.                                                adjustArg( startPos ) ) );
  215.   }
  216. inline unsigned I0String :: indexOfAnyBut ( const char *pString,
  217.                                             unsigned    startPos ) const
  218.   {
  219.   return adjustResult( IString::indexOfAnyBut( pString,
  220.                                                adjustArg( startPos ) ) );
  221.   }
  222. inline unsigned I0String :: indexOfAnyBut ( char     aChar,
  223.                                             unsigned startPos ) const
  224.   {
  225.   return adjustResult( IString::indexOfAnyBut( aChar,
  226.                                                adjustArg( startPos ) ) );
  227.   }
  228. inline unsigned I0String :: indexOfAnyBut ( const IStringTest &aTest,
  229.                                             unsigned           startPos ) const
  230.   {
  231.   return adjustResult( IString::indexOfAnyBut( aTest,
  232.                                                adjustArg( startPos ) ) );
  233.   }
  234. inline unsigned I0String :: indexOfAnyOf ( const IString &aString,
  235.                                            unsigned       startPos ) const
  236.   {
  237.   return adjustResult( IString::indexOfAnyOf( aString,
  238.                                               adjustArg( startPos ) ) );
  239.   }
  240. inline unsigned I0String :: indexOfAnyOf ( const char *pString,
  241.                                            unsigned    startPos ) const
  242.   {
  243.   return adjustResult( IString::indexOfAnyOf( pString,
  244.                                               adjustArg( startPos ) ) );
  245.   }
  246. inline unsigned I0String :: indexOfAnyOf ( char     aChar,
  247.                                            unsigned startPos ) const
  248.   {
  249.   return adjustResult( IString::indexOfAnyOf( aChar,
  250.                                               adjustArg( startPos ) ) );
  251.   }
  252. inline unsigned I0String :: indexOfAnyOf ( const IStringTest &aTest,
  253.                                            unsigned           startPos ) const
  254.   {
  255.   return adjustResult( IString::indexOfAnyOf( aTest,
  256.                                               adjustArg( startPos ) ) );
  257.   }
  258. inline unsigned I0String :: lastIndexOf ( const IString &aString,
  259.                                           unsigned       startPos ) const
  260.   {
  261.   return adjustResult( IString::lastIndexOf( aString,
  262.                                              adjustArg( startPos ) ) );
  263.   }
  264. inline unsigned I0String :: lastIndexOf ( const char *pString,
  265.                                           unsigned    startPos ) const
  266.   {
  267.   return adjustResult( IString::lastIndexOf( pString,
  268.                                              adjustArg( startPos ) ) );
  269.   }
  270. inline unsigned I0String :: lastIndexOf ( char     aChar,
  271.                                           unsigned startPos ) const
  272.   {
  273.   return adjustResult( IString::lastIndexOf( aChar,
  274.                                              adjustArg( startPos ) ) );
  275.   }
  276. inline unsigned I0String :: lastIndexOf ( const IStringTest &aTest,
  277.                                           unsigned           startPos ) const
  278.   {
  279.   return adjustResult( IString::lastIndexOf( aTest,
  280.                                              adjustArg( startPos ) ) );
  281.   }
  282. inline unsigned I0String :: lastIndexOfAnyBut ( const IString &aString,
  283.                                                 unsigned       startPos ) const
  284.   {
  285.   return adjustResult( IString::lastIndexOfAnyBut( aString,
  286.                                                    adjustArg( startPos ) ) );
  287.   }
  288. inline unsigned I0String :: lastIndexOfAnyBut ( const char *pString,
  289.                                                 unsigned    startPos ) const
  290.   {
  291.   return adjustResult( IString::lastIndexOfAnyBut( pString,
  292.                                                    adjustArg( startPos ) ) );
  293.   }
  294. inline unsigned I0String :: lastIndexOfAnyBut ( char     aChar,
  295.                                                 unsigned startPos ) const
  296.   {
  297.   return adjustResult( IString::lastIndexOfAnyBut( aChar,
  298.                                                    adjustArg( startPos ) ) );
  299.   }
  300. inline unsigned I0String :: lastIndexOfAnyBut ( const IStringTest &aTest,
  301.                                                 unsigned      startPos ) const
  302.   {
  303.   return adjustResult( IString::lastIndexOfAnyBut( aTest,
  304.                                                    adjustArg( startPos ) ) );
  305.   }
  306. inline unsigned I0String :: lastIndexOfAnyOf ( const IString &aString,
  307.                                                unsigned       startPos ) const
  308.   {
  309.   return adjustResult( IString::lastIndexOfAnyOf( aString,
  310.                                                   adjustArg( startPos ) ) );
  311.   }
  312. inline unsigned I0String :: lastIndexOfAnyOf ( const char *pString,
  313.                                                unsigned    startPos ) const
  314.   {
  315.   return adjustResult( IString::lastIndexOfAnyOf( pString,
  316.                                                   adjustArg( startPos ) ) );
  317.   }
  318. inline unsigned I0String :: lastIndexOfAnyOf ( char     aChar,
  319.                                                unsigned startPos ) const
  320.   {
  321.   return adjustResult( IString::lastIndexOfAnyOf( aChar,
  322.                                                   adjustArg( startPos ) ) );
  323.   }
  324. inline unsigned I0String :: lastIndexOfAnyOf ( const IStringTest &aTest,
  325.                                                unsigned       startPos ) const
  326.   {
  327.   return adjustResult( IString::lastIndexOfAnyOf( aTest,
  328.                                                   adjustArg( startPos ) ) );
  329.   }
  330. inline unsigned I0String :: occurrencesOf ( const IString &aString,
  331.                                             unsigned       startPos ) const
  332.   {
  333.   return IString::occurrencesOf( aString,
  334.                                  adjustArg( startPos ) );
  335.   }
  336. inline unsigned I0String :: occurrencesOf ( const char    *pString,
  337.                                             unsigned       startPos ) const
  338.   {
  339.   return IString::occurrencesOf( pString,
  340.                                  adjustArg( startPos ) );
  341.   }
  342. inline unsigned I0String :: occurrencesOf ( char     aChar,
  343.                                             unsigned startPos ) const
  344.   {
  345.   return IString::occurrencesOf( aChar,
  346.                                  adjustArg( startPos ) );
  347.   }
  348. inline unsigned I0String :: occurrencesOf ( const IStringTest &aTest,
  349.                                             unsigned           startPos ) const
  350.   {
  351.   return IString::occurrencesOf( aTest,
  352.                                  adjustArg( startPos ) );
  353.   }
  354. inline I0String &I0String :: change ( const IString &aPattern,
  355.                                       const IString &aReplacement,
  356.                                       unsigned       startPos,
  357.                                       unsigned       numChanges )
  358.   {
  359.   IString::change( aPattern,
  360.                    aReplacement,
  361.                    adjustArg( startPos ),
  362.                    numChanges );
  363.  
  364.   return *this;
  365.   }
  366. inline I0String &I0String :: change ( const IString &aPattern,
  367.                                       const char    *pReplacement,
  368.                                       unsigned       startPos,
  369.                                       unsigned       numChanges )
  370.   {
  371.   IString::change( aPattern,
  372.                    pReplacement,
  373.                    adjustArg( startPos ),
  374.                    numChanges );
  375.  
  376.   return *this;
  377.   }
  378. inline I0String &I0String :: change ( const char    *pPattern,
  379.                                       const IString &aReplacement,
  380.                                       unsigned       startPos,
  381.                                       unsigned       numChanges )
  382.   {
  383.   IString::change( pPattern,
  384.                    aReplacement,
  385.                    adjustArg( startPos ),
  386.                    numChanges );
  387.   return *this;
  388.   }
  389. inline I0String &I0String :: change ( const char    *pPattern,
  390.                                       const char    *pReplacement,
  391.                                       unsigned       startPos,
  392.                                       unsigned       numChanges )
  393.   {
  394.   IString::change( pPattern,
  395.                    pReplacement,
  396.                    adjustArg( startPos ),
  397.                    numChanges );
  398.   return *this;
  399.   }
  400. inline I0String &I0String :: insert ( const IString &aString,
  401.                                       unsigned       index,
  402.                                       char           padCharacter )
  403.   {
  404.   IString::insert( aString, adjustArg( index ), padCharacter );
  405.   return *this;
  406.   }
  407. inline I0String &I0String :: insert ( const char    *pString,
  408.                                       unsigned       index,
  409.                                       char           padCharacter )
  410.   {
  411.   IString::insert( pString, adjustArg( index ), padCharacter );
  412.   return *this;
  413.   }
  414. inline I0String &I0String :: overlayWith ( const IString &aString,
  415.                                            unsigned       index,
  416.                                            char           padCharacter )
  417.   {
  418.   IString::overlayWith( aString, adjustArg( index ), padCharacter );
  419.   return *this;
  420.   }
  421. inline I0String &I0String :: overlayWith ( const char    *pString,
  422.                                            unsigned       index,
  423.                                            char           padCharacter )
  424.   {
  425.   IString::overlayWith( pString, adjustArg( index ), padCharacter );
  426.   return *this;
  427.   }
  428. inline I0String &I0String :: remove ( unsigned startPos )
  429.   {
  430.   IString::remove( startPos == (unsigned)UINT_MAX ?
  431.                    startPos : adjustArg( startPos ) );
  432.   return *this;
  433.   }
  434. inline I0String &I0String :: remove ( unsigned startPos,
  435.                                       unsigned numChars )
  436.   {
  437.   IString::remove( startPos == (unsigned)UINT_MAX ?
  438.                    startPos : adjustArg( startPos ), numChars );
  439.   return *this;
  440.   }
  441. inline I0String I0String :: change ( const IString &aString,
  442.                                      const IString &inputString,
  443.                                      const IString &outputString,
  444.                                      unsigned       startPos,
  445.                                      unsigned       numChanges )
  446.   {
  447.   I0String result( aString );
  448.   return result.change( inputString, outputString, startPos, numChanges );
  449.   }
  450. inline I0String I0String :: change ( const IString &aString,
  451.                                      const IString &inputString,
  452.                                      const char    *pOutputString,
  453.                                      unsigned       startPos,
  454.                                      unsigned       numChanges)
  455.   {
  456.   I0String result( aString );
  457.   return result.change( inputString, pOutputString, startPos, numChanges );
  458.   }
  459. inline I0String I0String :: change ( const IString &aString,
  460.                                      const char    *pInputString,
  461.                                      const IString &outputString,
  462.                                      unsigned       startPos,
  463.                                      unsigned       numChanges)
  464.   {
  465.   I0String result( aString );
  466.   return result.change( pInputString, outputString, startPos, numChanges );
  467.   }
  468. inline I0String I0String :: change ( const IString &aString,
  469.                                      const char    *pInputString,
  470.                                      const char    *pOutputString,
  471.                                      unsigned       startPos,
  472.                                      unsigned       numChanges )
  473.   {
  474.   I0String result( aString );
  475.   return result.change( pInputString, pOutputString, startPos, numChanges );
  476.   }
  477. inline I0String I0String :: insert ( const IString &aString,
  478.                                      const IString &anInsert,
  479.                                      unsigned       index,
  480.                                      char           padCharacter )
  481.   {
  482.   I0String result( aString );
  483.   return result.insert( anInsert, index, padCharacter );
  484.   }
  485. inline I0String I0String :: insert ( const IString &aString,
  486.                                      const char    *pInsert,
  487.                                      unsigned       index,
  488.                                      char           padCharacter )
  489.   {
  490.   I0String result( aString );
  491.   return result.insert( pInsert, index, padCharacter );
  492.   }
  493. inline I0String I0String :: overlayWith ( const IString &aString,
  494.                                           const IString &anOverlay,
  495.                                           unsigned       index,
  496.                                           char           padCharacter )
  497.   {
  498.   I0String result( aString );
  499.   return result.overlayWith( anOverlay, index, padCharacter );
  500.   }
  501. inline I0String I0String :: overlayWith ( const IString &aString,
  502.                                           const char    *pOverlay,
  503.                                           unsigned       index,
  504.                                           char           padCharacter )
  505.   {
  506.   I0String result( aString );
  507.   return result.overlayWith( pOverlay, index, padCharacter );
  508.   }
  509. inline I0String I0String :: remove ( const IString &aString,
  510.                                      unsigned       startPos )
  511.   {
  512.   I0String result( aString );
  513.   return result.remove( startPos );
  514.   }
  515. inline I0String I0String :: remove ( const IString &aString,
  516.                                      unsigned       startPos,
  517.                                      unsigned       numChars )
  518.   {
  519.   I0String result( aString );
  520.   return result.remove( startPos, numChars );
  521.   }
  522. inline unsigned I0String :: indexOfPhrase ( const IString &wordString,
  523.                                             unsigned       startWord ) const
  524.   {
  525.   return adjustResult( IString::indexOfPhrase( wordString, startWord ) );
  526.   }
  527. inline unsigned I0String :: indexOfWord ( unsigned wordNumber ) const
  528.   {
  529.   return adjustResult( IString::indexOfWord( wordNumber ) );
  530.   }
  531. #endif // _I0STRING_INL_
  532.