String.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_STRING_H
#define ZYPP_BASE_STRING_H

#include <cstring>

#include <iosfwd>
#include <vector>
#include <string>
#include <sstream>

#include "zypp/base/Easy.h"
#include "zypp/base/PtrTypes.h"

namespace zypp
{ 

  class C_Str
  {
    public:
      typedef std::string::size_type size_type;

    public:
      C_Str()                            : _val( 0 ),             _sze( 0 ) {}
      C_Str( char * c_str_r )            : _val( c_str_r ),       _sze( std::string::npos ) {}
      C_Str( const char * c_str_r )      : _val( c_str_r ),       _sze( std::string::npos ) {}
      C_Str( const std::string & str_r ) : _val( str_r.c_str() ), _sze( str_r.size() ) {}

    public:
      bool      isNull()       const { return !_val; }
      bool      empty()        const { return !(_val && *_val); }
      size_type size()         const
      {
        if ( _sze == std::string::npos )
        { _sze = _val ? ::strlen( _val ) : 0; }
        return _sze;
      };

      operator const char *() const { return c_str(); }
      const char * c_str()    const { return _val ? _val : ""; }

    private:
      const char *const _val;
      mutable size_type _sze;
  };

  inline std::ostream & operator<<( std::ostream & str, const C_Str & obj )
  { return str << obj.c_str(); }


  namespace str
  { 


    inline std::string asString( const std::string &t )
    { return t; }

    inline std::string asString( const char * t )
    { return t; }

    template<class _T>
        inline std::string asString( const _T &t )
        { return t.asString(); }

    template<class _T>
        inline std::string asString( const intrusive_ptr<_T> &p )
        { return p->asString(); }

    template<class _T>
        inline std::string asString( const weak_ptr<_T> &p )
        { return p->asString(); }

    template<>
        inline std::string asString( const bool &t )
        { return t ? "+" : "-"; }


    std::string form( const char * format, ... )
    __attribute__ ((format (printf, 1, 2)));


    std::string strerror( int errno_r );


    struct SafeBuf
    {
      char * _buf;
      SafeBuf() : _buf( 0 ) {}
      ~SafeBuf() { if ( _buf ) free( _buf ); }
      std::string asString() const
      { return _buf ? std::string(_buf) : std::string(); }
    };


    struct Str
    {
      template<class _Tp>
      Str & operator<<( const _Tp & val )
      { _str << val; return *this; }

      operator std::string() const
      { return _str.str(); }

      std::ostringstream _str;
    };


    inline std::string numstring( char n,               int w = 0 ) { return form( "%*hhd",  w, n ); }
    inline std::string numstring( unsigned char n,      int w = 0 ) { return form( "%*hhu",  w, n ); }
    inline std::string numstring( short n,              int w = 0 ) { return form( "%*hd",   w, n ); }
    inline std::string numstring( unsigned short n,     int w = 0 ) { return form( "%*hu",   w, n ); }
    inline std::string numstring( int n,                int w = 0 ) { return form( "%*d",    w, n ); }
    inline std::string numstring( unsigned n,           int w = 0 ) { return form( "%*u",    w, n ); }
    inline std::string numstring( long n,               int w = 0 ) { return form( "%*ld",   w, n ); }
    inline std::string numstring( unsigned long n,      int w = 0 ) { return form( "%*lu",   w, n ); }
    inline std::string numstring( long long n,          int w = 0 ) { return form( "%*lld",  w, n ); }
    inline std::string numstring( unsigned long long n, int w = 0 ) { return form( "%*llu",  w, n ); }

    template<> inline std::string asString( const char & t )                    { return numstring( t ); }
    template<> inline std::string asString( const unsigned char & t )           { return numstring( t ); }
    template<> inline std::string asString( const short & t )                   { return numstring( t ); }
    template<> inline std::string asString( const unsigned short & t )          { return numstring( t ); }
    template<> inline std::string asString( const int & t )                     { return numstring( t ); }
    template<> inline std::string asString( const unsigned & t )                { return numstring( t ); }
    template<> inline std::string asString( const long & t )                    { return numstring( t ); }
    template<> inline std::string asString( const unsigned long & t )           { return numstring( t ); }
    template<> inline std::string asString( const long long & t )               { return numstring( t ); }
    template<> inline std::string asString( const unsigned long long & t )      { return numstring( t ); }


    inline std::string hexstring( char n,               int w = 4 ) { return form( "%#0*hhx", w, n ); }
    inline std::string hexstring( unsigned char n,      int w = 4 ) { return form( "%#0*hhx", w, n ); }
    inline std::string hexstring( short n,              int w = 10 ){ return form( "%#0*hx",  w, n ); }
    inline std::string hexstring( unsigned short n,     int w = 10 ){ return form( "%#0*hx",  w, n ); }
    inline std::string hexstring( int n,                int w = 10 ){ return form( "%#0*x",   w, n ); }
    inline std::string hexstring( unsigned n,           int w = 10 ){ return form( "%#0*x",   w, n ); }
    inline std::string hexstring( long n,               int w = 10 ){ return form( "%#0*lx",  w, n ); }
    inline std::string hexstring( unsigned long n,      int w = 10 ){ return form( "%#0*lx",  w, n ); }
    inline std::string hexstring( long long n,          int w = 0 ) { return form( "%#0*llx", w, n ); }
    inline std::string hexstring( unsigned long long n, int w = 0 ) { return form( "%#0*llx", w, n ); }


    inline std::string octstring( char n,               int w = 4 ) { return form( "%#0*hho",  w, n ); }
    inline std::string octstring( unsigned char n,      int w = 4 ) { return form( "%#0*hho",  w, n ); }
    inline std::string octstring( short n,              int w = 5 ) { return form( "%#0*ho",   w, n ); }
    inline std::string octstring( unsigned short n,     int w = 5 ) { return form( "%#0*ho",   w, n ); }
    inline std::string octstring( int n,                int w = 5 ) { return form( "%#0*o",    w, n ); }
    inline std::string octstring( unsigned n,           int w = 5 ) { return form( "%#0*o",    w, n ); }
    inline std::string octstring( long n,               int w = 5 ) { return form( "%#0*lo",   w, n ); }
    inline std::string octstring( unsigned long n,      int w = 5 ) { return form( "%#0*lo",   w, n ); }
    inline std::string octstring( long long n,          int w = 0 ) { return form( "%#0*llo",  w, n ); }
    inline std::string octstring( unsigned long long n, int w = 0 ) { return form( "%#0*llo",  w, n ); }


    template<typename _It>
      _It strtonum( const C_Str & str );

    template<>
      inline short              strtonum( const C_Str & str ) { return ::strtol  ( str, NULL, 0 ); }
    template<>
      inline int                strtonum( const C_Str & str ) { return ::strtol  ( str, NULL, 0 ); }
    template<>
      inline long               strtonum( const C_Str & str ) { return ::strtol  ( str, NULL, 0 ); }
    template<>
      inline long long          strtonum( const C_Str & str ) { return ::strtoll ( str, NULL, 0 ); }

    template<>
      inline unsigned short     strtonum( const C_Str & str ) { return ::strtoul ( str, NULL, 0 ); }
    template<>
      inline unsigned           strtonum( const C_Str & str ) { return ::strtoul ( str, NULL, 0 ); }
    template<>
      inline unsigned long      strtonum( const C_Str & str ) { return ::strtoul ( str, NULL, 0 ); }
    template<>
      inline unsigned long long strtonum( const C_Str & str ) { return ::strtoull( str, NULL, 0 ); }

    template<typename _It>
      inline _It strtonum( const C_Str & str, _It & i )
      { return i = strtonum<_It>( str ); }


    bool strToTrue( const C_Str & str );

    bool strToFalse( const C_Str & str );

    inline bool strToBool( const C_Str & str, bool default_r )
    { return( default_r ? strToFalse( str ) : strToTrue( str ) ); }

    inline bool strToBoolNodefault( const C_Str & str, bool & return_r )
    {
      if ( strToTrue( str ) ) return (return_r = true);
      if ( !strToFalse( str ) ) return (return_r = false);
      return return_r;
    }


    std::string gsub( const std::string& sData, const std::string& sFrom, const std::string& sTo);

    std::string& replaceAll( std::string & str, const std::string & from, const std::string & to);


    template<class _OutputIterator>
      unsigned split( const C_Str &   line_r,
                      _OutputIterator result_r,
                      const C_Str &   sepchars_r = " \t" )
      {
        const char * beg = line_r;
        const char * cur = beg;
        // skip leading sepchars
        while ( *cur && ::strchr( sepchars_r, *cur ) )
          ++cur;
        unsigned ret = 0;
        for ( beg = cur; *beg; beg = cur, ++result_r, ++ret )
          {
            // skip non sepchars
            while( *cur && !::strchr( sepchars_r, *cur ) )
              ++cur;
            // build string
            *result_r = std::string( beg, cur-beg );
            // skip sepchars
            while ( *cur && ::strchr( sepchars_r, *cur ) )
              ++cur;
          }
        return ret;
      }

    template<class _OutputIterator>
      unsigned splitEscaped( const C_Str &   line_r,
                      _OutputIterator result_r,
                      const C_Str &   sepchars_r = " \t",
                      bool withEmpty = false)
      {
        const char * beg = line_r;
        const char * cur = beg;
        unsigned ret = 0;

        // skip leading sepchars
        while ( *cur && ::strchr( sepchars_r, *cur ) )
        {
          ++cur;
          if (withEmpty)
          {
            *result_r = "";
            ++ret;
          }
        }

        // there were only sepchars in the string
        if (!*cur && withEmpty)
        {
          *result_r = "";
          return ++ret;
        }

        // after the leading sepchars
        for ( beg = cur; *beg; beg = cur, ++result_r, ++ret )
          {
            if ( *cur == '"'  || *cur == '\'' )
            {
              char closeChar = *cur;
              ++cur;
              bool cont = true;
              while (cont)
              {
                while ( *cur && *cur != closeChar)
                  ++cur;
                if ( *cur == '\0' )
                {
                  return ret; //TODO parsing exception no closing quote
                }
                int escCount = 0;
                const char * esc = cur-1;
                while ( esc != beg && *esc == '\\' )
                {
                  escCount++;
                  --esc;
                }
                cont = (escCount % 2 == 1); // find some non escaped escape char
                cur++; //skip quote
              }

              std::string s( beg+1, cur-beg-2 ); //without quotes
              //transform escaped escape
              replaceAll( s, "\\\\", "\\" );
              //transform escaped quotes (only same as open
              char tmpn[2] = { closeChar, 0 };
              char tmpo[3] = { '\\', closeChar, 0 };
              replaceAll( s, tmpo, tmpn );

              *result_r = s;
            }
            else
            {
              // skip non sepchars
              while( *cur && !::strchr( sepchars_r, *cur ) )
              {
                //ignore char after backslash
                if ( *cur == '\\' )
                {
                  ++cur;
                }
                ++cur;
              }
              // build string
              std::string s( beg, cur-beg );
              //transform escaped escape
              replaceAll( s, "\\\\", "\\" );

              const char *delimeter = sepchars_r;
              while ( *delimeter )
              {
                std::string ds("\\");
                const char tmp[2] = { *delimeter, '\0' };
                std::string del(tmp);
                ds+= del;
                replaceAll( s, ds, del );
                ++delimeter;
              }

              *result_r = s;
            }
            // skip sepchars
            if ( *cur && ::strchr( sepchars_r, *cur ) )
              ++cur;
            while ( *cur && ::strchr( sepchars_r, *cur ) )
            {
              ++cur;
              if (withEmpty)
              {
                *result_r = "";
                ++ret;
              }
            }
            // the last was a separator => one more field
            if ( !*cur && withEmpty && ::strchr( sepchars_r, *(cur-1) ) )
            {
              *result_r = "";
              ++ret;
            }
          }
        return ret;
      }

    template<class _OutputIterator>
      unsigned splitFields( const C_Str &   line_r,
                            _OutputIterator result_r,
                            const C_Str &   sepchars_r = ":" )
      {
        const char * beg = line_r;
        const char * cur = beg;
        unsigned ret = 0;
        for ( beg = cur; *beg; beg = cur, ++result_r )
          {
            // skip non sepchars
            while( *cur && !::strchr( sepchars_r, *cur ) )
              ++cur;
            // build string
            *result_r = std::string( beg, cur-beg );
            ++ret;
            // skip sepchar
            if ( *cur )
            {
              ++cur;
              if ( ! *cur )                // ending with sepchar
              {
                *result_r = std::string(); // add final empty field
                ++ret;
                break;
              }
            }
          }
        return ret;
      }

    template<class _OutputIterator>
      unsigned splitFieldsEscaped( const C_Str &   line_r,
                            _OutputIterator result_r,
                            const C_Str &   sepchars_r = ":" )
      {
        return
          splitEscaped( line_r, result_r, sepchars_r, true /* withEmpty */ );
      }



    template <class _Iterator>
      std::string join( _Iterator begin, _Iterator end,
                        const C_Str & sep_r = " " )
      {
        std::string res;
        for ( _Iterator iter = begin; iter != end; ++ iter )
          {
            if ( iter != begin )
              res += sep_r;
            res += asString(*iter);
          }
        return res;
      }

    template <class _Container>
      std::string join( const _Container & cont_r,
                        const C_Str & sep_r = " " )
      { return join( cont_r.begin(), cont_r.end(), sep_r ); }

    template <class _Iterator>
      std::string joinEscaped( _Iterator begin, _Iterator end,
                               const char sep_r = ' ' )
      {
        std::vector<char> buf;
        for ( _Iterator iter = begin; iter != end; ++ iter )
        {
          if ( iter != begin )
            buf.push_back( sep_r );

          if ( iter->empty() )
          {
            // empty string goes ""
            buf.push_back( '"' );
            buf.push_back( '"' );
          }
          else
          {
            std::string toadd( asString(*iter) );
            for_( ch, toadd.begin(), toadd.end() )
            {
              switch ( *ch )
              {
                case '"':
                case '\'':
                case '\\':
                  buf.push_back( '\\' );
                  buf.push_back( *ch );
                  break;
                default:
                  if ( *ch == sep_r )
                    buf.push_back( '\\' );
                  buf.push_back( *ch );
              }
            }
          }
        }
        return std::string( buf.begin(), buf.end() );
      }


      std::string escape( const C_Str & str_r, const char c = ' ' );

      inline void appendEscaped( std::string & str_r, const C_Str & next_r, const char sep_r = ' ' )
      {
        if ( ! str_r.empty() )
          str_r += sep_r;
        if ( next_r.empty() )
          str_r += "\"\"";
        else
          str_r += escape( next_r, sep_r );
      }





    std::string hexencode( const C_Str & str_r );
    std::string hexdecode( const C_Str & str_r );


    std::string toLower( const std::string & s );
    inline std::string toLower( const char * s )
    { return( s ? toLower( std::string(s) ) : std::string() ); }

    std::string toUpper( const std::string & s );
    inline std::string toUpper( const char * s )
    { return( s ? toUpper( std::string(s) ) : std::string() ); }


    inline int compareCI( const C_Str & lhs, const C_Str & rhs )
    { return ::strcasecmp( lhs, rhs ); }

    inline bool contains( const C_Str & str_r, const C_Str & val_r )
    { return ::strstr( str_r, val_r ); }
    inline bool containsCI( const C_Str & str_r, const C_Str & val_r )
    { return ::strcasestr( str_r, val_r ); }


    enum Trim {
      NO_TRIM = 0x00,
      L_TRIM  = 0x01,
      R_TRIM  = 0x02,
      TRIM    = (L_TRIM|R_TRIM)
    };

    std::string trim( const std::string & s, const Trim trim_r = TRIM );

    inline std::string ltrim( const std::string & s )
    { return trim( s, L_TRIM ); }

    inline std::string rtrim( const std::string & s )
    { return trim( s, R_TRIM ); }

    std::string stripFirstWord( std::string & line, const bool ltrim_first );

    std::string stripLastWord( std::string & line, const bool rtrim_first );

    std::string getline( std::istream & str, bool trim = false );

    std::string getline( std::istream & str, const Trim trim_r );

    std::string receiveUpTo( std::istream & str, const char delim_r, bool returnDelim_r = false );


    inline bool hasPrefix( const C_Str & str_r, const C_Str & prefix_r )
    { return( ::strncmp( str_r, prefix_r, prefix_r.size() ) == 0 ); }

    inline std::string stripPrefix( const C_Str & str_r, const C_Str & prefix_r )
    { return( hasPrefix( str_r, prefix_r ) ? str_r + prefix_r.size() : str_r.c_str() ); }

    inline bool hasSuffix( const C_Str & str_r, const C_Str & suffix_r )
    { return( str_r.size() >= suffix_r.size() && ::strncmp( str_r + str_r.size() - suffix_r.size() , suffix_r, suffix_r.size() ) == 0 ); }

    inline std::string stripSuffix( const C_Str & str_r, const C_Str & suffix_r )
    {
      if ( hasSuffix( str_r, suffix_r ) )
        return std::string( str_r, str_r.size() - suffix_r.size() );
      return str_r.c_str();
    }

    inline bool startsWith( const C_Str & str_r, const C_Str & prefix_r )
    { return hasPrefix( str_r, prefix_r ); }
    inline bool endsWith( const C_Str & str_r, const C_Str & prefix_r )
    { return hasSuffix( str_r, prefix_r ); }

  } // namespace str
} // namespace zypp
#endif // ZYPP_BASE_STRING_H