stringutil.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

  File:       stringutil.h

  Author:     Michael Andres <ma@suse.de>
  Maintainer: Michael Andres <ma@suse.de>

  Purpose: Contains 'std::string form(const char * format, ...)' for
  printf style creation of strings and some more string utility
  functions.

/-*/
#ifndef stringutil_h
#define stringutil_h

#include <cstdio>
#include <cstdarg>

#include <iosfwd>
#include <vector>
#include <string>
#include <list>


namespace stringutil {
;

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

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

inline std::string form( const char * format, ... ) {
  char * buf = 0;
  std::string val;

  va_list ap;
  va_start( ap, format );

#if 1
  vasprintf( &buf, format, ap );
  if ( buf ) {
    val = buf;
    free( buf );
  }
#else
  // Don't know wheter we actually nedd two va_lists, one to
  // evaluate the buffer size needed, and one to actually fill
  // the buffer. Maybe there's a save way to reuse a va_lists.
  va_list ap1;
  va_start( ap1, format );
  buf = new char[vsnprintf( NULL, 0, format, ap ) + 1];
  vsprintf( buf, format, ap1 );
  val = buf;
  delete [] buf;
  va_end( ap1 );
#endif

  va_end( ap );
  return val;
}

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

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

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

extern unsigned split( const std::string          line_r,
                       std::vector<std::string> & words_r,
                       const std::string &        sep_t       = " \t",
                       const bool                 singlesep_r = false );

extern std::string join( const std::vector<std::string> & words_r,
                         const std::string & sep_r = " " );


inline std::list<std::string> splitToLines( const std::string text_r, const std::string & sep_r = "\n" )
{
  std::vector<std::string> lines;
  stringutil::split( text_r, lines, "\n", true );
  std::list<std::string> ret;
  for ( unsigned i = 0; i < lines.size(); ++i ) {
    ret.push_back( lines[i] );
  }
  return ret;
}

extern std::string stripFirstWord( std::string & value, const bool ltrim_first = false );

extern std::string ltrim( const std::string & s );
extern std::string rtrim( const std::string & s );
inline std::string  trim( const std::string & s, const Trim trim_r = TRIM ) {
  switch ( trim_r ) {
  case L_TRIM:
    return ltrim( s );
  case R_TRIM:
    return rtrim( s );
  case TRIM:
    return ltrim( rtrim( s ) );
  case NO_TRIM:
    break;
  }
  return s;
}

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

extern std::ostream & dumpOn( std::ostream & str, const std::list<std::string> & l, const bool numbered = false );
extern std::ostream & dumpOn( std::ostream & str, const std::vector<std::string> & l, const bool numbered = false );

}  // namespace stringutil

#endif // stringutil_h

---