12#ifndef ZYPP_BASE_STRING_H
13#define ZYPP_BASE_STRING_H
21#include <boost/format.hpp>
22#include <boost/utility/string_ref.hpp>
29namespace boost {
namespace logic {
class tribool; } }
41 {
return val_r.asUserString(); }
101#ifdef __cpp_lib_string_view
110 if (
_sze == std::string::npos )
115 operator const char *()
const {
return c_str(); }
125 {
return str <<
obj.c_str(); }
139 inline const std::string &
asString(
const std::string &
t )
143 {
return std::move(
t); }
146 {
return t ==
nullptr ? std::string() :
t; }
149 {
return t ==
nullptr ? std::string() :
t; }
153 {
return t.asString(); }
157 {
return p->asString(); }
161 {
return p->asString(); }
165 {
return t ?
"true" :
"false"; }
169 std::string
form(
const char * format, ... )
196 {
return _buf ? std::string(
_buf) : std::string(); }
218 {
_str << iomanip;
return *
this; }
220 operator std::string()
const {
return _str.
str(); }
222 std::string
str()
const {
return _str.str(); }
235 {
return str <<
obj.str(); }
259 {
_fmter % std::forward<Tp>(
arg);
return *
this; }
261 operator std::string()
const {
return _fmter.str(); }
274 {
return str <<
obj.fmter(); }
298 inline std::string
numstring(
unsigned long long n,
int w = 0 ) {
return form(
"%*llu",
w,
n ); }
333 inline std::string
hexstring(
unsigned long long n,
int w = 0 ) {
return form(
"%#0*llx",
w,
n ); }
357 inline std::string
octstring(
unsigned long long n,
int w = 0 ) {
return form(
"%#0*llo",
w,
n ); }
363 template <
typename TInt>
366 constexpr unsigned bits =
sizeof(TInt)*8;
367 std::string
ret( bits,
' ' );
369 for (
unsigned pos = bits; pos > 0; )
370 { --pos;
ret[pos] = ((
val_r & bit)?
'1':
'0'); bit = bit<<1; }
384 template<
typename TInt>
410 template<
typename TInt>
484 for ( std::string::size_type pos =
gap_r; pos <
inp_r.size(); pos +=
gap_r+1 )
506 inline std::string
ltrim(
const std::string &
s )
508 inline std::string
ltrim( std::string &&
s )
511 inline std::string
rtrim(
const std::string &
s )
513 inline std::string
rtrim( std::string &&
s )
530 template<
class TOutputIterator>
553 template<
class TOutputIterator>
594 template<
class TOutputIterator>
621 std::vector<char>
buf;
634 case '\\':
quoting = Quote::Slash;
break;
635 case '\'':
quoting = Quote::Single;
break;
636 case '"':
quoting = Quote::Double;
break;
637 default:
buf.push_back( *
cur );
break;
649 case '\'':
quoting = Quote::None;
break;
650 default:
buf.push_back( *
cur );
break;
657 case '\"':
quoting = Quote::None;
break;
658 case '\\':
quoting = Quote::DoubleSlash;
break;
659 default:
buf.push_back( *
cur );
break;
663 case Quote::DoubleSlash:
667 case '\\':
buf.push_back( *
cur );
break;
669 buf.push_back(
'\\' );
724 template<
class TOutputIterator>
735 if ( *
cur ==
'\\' && *(
cur+1) )
763 template<
class TOutputIterator>
775 template <
class TIterator>
776 std::string
join( TIterator begin, TIterator end,
const C_Str &
sep_r =
" " )
789 template <
class TContainer>
797 template <
class TIterator>
798 std::string
joinEscaped( TIterator begin, TIterator end,
const char sep_r =
' ' )
800 std::vector<char>
buf;
809 buf.push_back(
'"' );
810 buf.push_back(
'"' );
822 buf.push_back(
'\\' );
823 buf.push_back( *
ch );
827 buf.push_back(
'\\' );
828 buf.push_back( *
ch );
833 return std::string(
buf.begin(),
buf.end() );
855 for (
const char * e = text_r.c_str(), * s = e; *e; s = ++e )
857 for ( ; *e && *e !=
'\n'; ++e ) ;
859 if ( maxWitdh_r && width > maxWitdh_r )
863 for ( e = s+width; e > s && *e !=
' '; --e ) ;
870 str.write( s, width );
878 inline std::ostream &
printIndented( std::ostream &
str,
const std::string & text_r,
unsigned indent_r,
char indentch_r =
' ',
unsigned maxWitdh_r = 0 )
879 {
return printIndented(
str, text_r, std::string( indent_r, indentch_r ), maxWitdh_r ); }
881 inline std::ostream &
printIndented( std::ostream &
str,
const std::string & text_r,
unsigned indent_r,
unsigned maxWitdh_r,
char indentch_r =
' ' )
882 {
return printIndented(
str, text_r, std::string( indent_r, indentch_r ), maxWitdh_r ); }
887 inline std::ostream &
autoPrefix( std::ostream &
str,
const std::string & text_r,
const function<std::string(
const char*,
const char*)>& fnc_r )
889 for (
const char * e = text_r.c_str(); *e; ++e )
892 for ( ; *e && *e !=
'\n'; ++e ) ;
893 str << fnc_r( s, e );
902 inline std::ostream &
autoPrefix0( std::ostream &
str,
const std::string & text_r, function<std::string()> fnc_r )
904 auto wrap = [&fnc_r](
const char*,
const char* )-> std::string {
919 std::string
escape(
const C_Str & str_r,
const char c =
' ' )
ZYPP_API;
922 inline
void appendEscaped(
std::
string & str_r, const C_Str & next_r, const
char sep_r = ' ' )
924 if ( ! str_r.empty() )
926 if ( next_r.empty() )
929 str_r +=
escape( next_r, sep_r );
933 std::string
bEscape( std::string str_r,
const C_Str & special_r )
ZYPP_API;
954 std::string
hexencode(
const C_Str & str_r );
956 std::string
hexdecode(
const C_Str & str_r );
968 inline std::string
toLower(
const char * s )
969 {
return( s ?
toLower( std::string(s) ) :
std::string() ); }
977 inline std::string
toUpper(
const char * s )
978 {
return( s ?
toUpper( std::string(s) ) :
std::string() ); }
984 inline int compareCI(
const C_Str & lhs,
const C_Str & rhs )
985 { return ::strcasecmp( lhs, rhs ); }
991 inline bool contains(
const C_Str & str_r,
const C_Str & val_r )
992 { return ::strstr( str_r, val_r ); }
994 inline bool containsCI(
const C_Str & str_r,
const C_Str & val_r )
995 { return ::strcasestr( str_r, val_r ); }
1027 inline
bool hasPrefix( const C_Str & str_r, const C_Str & prefix_r )
1028 {
return( ::strncmp( str_r, prefix_r, prefix_r.size() ) == 0 ); }
1030 inline bool hasPrefixCI(
const C_Str & str_r,
const C_Str & prefix_r )
1031 {
return( ::strncasecmp( str_r, prefix_r, prefix_r.size() ) == 0 ); }
1034 inline std::string
stripPrefix(
const C_Str & str_r,
const C_Str & prefix_r )
1035 {
return(
hasPrefix( str_r, prefix_r ) ? str_r + prefix_r.size() : str_r.c_str() ); }
1037 inline std::string
stripPrefixCI(
const C_Str & str_r,
const C_Str & prefix_r )
1038 {
return(
hasPrefixCI( str_r, prefix_r ) ? str_r + prefix_r.size() : str_r.c_str() ); }
1041 inline bool hasSuffix(
const C_Str & str_r,
const C_Str & suffix_r )
1042 {
return( str_r.size() >= suffix_r.size() && ::strncmp( str_r + str_r.size() - suffix_r.size() , suffix_r, suffix_r.size() ) == 0 ); }
1044 inline bool hasSuffixCI(
const C_Str & str_r,
const C_Str & suffix_r )
1045 {
return( str_r.size() >= suffix_r.size() && ::strncasecmp( str_r + str_r.size() - suffix_r.size() , suffix_r, suffix_r.size() ) == 0 ); }
1048 inline std::string
stripSuffix(
const C_Str & str_r,
const C_Str & suffix_r )
1051 return std::string( str_r, str_r.size() - suffix_r.size() );
1052 return str_r.c_str();
1055 inline std::string
stripSuffixCI(
const C_Str & str_r,
const C_Str & suffix_r )
1058 return std::string( str_r, str_r.size() - suffix_r.size() );
1059 return str_r.c_str();
1063 inline std::string::size_type
commonPrefix(
const C_Str & lhs,
const C_Str & rhs )
1065 const char * lp = lhs.c_str();
1066 const char * rp = rhs.c_str();
1067 std::string::size_type ret = 0;
1068 while ( *lp == *rp && *lp !=
'\0' )
1069 { ++lp, ++rp, ++ret; }
1073 inline std::string::size_type
commonPrefixCI(
const C_Str & lhs,
const C_Str & rhs )
1075 const char * lp = lhs.c_str();
1076 const char * rp = rhs.c_str();
1077 std::string::size_type ret = 0;
1078 while ( tolower(*lp) == tolower(*rp) && *lp !=
'\0' )
1079 { ++lp, ++rp, ++ret; }
1085 inline bool startsWith(
const C_Str & str_r,
const C_Str & prefix_r )
1086 {
return hasPrefix( str_r, prefix_r ); }
1088 inline bool startsWithCI(
const C_Str & str_r,
const C_Str & prefix_r )
1092 inline bool endsWith(
const C_Str & str_r,
const C_Str & prefix_r )
1093 {
return hasSuffix( str_r, prefix_r ); }
1095 inline bool endsWithCI(
const C_Str & str_r,
const C_Str & prefix_r )
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string.
std::ostream & operator<<(std::ostream &str, const C_Str &obj)
Stream output.
C_Str(const std::string &str_r)
C_Str(const boost::string_ref &str_r)
const char * c_str() const
C_Str(const char *c_str_r)
std::string::size_type size_type
String related utilities and Regular expression matching.
std::string octstring(char n, int w=4)
std::string stripLastWord(std::string &line, const bool rtrim_first)
std::string hexdecode(const C_Str &str_r)
Decode hexencoded XX sequences.
std::string::size_type commonPrefix(const C_Str &lhs, const C_Str &rhs)
Return size of the common prefix of lhs and rhs.
Trim
To define how to trim.
std::string hexencode(const C_Str &str_r)
Encode all characters other than [a-zA-Z0-9] as XX.
std::string joinEscaped(TIterator begin, TIterator end, const char sep_r=' ')
Join strings using separator sep_r, quoting or escaping the values.
std::string & replaceAll(std::string &str_r, const std::string &from_r, const std::string &to_r)
Replace all occurrences of from_r with to_r in str_r (inplace).
std::string stripPrefixCI(const C_Str &str_r, const C_Str &prefix_r)
bool hasSuffix(const C_Str &str_r, const C_Str &suffix_r)
Return whether str_r has suffix suffix_r.
std::ostream & autoPrefix0(std::ostream &str, const std::string &text_r, function< std::string()> fnc_r)
unsigned splitFields(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=":")
Split line_r into fields.
std::string numstring(char n, int w=0)
std::string gsubFun(const std::string &str_r, const std::string &from_r, function< std::string()> to_r)
bool strToTrue(const C_Str &str)
Parsing boolean from string.
std::string binstring(TInt val_r)
String representation of number as bit-string with leading '0's.
TriBool strToTriBool(const C_Str &str)
Parse str into a bool if it's a legal true or false string; else indeterminate.
std::string::size_type commonPrefixCI(const C_Str &lhs, const C_Str &rhs)
std::string rxEscapeGlob(std::string str_r)
Escape GLOB str_r for use in a regex (not anchored by "^" or "$").
const std::string & asString(const std::string &t)
Global asString() that works with std::string too.
std::string stripFirstWord(std::string &line, const bool ltrim_first)
std::string stripSuffixCI(const C_Str &str_r, const C_Str &suffix_r)
std::ostream & autoPrefix(std::ostream &str, const std::string &text_r, const function< std::string(const char *, const char *)> &fnc_r)
Prefix lines by string computed by function taking line begin/end [std::string(const char*,...
std::string escape(const C_Str &str_r, const char sep_r)
Escape desired character c using a backslash.
void appendEscaped(std::string &str_r, const C_Str &next_r, const char sep_r=' ')
Escape next_r and append it to str_r using separator sep_r.
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
std::string toLower(const std::string &s)
Return lowercase version of s.
unsigned splitFieldsEscaped(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=":")
Split line_r into fields handling also escaped separators.
bool startsWith(const C_Str &str_r, const C_Str &prefix_r)
alias for hasPrefix
bool endsWith(const C_Str &str_r, const C_Str &prefix_r)
alias for hasSuffix
std::string stripSuffix(const C_Str &str_r, const C_Str &suffix_r)
Strip a suffix_r from str_r and return the resulting string.
std::string receiveUpTo(std::istream &str, const char delim_r, bool returnDelim_r)
Return stream content up to the next ocurrence of delim_r or EOF delim_r, if found,...
std::string rtrim(const std::string &s)
std::string join(TIterator begin, TIterator end, const C_Str &sep_r=" ")
Join strings using separator sep_r (defaults to BLANK).
std::string gsub(const std::string &str_r, const std::string &from_r, const std::string &to_r)
Return a string with all occurrences of from_r replaced with to_r.
std::string toUpper(const std::string &s)
Return uppercase version of s.
std::string ltrim(const std::string &s)
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
std::ostream & printIndented(std::ostream &str, const std::string &text_r, const std::string &indent_r=" ", unsigned maxWitdh_r=0)
Indent by string [" "] optionally wrap.
bool strToBool(const C_Str &str, bool default_r)
Parse str into a bool depending on the default value.
std::string bEscape(std::string str_r, const C_Str &special_r)
Return str_r with '\'-escaped chars occurring in special_r (and '\').
bool hasPrefixCI(const C_Str &str_r, const C_Str &prefix_r)
std::string stripPrefix(const C_Str &str_r, const C_Str &prefix_r)
Strip a prefix_r from str_r and return the resulting string.
std::string & replaceAllFun(std::string &str_r, const std::string &from_r, const function< std::string()> &to_r)
std::string rxEscapeStr(std::string str_r)
Escape plain STRING str_r for use in a regex (not anchored by "^" or "$").
std::string getline(std::istream &str, const Trim trim_r)
Return stream content up to (but not returning) the next newline.
std::string hexstring(char n, int w=4)
unsigned split(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \t", const Trim trim_r=NO_TRIM)
Split line_r into words.
TInt strtonum(const C_Str &str)
Parsing numbers from string.
bool containsCI(const C_Str &str_r, const C_Str &val_r)
Locate substring case insensitive.
bool contains(const C_Str &str_r, const C_Str &val_r)
Locate substring case sensitive.
bool strToFalse(const C_Str &str)
Return false if str is 0, false, no, off, never.
unsigned splitEscaped(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \t", bool withEmpty=false)
Split line_r into words with respect to escape delimeters.
bool endsWithCI(const C_Str &str_r, const C_Str &prefix_r)
bool hasSuffixCI(const C_Str &str_r, const C_Str &suffix_r)
std::string trim(const std::string &s, const Trim trim_r)
bool strToBoolNodefault(const C_Str &str, bool &return_r)
Parse str into a bool if it's a legal true or false string.
int compareCI(const C_Str &lhs, const C_Str &rhs)
std::string gapify(std::string inp_r, std::string::size_type gap_r=1, char gapchar=' ')
Enhance readability: insert gaps at regular distance.
bool startsWithCI(const C_Str &str_r, const C_Str &prefix_r)
Easy-to use interface to the ZYPP dependency resolver.
std::string asUserString(VendorSupportOption opt)
converts the support option to a name intended to be printed to the user.
boost::logic::tribool TriBool
3-state boolean logic (true, false and indeterminate).
Assert free called for allocated char *.
std::string asString() const
Convenient building of std::string via std::ostringstream Basically a std::ostringstream autoconverti...
std::ostream & operator<<(std::ostream &str, const Str &obj)
Stream output.
Str & operator<<(Tp &&val)
std::string asString() const
const std::ostream & stream() const
Str & operator<<(std::ostream &(*iomanip)(std::ostream &))
#define for_(IT, BEG, END)
Convenient for-loops using iterator.