home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / IBMCLASS / ISTRING.INL < prev    next >
Text File  |  1993-10-22  |  37KB  |  969 lines
  1. #ifndef _ISTRING_INL_
  2. #define _ISTRING_INL_ 0
  3. /*******************************************************************************
  4. * FILE NAME: istring.inl                                                       *
  5. *                                                                              *
  6. * DESCRIPTION:                                                                 *
  7. *   Definition of the inline functions declared in <irect.hpp>.                *
  8. *                                                                              *
  9. * COPYRIGHT:                                                                   *
  10. *   Licensed Materials - Property of IBM                                       *
  11. *   (C) Copyright IBM Corporation 1992, 1993                                   *
  12. *   All Rights Reserved                                                        *
  13. *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  14. *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  15. *                                                                              *
  16. *******************************************************************************/
  17. extern "C"
  18.   {
  19.   #include <ctype.h>
  20.   #include <limits.h>
  21.   #include <string.h>
  22.   #include <stdlib.h>
  23.   }
  24.  
  25. #ifndef _ISTRING_
  26.   #undef _ISTRING_INL_
  27.   #define _ISTRING_INL_ 1
  28.   #include <istring.hpp>
  29. #endif
  30.  
  31. #ifndef _IEXCBASE_
  32.   #include <iexcbase.hpp>
  33. #endif
  34.  
  35. #ifndef _IBUFFER_
  36.   #include <ibuffer.hpp>
  37. #endif
  38.  
  39. #ifndef _ISTRTEST_
  40.   #include <istrtest.hpp>
  41. #endif
  42.  
  43. #if _ISTRING_INL_
  44.   #define inline
  45. #endif
  46.  
  47. /*------------------------------ Implementation ------------------------------*/
  48. inline IBuffer *IString :: buffer( ) const
  49.   {
  50.   #ifdef IC_DEVELOP
  51.     IASSERT( pBuffer != 0 );
  52.   #endif
  53.   return IBuffer::fromContents( pBuffer );
  54.   }
  55. inline char *IString::defaultBuffer ( )
  56.   {
  57.   return ( nullBuffer ) ? 
  58.            nullBuffer 
  59.            : 
  60.            ( nullBuffer = IBuffer::defaultBuffer()->contents() );
  61.   }
  62. inline char *IString :: data ( ) const
  63.   {
  64.   return pBuffer;
  65.   }
  66. inline unsigned IString :: lengthOf ( const char *p )
  67.   {
  68.   return p ? strlen( p ) : 0;
  69.   }
  70. inline IString &IString :: setBuffer( IBuffer *ibuff )
  71.   {
  72.   #ifdef IC_DEVELOP
  73.     IASSERT( ibuff != 0 );
  74.   #endif
  75.   pBuffer = ibuff->contents();
  76.   return *this;
  77.   }
  78. inline void IString :: setDefaultBuffer ( char *newDefaultBuffer )
  79.   {
  80.   nullBuffer = newDefaultBuffer;
  81.   }
  82. inline void IBuffer :: setDefaultBuffer ( IBuffer *newDefaultBuffer )
  83.   {
  84.   #ifdef IC_DEVELOP
  85.     IASSERT( newDefaultBuffer->len == 0 && newDefaultBuffer->data[0] == 0 );
  86.   #endif
  87.   if ( IBuffer::nullBuffer )
  88.     IBuffer::nullBuffer -> removeRef();
  89.   IBuffer::nullBuffer = newDefaultBuffer;
  90.   IString::setDefaultBuffer( newDefaultBuffer->data );
  91.   }
  92. /*-------------------------------- Accessors ---------------------------------*/
  93. inline unsigned IString :: length ( ) const
  94.   {
  95.   return this->buffer() -> length();
  96.   }
  97. inline unsigned IString :: size ( ) const
  98.   {
  99.   return this->buffer() -> length();
  100.   }
  101. inline IStringEnum::CharType IString :: charType ( unsigned index ) const
  102.   {
  103.   return this->buffer() -> charType( index );
  104.   }
  105. /*-------------------------------- Searching ---------------------------------*/
  106. inline unsigned IString :: indexOf ( const IString &aString,
  107.                                      unsigned       startPos ) const
  108.   {
  109.   return this->buffer()->indexOf( aString.data(),             
  110.                                   aString.length(),
  111.                                   startPos );
  112.   }
  113. inline unsigned IString :: indexOf ( const char *pString,
  114.                                      unsigned    startPos ) const
  115.   {
  116.   return this->buffer()->indexOf( pString,                    
  117.                                   lengthOf( pString ),
  118.                                   startPos );
  119.   }
  120. inline unsigned IString :: indexOf ( const IStringTest &aTest,
  121.                                      unsigned           startPos ) const
  122.   {
  123.   return this->buffer()->indexOf( aTest,                      
  124.                                   startPos );
  125.   }
  126. inline unsigned IString :: indexOfAnyBut ( const IString &aString,
  127.                                            unsigned       startPos ) const
  128.   {
  129.   return this->buffer()->indexOfAnyBut( aString.data(),       
  130.                                         aString.length(),
  131.                                         startPos );
  132.   }
  133. inline unsigned IString :: indexOfAnyBut ( const char *pValidChars,
  134.                                            unsigned    startPos ) const
  135.   {
  136.   return this->buffer()->indexOfAnyBut( pValidChars,          
  137.                                         lengthOf( pValidChars ),
  138.                                         startPos );
  139.   }
  140. inline unsigned IString :: indexOfAnyBut ( char     validChar,
  141.                                            unsigned startPos ) const
  142.   {
  143.   return this->buffer()->indexOfAnyBut( &validChar,           
  144.                                         1,
  145.                                         startPos );
  146.   }
  147. inline unsigned IString :: indexOfAnyBut ( const IStringTest &aTest,
  148.                                            unsigned           startPos ) const
  149.   {
  150.   return this->buffer()->indexOfAnyBut( aTest,                
  151.                                         startPos );
  152.   }
  153. inline unsigned IString :: indexOfAnyOf ( const IString &aString,
  154.                                           unsigned       startPos ) const
  155.   {
  156.   return this->buffer()->indexOfAnyOf( aString.data(),        
  157.                                        aString.length(),
  158.                                        startPos );
  159.   }
  160. inline unsigned IString :: indexOfAnyOf ( const char *pSearchChars,
  161.                                           unsigned    startPos ) const
  162.   {
  163.   return this->buffer()->indexOfAnyOf( pSearchChars,          
  164.                                        lengthOf( pSearchChars ),
  165.                                        startPos );
  166.   }
  167. inline unsigned IString :: indexOfAnyOf ( char     searchChar,
  168.                                           unsigned startPos ) const
  169.   {
  170.   return this->buffer()->indexOfAnyOf( &searchChar,           
  171.                                        1,
  172.                                        startPos );
  173.   }
  174. inline unsigned IString :: indexOfAnyOf ( const IStringTest &aTest,
  175.                                           unsigned           startPos ) const
  176.   {
  177.   return this->buffer()->indexOfAnyOf( aTest,                 
  178.                                        startPos );
  179.   }
  180. inline unsigned IString :: lastIndexOf ( const IString &aString,
  181.                                          unsigned       startPos ) const
  182.   {
  183.   return this->buffer()->lastIndexOf( aString.data(),         
  184.                                       aString.length(),
  185.                                       startPos );
  186.   }
  187. inline unsigned IString :: lastIndexOf ( const char *pString,
  188.                                          unsigned    startPos ) const
  189.   {
  190.   return this->buffer()->lastIndexOf( pString,                
  191.                                       lengthOf( pString ),
  192.                                       startPos );
  193.   }
  194. inline unsigned IString :: lastIndexOf ( const IStringTest &aTest,
  195.                                          unsigned           startPos ) const
  196.   {
  197.   return this->buffer()->lastIndexOf( aTest,                  
  198.                                       startPos );
  199.   }
  200. inline unsigned IString :: lastIndexOfAnyBut ( const IString &aString,
  201.                                                unsigned       startPos ) const
  202.   {
  203.   return this->buffer()->lastIndexOfAnyBut( aString.data(),   
  204.                                             aString.length(),
  205.                                             startPos );
  206.   }
  207. inline unsigned IString :: lastIndexOfAnyBut ( const char *pValidChars,
  208.                                                unsigned    startPos ) const
  209.   {
  210.   return this->buffer()->lastIndexOfAnyBut( pValidChars,      
  211.                                             lengthOf( pValidChars ),
  212.                                             startPos );
  213.   }
  214. inline unsigned IString :: lastIndexOfAnyBut ( char     validChar,
  215.                                                unsigned startPos ) const
  216.   {
  217.   return this->buffer()->lastIndexOfAnyBut( &validChar,       
  218.                                             1,
  219.                                             startPos );
  220.   }
  221. inline unsigned IString :: lastIndexOfAnyBut ( const IStringTest &aTest,
  222.                                                unsigned           startPos ) const
  223.   {
  224.   return this->buffer()->lastIndexOfAnyBut( aTest,            
  225.                                            startPos );
  226.   }
  227. inline unsigned IString :: lastIndexOfAnyOf ( const IString &aString,
  228.                                               unsigned       startPos ) const
  229.   {
  230.   return this->buffer()->lastIndexOfAnyOf( aString.data(),    
  231.                                            aString.length(),
  232.                                            startPos );
  233.   }
  234. inline unsigned IString :: lastIndexOfAnyOf ( const char *pSearchChars,
  235.                                               unsigned    startPos ) const
  236.   {
  237.   return this->buffer()->lastIndexOfAnyOf( pSearchChars,      
  238.                                            lengthOf( pSearchChars ),
  239.                                            startPos );
  240.   }
  241. inline unsigned IString :: lastIndexOfAnyOf ( char     searchChar,
  242.                                               unsigned startPos ) const
  243.   {
  244.   return this->buffer()->lastIndexOfAnyOf( &searchChar,       
  245.                                            1,
  246.                                            startPos );
  247.   }
  248. inline unsigned IString :: lastIndexOfAnyOf ( const IStringTest &aTest,
  249.                                               unsigned           startPos ) const
  250.   {
  251.   return this->buffer()->lastIndexOfAnyOf( aTest,             
  252.                                            startPos );
  253.   }
  254. inline unsigned IString :: occurrencesOf ( const IString &aString,
  255.                                            unsigned       startPos ) const
  256.   {
  257.   return this->occurrencesOf( aString.data(),
  258.                               aString.length(),
  259.                               startPos );
  260.   }
  261. inline unsigned IString :: occurrencesOf ( const char *pString,
  262.                                            unsigned    startPos ) const
  263.   {
  264.   return this->occurrencesOf( pString,
  265.                               lengthOf( pString ),
  266.                               startPos );
  267.   }
  268. /*--------------------------------- Testing ----------------------------------*/
  269. inline IBase::Boolean IString :: isAlphanumeric ( ) const
  270.   { return this->buffer()->isAlphanumeric(); }
  271. inline IBase::Boolean IString :: isAlphabetic ( ) const
  272.   { return this->buffer()->isAlphabetic(); }
  273. inline IBase::Boolean IString :: isASCII ( ) const
  274.   { return this->buffer()->isASCII(); }
  275. inline IBase::Boolean IString :: isControl ( ) const
  276.   { return this->buffer()->isControl(); }
  277. inline IBase::Boolean IString :: isDigits ( ) const
  278.   { return this->buffer()->isDigits(); }                      
  279. inline IBase::Boolean IString :: isGraphics ( ) const
  280.   { return this->buffer()->isGraphics(); }                    
  281. inline IBase::Boolean IString :: isHexDigits ( ) const
  282.   { return this->buffer()->isHexDigits(); }                   
  283. inline IBase::Boolean IString :: isLowerCase ( ) const
  284.   { return this->buffer()->isLowerCase(); }                   
  285. inline IBase::Boolean IString :: isPrintable ( ) const
  286.   { return this->buffer()->isPrintable(); }                   
  287. inline IBase::Boolean IString :: isPunctuation ( ) const
  288.   { return this->buffer()->isPunctuation(); }                
  289. inline IBase::Boolean IString :: isUpperCase ( ) const
  290.   { return this->buffer()->isUpperCase(); }                   
  291. inline IBase::Boolean IString :: isWhiteSpace ( ) const
  292.   { return this->buffer()->isWhiteSpace(); }                  
  293. inline IBase::Boolean IString :: isDBCS ( ) const
  294.   { return this->buffer()->isDBCS(); }
  295. inline IBase::Boolean IString :: isSBCS ( ) const
  296.   { return this->buffer()->isSBCS(); }
  297. inline IBase::Boolean IString :: isValidDBCS ( ) const
  298.   { return this->buffer()->isValidDBCS(); }
  299. inline IBase::Boolean IString :: includesDBCS ( ) const
  300.   { return this->buffer()->includesDBCS(); }
  301. inline IBase::Boolean IString :: includesSBCS ( ) const
  302.   { return this->buffer()->includesSBCS(); }
  303. inline IBase::Boolean IString :: isLike ( const IString &aPattern,
  304.                                           char           zeroOrMore,
  305.                                           char           anyChar ) const
  306.   {
  307.   return this->isLike( aPattern.data(),
  308.                        aPattern.length(),
  309.                        zeroOrMore,
  310.                        anyChar );
  311.   }
  312. inline IBase::Boolean IString :: isLike ( const char *pPattern,
  313.                                           char        zeroOrMore,
  314.                                           char        anyChar ) const
  315.   {
  316.   return this->isLike( pPattern,
  317.                        lengthOf(pPattern),
  318.                        zeroOrMore,
  319.                        anyChar );
  320.   }
  321. inline IBase::Boolean IString :: isAbbreviationFor ( const IString &aString,
  322.                                                      unsigned       minAbbrevLength ) const
  323.   {
  324.   return this->isAbbrevFor( aString.data(),
  325.                             aString.length(),
  326.                             minAbbrevLength );
  327.   }
  328. inline IBase::Boolean IString :: isAbbreviationFor ( const char *pString,
  329.                                                      unsigned    minAbbrevLength ) const
  330.   {
  331.   return this->isAbbrevFor( pString,
  332.                             lengthOf( pString ),
  333.                             minAbbrevLength );
  334.   }
  335. inline IBase::Boolean IString :: includes ( const IString &aString ) const
  336.   {
  337.   return this->indexOf( aString );
  338.   }
  339. inline IBase::Boolean IString :: includes ( const char *pString ) const
  340.   {
  341.   return this->indexOf( pString );
  342.   }
  343. inline IBase::Boolean IString :: includes ( char aChar ) const
  344.   {
  345.   return this->indexOf( aChar );
  346.   }
  347. inline IBase::Boolean IString :: includes ( const IStringTest &aTest ) const
  348.   {
  349.   return this->indexOf( aTest );
  350.   }
  351. /*--------------------------- Comparison Operators ---------------------------*/
  352. inline IBase::Boolean operator == ( const IString &string1, const IString &string2 )
  353.   {
  354.   return ( string1.buffer()->compare( string2.data(),       
  355.                                      string2.length() ) == IBuffer::equal );
  356.   }
  357. inline IBase::Boolean operator == ( const IString &string1, const char *pString2 )
  358.   {
  359.   return
  360.     ( string1.buffer()->compare( pString2,                  
  361.                                  IString::lengthOf( pString2 ) )
  362.       == IBuffer::equal );
  363.   }
  364. inline IBase::Boolean operator == ( const char *pString1, const IString &string2 )
  365.   {
  366.   return
  367.     ( string2.buffer()->compare( pString1,                  
  368.                                  IString::lengthOf( pString1 ) )
  369.       == IBuffer::equal );
  370.   }
  371. inline IBase::Boolean operator != ( const IString &string1, const IString &string2 )
  372.   {
  373.   return !( string1 == string2 );
  374.   }
  375. inline IBase::Boolean operator != ( const IString &string1, const char *pString2 )
  376.   {
  377.   return !( string1 == pString2 );
  378.   }
  379. inline IBase::Boolean operator != ( const char *pString1, const IString &string2 )
  380.   {
  381.   return !( pString1 == string2 );
  382.   }
  383. inline IBase::Boolean operator >  ( const IString &string1, const IString &string2 )
  384.   {
  385.   return
  386.     ( string1.buffer()->compare( string2.data(),            
  387.                                  string2.length() )
  388.       == IBuffer::greaterThan );
  389.   }
  390. inline IBase::Boolean operator >  ( const IString &string1, const char *pString2 )
  391.   {
  392.   return
  393.     ( string1.buffer()->compare( pString2,                  
  394.                                  IString::lengthOf( pString2 ) )
  395.       == IBuffer::greaterThan );
  396.   }
  397. inline IBase::Boolean operator >  ( const char *pString1, const IString &string2 )
  398.   {
  399.   return
  400.     ( string2.buffer()->compare( pString1,                  
  401.                                  IString::lengthOf( pString1 ) )
  402.       == IBuffer::lessThan );
  403.   }
  404. inline IBase::Boolean operator >= ( const IString &string1, const IString &string2 )
  405.   {
  406.   return !
  407.     ( string1.buffer()->compare( string2.data(),            
  408.                                  string2.length() )
  409.       == IBuffer::lessThan );
  410.   }
  411. inline IBase::Boolean operator >= ( const IString &string1, const char *pString2 )
  412.   {
  413.   return !
  414.     ( string1.buffer()->compare( pString2,                  
  415.                                  IString::lengthOf( pString2 ) )
  416.       == IBuffer::lessThan );
  417.   }
  418. inline IBase::Boolean operator >= ( const char *pString1, const IString &string2 )
  419.   {
  420.   return !
  421.     ( string2.buffer()->compare( pString1,                  
  422.                                  IString::lengthOf( pString1 ) )
  423.       == IBuffer::greaterThan );
  424.   }
  425. inline IBase::Boolean operator <  ( const IString &string1, const IString &string2 )
  426.   {
  427.   return !( string1 >= string2 );
  428.   }
  429. inline IBase::Boolean operator <  ( const IString &string1, const char *pString2 )
  430.   {
  431.   return !( string1 >= pString2 );
  432.   }
  433. inline IBase::Boolean operator <  ( const char *pString1, const IString &string2 )
  434.   {
  435.   return !( pString1 >= string2 );
  436.   }
  437. inline IBase::Boolean operator <= ( const IString &string1, const IString &string2 )
  438.   {
  439.   return !( string1 > string2 );
  440.   }
  441. inline IBase::Boolean operator <= ( const IString &string1, const char *pString2 )
  442.   {
  443.   return !( string1 > pString2 );
  444.   }
  445. inline IBase::Boolean operator <= ( const char *pString1, const IString &string2 )
  446.   {
  447.   return !( pString1 > string2 );
  448.   }
  449. /*-------------------------------- Conversion --------------------------------*/
  450. inline IString IString :: asString ( ) const
  451.   {
  452.   return *this;
  453.   }
  454. inline long int IString :: asInt ( ) const
  455.   {
  456.   return strtol( this->data(), 0, 10 );
  457.   }
  458. inline unsigned long IString :: asUnsigned ( ) const
  459.   {
  460.   return strtoul( this->data(), 0, 10 );
  461.   }
  462. inline double IString :: asDouble ( ) const
  463.   {
  464.   return strtod( this->data(), 0 );
  465.   }
  466. inline IString :: operator char* ( ) const
  467.   {
  468.   return this->data();
  469.   }
  470. inline IString :: operator unsigned char* ( ) const
  471.   {
  472.   return (unsigned char*) this->data();
  473.   }
  474. inline IString :: operator signed char* ( ) const
  475.   {
  476.   return (signed char*) this->data();
  477.   }
  478. inline IString IString :: c2b( const IString &aString )
  479.   {
  480.   return IString(aString).c2b();
  481.   }
  482. inline IString IString :: c2d( const IString &aString )
  483.   {
  484.   return IString(aString).c2d();
  485.   }
  486. inline IString IString :: c2x( const IString &aString )
  487.   {
  488.   return IString(aString).c2x();
  489.   }
  490. inline IString IString :: b2c( const IString &aString )
  491.   {
  492.   return IString(aString).b2c();
  493.   }
  494. inline IString & IString :: b2d ( )
  495.   {
  496.   this->b2c().c2d();
  497.   return *this;
  498.   }
  499. inline IString IString :: b2d( const IString &aString )
  500.   {
  501.   return IString(aString).b2d();
  502.   }
  503. inline IString & IString :: b2x ( )
  504.   {
  505.   this->b2c().c2x();
  506.   return *this;
  507.   }
  508. inline IString IString :: b2x( const IString &aString )
  509.   {
  510.   return IString(aString).b2x();
  511.   }
  512. inline IString IString :: d2c( const IString &aString )
  513.   {
  514.   return IString(aString).d2c();
  515.   }
  516. inline IString & IString :: d2b ( )
  517.   {
  518.   this->d2c().c2b();
  519.   return *this;
  520.   }
  521. inline IString IString :: d2b( const IString &aString )
  522.   {
  523.   return IString(aString).d2b();
  524.   }
  525. inline IString & IString :: d2x ( )
  526.   {
  527.   this->d2c().c2x();
  528.   return *this;
  529.   }
  530. inline IString IString :: d2x( const IString &aString )
  531.   {
  532.   return IString(aString).d2x();
  533.   }
  534. inline IString IString :: x2c( const IString &aString )
  535.   {
  536.   return IString(aString).x2c();
  537.   }
  538. inline IString & IString :: x2b ( )
  539.   {
  540.   this->x2c().c2b();
  541.   return *this;
  542.   }
  543. inline IString IString :: x2b( const IString &aString )
  544.   {
  545.   return IString(aString).x2b();
  546.   }
  547. inline IString & IString :: x2d ( )
  548.   {
  549.   this->x2c().c2d();
  550.   return *this;
  551.   }
  552. inline IString IString :: x2d( const IString &aString )
  553.   {
  554.   return IString(aString).x2d();
  555.   }
  556. /*--------------------------------- Editing ----------------------------------*/
  557. inline IString & IString :: change ( const IString &aPattern,
  558.                                      const IString &aReplacement,
  559.                                      unsigned       startPos,
  560.                                      unsigned       numChanges )
  561.   {
  562.   return this->change( aPattern.data(),
  563.                        aPattern.length(),
  564.                        aReplacement.data(),
  565.                        aReplacement.length(),
  566.                        startPos,
  567.                        numChanges );
  568.   }
  569. inline IString & IString :: change ( const IString &aPattern,
  570.                                      const char    *pReplacement,
  571.                                      unsigned       startPos,
  572.                                      unsigned       numChanges )
  573.   {
  574.   return this->change( aPattern.data(),
  575.                        aPattern.length(),
  576.                        pReplacement,
  577.                        lengthOf( pReplacement ),
  578.                        startPos,
  579.                        numChanges );
  580.   }
  581. inline IString & IString :: change ( const char    *pPattern,
  582.                                      const IString &aReplacement,
  583.                                      unsigned       startPos,
  584.                                      unsigned       numChanges )
  585.   {
  586.   return this->change( pPattern,
  587.                        lengthOf( pPattern ),
  588.                        aReplacement.data(),
  589.                        aReplacement.length(),
  590.                        startPos,
  591.                        numChanges );
  592.   }
  593. inline IString & IString :: change ( const char *pPattern,
  594.                                      const char *pReplacement,
  595.                                      unsigned    startPos,
  596.                                      unsigned    numChanges )
  597.   {
  598.   return this->change( pPattern,
  599.                        lengthOf( pPattern ),
  600.                        pReplacement,
  601.                        lengthOf( pReplacement ),
  602.                        startPos,
  603.                        numChanges );
  604.   }
  605. inline IString IString :: change ( const IString &aString,
  606.                         const IString &aPattern,
  607.                         const char    *pReplacement,
  608.                         unsigned       startPos,
  609.                         unsigned       numChanges )
  610.   {
  611.   return IString(aString).change( aPattern,
  612.                                   pReplacement,
  613.                                   startPos,
  614.                                   numChanges );
  615.   }
  616. inline IString IString :: change ( const IString &aString,
  617.                         const char    *pPattern,
  618.                         const IString &aReplacement,
  619.                         unsigned       startPos,
  620.                         unsigned       numChanges )
  621.   {
  622.   return IString(aString).change( pPattern,
  623.                                   aReplacement,
  624.                                   startPos,
  625.                                   numChanges );
  626.   }
  627. inline IString IString :: change ( const IString &aString,
  628.                         const char    *pPattern,
  629.                         const char    *pReplacement,
  630.                         unsigned       startPos,
  631.                         unsigned       numChanges )
  632.   {
  633.   return IString(aString).change( pPattern,
  634.                                   pReplacement,
  635.                                   startPos,
  636.                                   numChanges );
  637.   }
  638. inline IString IString :: copy ( const IString &aString,
  639.                       unsigned       numCopies )
  640.   {
  641.   return IString(aString).copy( numCopies );
  642.   }
  643. inline IString & IString :: insert ( const IString &aString,
  644.                                      unsigned       index,
  645.                                      char           padCharacter )
  646.   {
  647.   return this->insert( aString.data(),
  648.                        aString.length(),
  649.                        index,
  650.                        padCharacter );
  651.   }
  652. inline IString & IString :: insert ( const char *pString,
  653.                                      unsigned    index,
  654.                                      char        padCharacter )
  655.   {
  656.   return this->insert( pString,
  657.                        lengthOf( pString ),
  658.                        index,
  659.                        padCharacter );
  660.   }
  661. inline IString IString :: insert ( const IString &aString,
  662.                         const IString &anInsert,
  663.                         unsigned       index,
  664.                         char           padCharacter )
  665.   {
  666.   return IString(aString).insert( anInsert, index, padCharacter );
  667.   }
  668. inline IString IString :: insert ( const IString &aString,
  669.                         const char    *pInsert,
  670.                         unsigned       index,
  671.                         char           padCharacter )
  672.   {
  673.   return IString(aString).insert( pInsert, index, padCharacter );
  674.   }
  675. inline IString IString :: leftJustify ( const IString &aString,
  676.                              unsigned       newLength,
  677.                              char           padCharacter )
  678.   {
  679.   return IString(aString).leftJustify( newLength, padCharacter );
  680.   }
  681. inline IString IString :: lowerCase ( const IString &aString )
  682.   {
  683.   return IString(aString).lowerCase();
  684.   }
  685. inline IString & IString :: overlayWith ( const IString &aString,
  686.                                           unsigned       index,
  687.                                           char           padCharacter )
  688.   {
  689.   return this->overlayWith( aString.data(),
  690.                             aString.length(),
  691.                             index,
  692.                             padCharacter );
  693.   }
  694. inline IString& IString :: overlayWith ( const char *pString,
  695.                                          unsigned    index,
  696.                                          char        padCharacter )
  697.    {
  698.    return this->overlayWith( pString,
  699.                              lengthOf( pString ),
  700.                              index,
  701.                              padCharacter );
  702.    }
  703. inline IString IString :: overlayWith ( const IString &aString,
  704.                              const IString &anOverlay,
  705.                              unsigned       index,
  706.                              char           padCharacter )
  707.   {
  708.   return IString(aString).overlayWith( anOverlay, index, padCharacter );
  709.   }
  710. inline IString IString :: overlayWith ( const IString &aString,
  711.                              const char    *pOverlay,
  712.                              unsigned       index,
  713.                              char           padCharacter )
  714.   {
  715.   return IString(aString).overlayWith( pOverlay, index, padCharacter );
  716.   }
  717. inline IString IString :: remove ( const IString &aString,
  718.                                    unsigned       startPos )
  719.   {
  720.   return IString::remove( aString, startPos, UINT_MAX );
  721.   }
  722. inline IString IString :: reverse ( const IString &aString )
  723.   {
  724.   return IString(aString).reverse();
  725.   }
  726. inline IString IString :: rightJustify ( const IString &aString,
  727.                               unsigned       newLength,
  728.                               char           padCharacter )
  729.   {
  730.   return IString(aString).rightJustify( newLength, padCharacter );
  731.   }
  732. inline IString & IString :: stripLeading ( )
  733.   {
  734.   return this->strip( IStringTest( isspace ), IStringEnum::leading );
  735.   }
  736. inline IString & IString :: stripTrailing ( )
  737.   {
  738.   return this->strip( IStringTest( isspace ), IStringEnum::trailing );
  739.   }
  740. inline IString & IString :: strip ( char aChar )
  741.   {
  742.   return this->strip( &aChar, 1, IStringEnum::both );
  743.   }
  744. inline IString & IString :: stripLeading ( char aChar )
  745.   {
  746.   return this->strip( &aChar, 1, IStringEnum::leading );
  747.   }
  748. inline IString & IString :: stripTrailing ( char aChar )
  749.   {
  750.   return this->strip( &aChar, 1, IStringEnum::trailing );
  751.   }
  752. inline IString & IString :: strip ( const IString &aString )
  753.   {
  754.   return this->strip( aString.data(), aString.length(), IStringEnum::both );
  755.   }
  756. inline IString & IString :: stripLeading ( const IString &aString )
  757.   {
  758.   return this->strip( aString.data(), aString.length(), IStringEnum::leading );
  759.   }
  760. inline IString & IString :: stripTrailing ( const IString &aString )
  761.   {
  762.   return this->strip( aString.data(), aString.length(), IStringEnum::trailing );
  763.   }
  764. inline IString & IString :: strip ( const char *pString )
  765.   {
  766.   return this->strip( pString, lengthOf( pString ), IStringEnum::both );
  767.   }
  768. inline IString & IString :: stripLeading ( const char *pString )
  769.   {
  770.   return this->strip( pString, lengthOf( pString ), IStringEnum::leading );
  771.   }
  772. inline IString & IString :: stripTrailing ( const char *pString )
  773.   {
  774.   return this->strip( pString, lengthOf( pString ), IStringEnum::trailing );
  775.   }
  776. inline IString & IString :: strip ( const IStringTest &aTest )
  777.   {
  778.   return this->strip( aTest, IStringEnum::both );
  779.   }
  780. inline IString & IString :: stripLeading ( const IStringTest &aTest )
  781.   {
  782.   return this->strip( aTest, IStringEnum::leading );
  783.   }
  784. inline IString & IString :: stripTrailing ( const IStringTest &aTest )
  785.   {
  786.   return this->strip( aTest, IStringEnum::trailing );
  787.   }
  788. inline IString IString :: stripBlanks ( const IString &aString )
  789.   {
  790.   return IString(aString).strip();
  791.   }
  792. inline IString IString :: strip ( const IString &aString,
  793.                        char           aChar )
  794.   {
  795.   return IString(aString).strip(aChar);
  796.   }
  797. inline IString IString :: strip ( const IString &aString,
  798.                        const IString &aStringOfChars )
  799.   {
  800.   return IString(aString).strip(aStringOfChars);
  801.   }
  802. inline IString IString :: strip ( const IString &aString,
  803.                        const char    *pStringOfChars )
  804.   {
  805.   return IString(aString).strip(pStringOfChars);
  806.   }
  807. inline IString IString :: strip ( const IString     &aString,
  808.                        const IStringTest &aTest )
  809.   {
  810.   return IString(aString).strip(aTest);
  811.   }
  812. inline IString IString :: stripLeadingBlanks ( const IString &aString )
  813.   {
  814.   return IString(aString).stripLeading();
  815.   }
  816. inline IString IString :: stripLeading ( const IString &aString,
  817.                               char           aChar )
  818.   {
  819.   return IString(aString).stripLeading(aChar);
  820.   }
  821. inline IString IString :: stripLeading ( const IString &aString,
  822.                               const IString &aStringOfChars )
  823.   {
  824.   return IString(aString).stripLeading(aStringOfChars);
  825.   }
  826. inline IString IString :: stripLeading ( const IString &aString,
  827.                               const char    *pStringOfChars )
  828.   {
  829.   return IString(aString).stripLeading(pStringOfChars);
  830.   }
  831. inline IString IString :: stripLeading ( const IString     &aString,
  832.                               const IStringTest &aTest )
  833.   {
  834.   return IString(aString).stripLeading(aTest);
  835.   }
  836. inline IString IString :: stripTrailingBlanks ( const IString &aString )
  837.   {
  838.   return IString(aString).stripTrailing();
  839.   }
  840. inline IString IString :: stripTrailing ( const IString &aString,
  841.                                char           aChar )
  842.   {
  843.   return IString(aString).stripTrailing(aChar);
  844.   }
  845. inline IString IString :: stripTrailing ( const IString &aString,
  846.                                const IString &aStringOfChars )
  847.   {
  848.   return IString(aString).stripTrailing(aStringOfChars);
  849.   }
  850. inline IString IString :: stripTrailing ( const IString &aString,
  851.                                const char    *pStringOfChars )
  852.   {
  853.   return IString(aString).stripTrailing(pStringOfChars);
  854.   }
  855. inline IString IString :: stripTrailing ( const IString     &aString,
  856.                                const IStringTest &aTest )
  857.   {
  858.   return IString(aString).stripTrailing(aTest);
  859.   }
  860. inline IString & IString :: translate ( const IString &inputChars,
  861.                                         const IString &outputChars,
  862.                                         char           padCharacter )
  863.   {
  864.   return this->translate( inputChars.data(),
  865.                           inputChars.length(),
  866.                           outputChars.data(),
  867.                           outputChars.length(),
  868.                           padCharacter );
  869.   }
  870. inline IString & IString :: translate ( const IString &inputChars,
  871.                                         const char    *pOutputChars,
  872.                                         char           padCharacter )
  873.   {
  874.   return this->translate( inputChars.data(),
  875.                           inputChars.length(),
  876.                           pOutputChars,
  877.                           lengthOf( pOutputChars ),
  878.                           padCharacter );
  879.   }
  880. inline IString & IString :: translate ( const char    *pInputChars,
  881.                                         const IString &outputChars,
  882.                                         char           padCharacter )
  883.   {
  884.   return this->translate( pInputChars,
  885.                           lengthOf( pInputChars ),
  886.                           outputChars.data(),
  887.                           outputChars.length(),
  888.                           padCharacter );
  889.   }
  890. inline IString & IString :: translate ( const char *pInputChars,
  891.                                         const char *pOutputChars,
  892.                                         char        padCharacter )
  893.   {
  894.   return this->translate( pInputChars,
  895.                           lengthOf( pInputChars ),
  896.                           pOutputChars,
  897.                           lengthOf( pOutputChars ),
  898.                           padCharacter );
  899.   }
  900. inline IString IString :: translate ( const IString &aString,
  901.                            const IString &inputChars,
  902.                            const IString &outputChars,
  903.                            char           padCharacter )
  904.   {
  905.   return IString(aString).translate( inputChars, outputChars, padCharacter );
  906.   }
  907. inline IString IString :: translate ( const IString &aString,
  908.                            const IString &inputChars,
  909.                            const char    *pOutputChars,
  910.                            char           padCharacter )
  911.   {
  912.   return IString(aString).translate( inputChars, pOutputChars, padCharacter );
  913.   }
  914. inline IString IString :: translate ( const IString &aString,
  915.                            const char    *pInputChars,
  916.                            const IString &outputChars,
  917.                            char           padCharacter )
  918.   {
  919.   return IString(aString).translate( pInputChars, outputChars, padCharacter );
  920.   }
  921. inline IString IString :: translate ( const IString &aString,
  922.                            const char    *pInputChars,
  923.                            const char    *pOutputChars,
  924.                            char           padCharacter )
  925.   {
  926.   return IString(aString).translate( pInputChars, pOutputChars, padCharacter );
  927.   }
  928. /*------------------------------ Word Functions ------------------------------*/
  929. inline IString & IString :: removeWords ( unsigned firstWord )
  930.   {
  931.   return this->removeWords( firstWord, UINT_MAX );
  932.   }
  933. inline IString IString :: removeWords ( const IString &aString,
  934.                              unsigned       firstWord )
  935.   {
  936.   return IString(aString).removeWords( firstWord );
  937.   }
  938. inline IString IString :: removeWords ( const IString &aString,
  939.                              unsigned       firstWord,
  940.                              unsigned       numWords )
  941.   {
  942.   return IString(aString).removeWords( firstWord, numWords );
  943.   }
  944. inline unsigned IString :: indexOfPhrase ( const IString &aPhrase,
  945.                                            unsigned       startWord ) const
  946.    {
  947.    return this->findPhrase ( aPhrase, startWord, charIndex );
  948.    }
  949. inline unsigned IString :: indexOfWord ( unsigned wordNumber ) const
  950.   {
  951.   return this->indexOfWord( wordNumber, 1, 0 );
  952.   }
  953. inline unsigned IString :: wordIndexOfPhrase( const IString &aPhrase,
  954.                                               unsigned       startWord ) const
  955.   {
  956.   return this->findPhrase( aPhrase, startWord, wordIndex );
  957.   }
  958. inline IString IString :: space ( const IString &aString,
  959.                        unsigned       numSpaces,
  960.                        char           spaceChar )
  961.   {
  962.   return IString(aString).space( numSpaces, spaceChar );
  963.   }
  964. inline IString IString :: words ( unsigned firstWord ) const
  965.   {
  966.   return this->words( firstWord, UINT_MAX );
  967.   }
  968. #endif /* _ISTRING_INL_ */
  969.