string_algorithm.tpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful

  CLAW is a free library without any particular aim but being useful to 
  anyone.

  Copyright (C) 2005-2011 Julien Jorge

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

  contact: julien.jorge@gamned.org
*/
#include <claw/algorithm.hpp>
#include <claw/glob.hpp>

#include <sstream>
#include <string>
#include <iterator>

/*----------------------------------------------------------------------------*/
template<typename StreamType, typename StringType>
StreamType& claw::text::getline( StreamType& is, StringType& str )
{
  std::getline( is, str );

  if ( !str.empty() )
    if ( str[ str.size() - 1 ] == typename StringType::value_type('\r') )
      str.erase( str.size() - 1 );

  return is;
} // getline()

/*----------------------------------------------------------------------------*/
template<typename StringType>
void claw::text::trim_left( StringType& str,
                            const typename StringType::value_type* const s )
{
  typename StringType::size_type p = str.find_first_not_of(s);

  if (p != StringType::npos)
    str = str.substr(p);
} // trim_left()

/*----------------------------------------------------------------------------*/
template<typename StringType>
void claw::text::trim_right( StringType& str,
                             const typename StringType::value_type* const s )
{
  typename StringType::size_type p = str.find_last_not_of(s);

  if (p != StringType::npos)
    str = str.substr( 0, p+1 );
} // trim_right()

/*----------------------------------------------------------------------------*/
template<typename StringType>
void claw::text::trim( StringType& str,
                       const typename StringType::value_type* const s )
{
  typename StringType::size_type first = str.find_first_not_of(s);
  typename StringType::size_type last  = str.find_last_not_of(s);

  if (first != StringType::npos)
    str = str.substr( first, last - first + 1 );
} // trim()

/*----------------------------------------------------------------------------*/
template<typename StringType>
void claw::text::squeeze( StringType& str,
                          const typename StringType::value_type* const s )
{
  typedef typename StringType::size_type size_type;

  size_type first(0);

  do
    {
      first = str.find_first_of(s, first);

      if ( first != StringType::npos )
        {
          size_type last = str.find_first_not_of(str[first], first+1);

          if ( last == StringType::npos )
            str = str.substr(0, first+1);
          else if ( last - first > 1 )
            str = str.substr(0, first+1) + str.substr(last);

          ++first;
        }
    }
  while ( (first != StringType::npos) && (first != str.length()) );
} // squeeze()

/*----------------------------------------------------------------------------*/
template<typename StringType>
std::size_t claw::text::replace
( StringType& str, const StringType& e1, const StringType& e2 )
{
  return
    claw::replace
    ( str.begin(), str.end(), e1.begin(), e1.end(), e2.begin(), e2.end() );
} // replace()

/*----------------------------------------------------------------------------*/
template<typename T, typename StringType>
bool claw::text::is_of_type( const StringType& str )
{
  std::basic_istringstream< typename StringType::value_type,
    typename StringType::traits_type,
    typename StringType::allocator_type > iss(str);

  T val;
  bool result = false;

  if ( iss >> val )
    result = iss.eof();

  return result;
} // is_of_type()

/*----------------------------------------------------------------------------*/
template<typename Sequence>
void claw::text::split
( Sequence& sequence, const typename Sequence::value_type& str,
  const typename Sequence::value_type::value_type sep )
{
  split(sequence, str.begin(), str.end(), sep);
} // split()

/*----------------------------------------------------------------------------*/
template<typename Sequence>
void claw::text::split
( Sequence& sequence, typename Sequence::value_type::const_iterator first,
  typename Sequence::value_type::const_iterator last,
  const typename Sequence::value_type::value_type sep )
{
  typedef typename Sequence::value_type string_type;

  string_type line;
  std::basic_istringstream< typename string_type::value_type,
    typename string_type::traits_type,
    typename string_type::allocator_type > iss( string_type(first, last) );

  while ( std::getline(iss, line, sep) )
    *std::insert_iterator<Sequence>(sequence, sequence.end()) = line;
} // split()

/*----------------------------------------------------------------------------*/
template<typename InputIterator, typename OutputIterator>
void claw::text::c_escape
( InputIterator first, InputIterator last, OutputIterator out )
{
  typedef typename std::iterator_traits<InputIterator>::value_type char_type;
  typedef std::basic_string<char_type> string_type;

  const string_type oct("01234567");
  const string_type hex("0123456789ABCDEFabcdef");

  bool escape(false);

  for ( ; first!=last; ++out )
    if ( escape )
      {
        switch( *first )
          {
          case 'a': *out = '\a'; ++first; break;
          case 'b': *out = '\b'; ++first; break;
          case 'f': *out = '\f'; ++first; break;
          case 'n': *out = '\n'; ++first; break;
          case 'r': *out = '\r'; ++first; break;
          case 't': *out = '\t'; ++first; break;
          case 'v': *out = '\v'; ++first; break;
          case 'o':
            {
              ++first;
              int v(0);
              const InputIterator e
                ( find_first_not_of(first, last, oct.begin(), oct.end()) );

              std::basic_istringstream<char_type> iss( string_type(first, e) );
              iss >> std::oct >> v;
              *out = (char_type)v;
              first = e;
              break;
            }
          case 'x':
            {
              ++first;
              int v(0);
              const InputIterator e
                ( find_first_not_of(first, last, hex.begin(), hex.end()) );

              std::basic_istringstream<char_type> iss( string_type(first, e) );
              iss >> std::hex >> v;
              *out = (char_type)v;
              first = e;
              break;
            }
          default: *out = *first; ++first;
          }

        escape = false;
      }
    else if ( *first == '\\' )
      {
        escape = true;
        ++first;
      }
    else
      {
        *out = *first;
        ++first;
      }
} // c_escape()

/*----------------------------------------------------------------------------*/
template<typename StringType>
bool claw::text::glob_match
( const StringType& pattern, const StringType& text,
  const typename StringType::value_type any_sequence,
  const typename StringType::value_type zero_or_one,
  const typename StringType::value_type any )
{
  return claw::glob_match
    ( pattern.begin(), pattern.end(), text.begin(), text.end(), any_sequence,
      zero_or_one, any );
} // glob_match()

/*----------------------------------------------------------------------------*/
template<typename StringType>
bool claw::text::glob_potential_match
( const StringType& pattern, const StringType& text,
  const typename StringType::value_type any_sequence,
  const typename StringType::value_type zero_or_one,
  const typename StringType::value_type any )
{
  return claw::glob_potential_match
    ( pattern.begin(), pattern.end(), text.begin(), text.end(), any_sequence,
      zero_or_one, any );
} // glob_potential_match()