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