String.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <string>
#include <boost/regex.hpp>

namespace zypp
{ 


  namespace str
  { 


    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(); }
    };


    using boost::regex;
    using boost::regex_match;
    using boost::regex_search;
    using boost::regex_replace;
    using boost::match_results;
    using boost::match_extra;
    using boost::cmatch;
    using boost::wcmatch;
    using boost::smatch;
    using boost::wsmatch;


    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 ); }


    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>
      inline _It strtonum( const std::string & str );

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

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

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


    inline std::string & replace_all( std::string & str, const std::string & from, const std::string & to )
    {
      std::string::size_type pos = 0;
      while( pos < str.length() && (pos = str.find( from, pos )) != std::string::npos )
      {
        str.replace( pos, from.size(), to );
        pos += to.size();
      }
      return str;
    }


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

    template<class _OutputIterator>
      unsigned splitFields( const std::string &   line_r,
                            _OutputIterator       result_r,
                            const std::string &   sepchars_r = ":" )
      {
        const char * beg = line_r.c_str();
        const char * cur = beg;
        unsigned ret = 0;
        for ( beg = cur; *beg; beg = cur, ++result_r )
          {
            // skip non sepchars
            while( *cur && !::strchr( sepchars_r.c_str(), *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 _Iterator>
      std::string join( _Iterator begin, _Iterator end,
                        const std::string & sep_r = " " )
      {
        std::string res;
        for ( _Iterator iter = begin; iter != end; ++ iter )
          {
            if ( iter != begin )
              res += sep_r;
            res += *iter;
          }
        return res;
      }

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



    std::string toLower( const std::string & s );

    std::string toUpper( const std::string & s );


    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 getline( std::istream & str, bool trim = false );

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


    inline bool hasPrefix( const std::string & str_r, const std::string & prefix_r )
    { return( str_r.substr( 0, prefix_r.size() ) == prefix_r ); }

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

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

---