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