---

basic_string.hh

/*
*  Name:      basic_string.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Extension class for STL string
*  Date:      $Date: 2003/04/14 00:18:32 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1999-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_TEXT_BASIC_STRING__
#define _MPCL_TEXT_BASIC_STRING__

#include <algorithm>
#include <cstring>
#include <locale>
#include <string>
#include "../exceptions.hh"


namespace mpcl
{

  namespace text
  {

    template < typename TChar                                ,
               typename TTraits    = std::char_traits<TChar> ,
               typename TAllocator = std::allocator<TChar>   >
    class TBasicString : public std::basic_string<TChar, TTraits, TAllocator>
    {

      public:

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::allocator_type
          allocator_type;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::const_iterator
          const_iterator;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::const_pointer
          const_pointer;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::const_reference
          const_reference;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::const_reverse_iterator
          const_reverse_iterator;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::difference_type
          difference_type;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::iterator
          iterator;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::pointer
          pointer;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::reference
          reference;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::reverse_iterator
          reverse_iterator;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::size_type
          size_type;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::traits_type
          traits_type;

        typedef
          typename std::basic_string<TChar, TTraits, TAllocator>::value_type
          value_type;


      public:

        //
        //  C O N S T R U C T O R S
        //

        explicit TBasicString (void)                      :
          std::basic_string<TChar, TTraits, TAllocator>() {}

        TBasicString (const std::basic_string<TChar, TTraits, TAllocator>& rkySOURCE) :
          std::basic_string<TChar, TTraits, TAllocator> (rkySOURCE)                   {}

        TBasicString (const TBasicString& rkySOURCE)                :
          std::basic_string<TChar, TTraits, TAllocator> (rkySOURCE) {}

        TBasicString ( const TBasicString& rkySOURCE      ,
                       size_type           zOFFSET        ,
                       size_type           zLENGTH = npos )                           :
          std::basic_string<TChar, TTraits, TAllocator> (rkySOURCE, zOFFSET, zLENGTH) {}

        TBasicString (const TChar* pkcSOURCE, size_type zLENGTH) :
          std::basic_string<TChar, TTraits, TAllocator>()
        {
          if ( !pkcSOURCE )
          {
            throw TConstraintException ("null string", __FILE__, __LINE__);
          }
          assign (pkcSOURCE, zLENGTH);
        }

        TBasicString (const TChar* pkcSOURCE) :
          std::basic_string<TChar, TTraits, TAllocator>()
        {
          if ( !pkcSOURCE )
          {
            throw TConstraintException ("null string", __FILE__, __LINE__);
          }
          assign (pkcSOURCE);
        }

        TBasicString (size_type zTIMES, TChar cSOURCE)                    :
          std::basic_string<TChar, TTraits, TAllocator> (zTIMES, cSOURCE) {}

        template<typename InputIterator>
        TBasicString(InputIterator tBEGIN_ITER, InputIterator tEND_ITER)         :
          std::basic_string<TChar, TTraits, TAllocator> (tBEGIN_ITER, tEND_ITER) {}

        TBasicString& operator = (const TBasicString& rkySOURCE)
        {
          std::basic_string<TChar, TTraits, TAllocator>::operator = (rkySOURCE);
          return *this;
        }

        TBasicString& operator = (const TChar* pkcSOURCE)
        {
          if ( !pkcSOURCE )
          {
            throw TConstraintException ("null string", __FILE__, __LINE__);
          }
          std::basic_string<TChar, TTraits, TAllocator>::operator = (pkcSOURCE);
          return *this;
        }

        TBasicString& operator = (TChar cSOURCE)
        {
          std::basic_string<TChar, TTraits, TAllocator>::operator = (cSOURCE);
          return *this;
        }

        size_type replaceAll ( const std::basic_string<TChar, TTraits, TAllocator>& rkySOURCE1 ,
                               const std::basic_string<TChar, TTraits, TAllocator>& rkySOURCE2 )
        {
          return replaceAll (rkySOURCE1.c_str(), rkySOURCE2.c_str());
        }

        size_type replaceAll (const TChar* pkcSOURCE1, const TChar* pkcSOURCE2);

        size_type replaceAll (TChar cSOURCE1, TChar cSOURCE2);

        TBasicString& leftFill (TChar cSOURCE, size_type zLENGTH);

        TBasicString& rightFill (TChar cSOURCE, size_type zLENGTH);

        TBasicString& suppress (TChar cSOURCE);

        TBasicString& suppressFirst (TChar cSOURCE);

        TBasicString& suppressLast (TChar cSOURCE);

        TBasicString& uppercase (void);

        TBasicString& lowercase (void);


      public:

        //  S E L E C T O R S
        //

        size_type occurrences (const TChar* pkcSOURCE) const;

        size_type occurrences (TChar cSOURCE) const;

        template <typename TOutputIter>
        const TBasicString& split (TChar cSOURCE, TOutputIter tTARGET_ITER) const
        {
          Split (begin(), end(), cSOURCE, tTARGET_ITER);
          return *this;
        }

    };  // class TBasicString


    template <typename TChar, typename TTraits, typename TAllocator>
    inline typename TBasicString<TChar, TTraits, TAllocator>::size_type TBasicString<TChar, TTraits, TAllocator>::
    replaceAll (const TChar* pkcSOURCE1, const TChar* pkcSOURCE2)
    {

      register size_type   zTimes = 0;

      if ( !pkcSOURCE1 || !pkcSOURCE2 )
      {
        throw TConstraintException ("null string in parameters", __FILE__, __LINE__);
      }
      else
      {
        register size_type   zOffset       = 0;
        register size_type   zSourceLength = std::strlen (pkcSOURCE1);
        register size_type   zTargetLength = std::strlen (pkcSOURCE2);

        while ( npos != (zOffset = find (pkcSOURCE1, zOffset)) )
        {
          erase (zOffset, zSourceLength);
          insert (zOffset, pkcSOURCE2);
          zOffset += zTargetLength;
          ++zTimes;
        }
      }
      return zTimes;

    }  // replaceAll()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline typename TBasicString<TChar, TTraits, TAllocator>::size_type TBasicString<TChar, TTraits, TAllocator>::
    replaceAll (TChar cSOURCE1, TChar cSOURCE2)
    {

      register size_type   zTimes  = 0;
      register size_type   zOffset = 0;

      while ( npos != (zOffset = find (cSOURCE1, zOffset)) )
      {
        erase (zOffset, 1);
        insert (zOffset, 1, cSOURCE2);
        ++zOffset;
        ++zTimes;
      }
      return zTimes;

    }  // replaceAll()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline TBasicString<TChar, TTraits, TAllocator>& TBasicString<TChar, TTraits, TAllocator>::
    leftFill (TChar cSOURCE, size_type zLENGTH)
    {

      size_type   zThisLength = length();

      if ( zLENGTH > zThisLength )
      {
        assign (std::string (zLENGTH - zThisLength, cSOURCE) + *this);
      }
      return *this;

    }  // leftFill()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline TBasicString<TChar, TTraits, TAllocator>& TBasicString<TChar, TTraits, TAllocator>::
    rightFill (TChar cSOURCE, size_type zLENGTH)
    {

      size_t   zThisLength = length();

      if ( zLENGTH > zThisLength )
      {
        append (std::string (zLENGTH - zThisLength, cSOURCE));
      }
      return *this;

    }  // rightFill()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline TBasicString<TChar, TTraits, TAllocator>& TBasicString<TChar, TTraits, TAllocator>::
    suppress (TChar cSOURCE)
    {

      iterator   tIter = std::remove (begin(), end(), cSOURCE);

      erase (tIter, end());
      return *this;

    }  // suppress()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline TBasicString<TChar, TTraits, TAllocator>& TBasicString<TChar, TTraits, TAllocator>::
    suppressFirst (TChar cSOURCE)
    {

      if ( !empty() )
      {
        const_iterator   tEnd  = end();
        iterator         tIter = begin();

        while ( tIter != tEnd )
        {
          if ( *tIter != cSOURCE )
          {
            if ( tIter != begin() )
            {
              erase (0, tIter - begin());
            }
            break;
          }
          ++tIter;
        }
      }
      return *this;

    }  // suppressFirst()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline TBasicString<TChar, TTraits, TAllocator>& TBasicString<TChar, TTraits, TAllocator>::
    suppressLast (TChar cSOURCE)
    {

      if ( !empty() )
      {
        iterator   tBegin = begin();
        iterator   tIter  = end();

        while ( tBegin != tIter )
        {
          --tIter;
          if ( *tIter != cSOURCE )
          {
            if ( tIter != (end() - 1) )
            {
              erase (tIter - tBegin + 1);
            }
            break;
          }
        }
      }
      return *this;

    }  // suppressLast()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline TBasicString<TChar, TTraits, TAllocator>& TBasicString<TChar, TTraits, TAllocator>::
    uppercase (void)
    {

      std::locale                TLocale;
      const std::ctype<TChar>&   rktCtype (std::use_facet<std::ctype<TChar> >(TLocale));

      for (iterator I = begin(); ( I != end() ) ;++I)
      {
        *I = rktCtype.toupper (*I);
      }
      return *this;

    }  // uppercase()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline TBasicString<TChar, TTraits, TAllocator>& TBasicString<TChar, TTraits, TAllocator>::
    lowercase (void)
    {

      using std::locale;

      std::locale                TLocale;
      const std::ctype<TChar>&   rktCtype (std::use_facet<std::ctype<TChar> >(TLocale));

      for (iterator I = begin(); ( I != end() ) ;++I)
      {
        *I = rktCtype.tolower (*I);
      }
      return *this;

    }  // lowercase()


    //
    //  S E L E C T O R S
    //

    template <typename TChar, typename TTraits, typename TAllocator>
    inline typename TBasicString<TChar, TTraits, TAllocator>::size_type TBasicString<TChar, TTraits, TAllocator>::
    occurrences (const TChar* pkcSOURCE) const
    {

      register size_type   zOccurrences = 0;

      if ( !pkcSOURCE )
      {
        throw TConstraintException ("null string in parameters", __FILE__, __LINE__);
      }
      else
      {
        register size_type   zOffset       = 0;
        register size_type   zTargetLength = std::strlen (pkcSOURCE);

        while ( npos != (zOffset = find (pkcSOURCE, zOffset)) )
        {
          ++zOccurrences;
          zOffset += zTargetLength;
        }
      }
      return zOccurrences;

    }  // occurrences()


    template <typename TChar, typename TTraits, typename TAllocator>
    inline typename TBasicString<TChar, TTraits, TAllocator>::size_type TBasicString<TChar, TTraits, TAllocator>::
    occurrences (TChar cTARGET) const
    {

      register size_type   zOffset      = 0;
      register size_type   zOccurrences = 0;

      while ( npos != (zOffset = find (cTARGET, zOffset)) )
      {
        ++zOccurrences;
        ++zOffset;
      }
      return zOccurrences;

    }  // occurrences()

  }  // namespace text

}  // namespace mpcl


#endif  // not _MPCL_TEXT_BASIC_STRING__

---