developer.intra2net.com Git - libi2ncommon/blob - src/stringfunc.hxx

   1 /*
   2 The software in this package is distributed under the GNU General
   3 Public License version 2 (with a special exception described below).
   4
   5 A copy of GNU General Public License (GPL) is included in this distribution,
   6 in the file COPYING.GPL.
   7
   8 As a special exception, if other files instantiate templates or use macros
   9 or inline functions from this file, or you compile this file and link it
  10 with other works to produce a work based on this file, this file
  11 does not by itself cause the resulting work to be covered
  12 by the GNU General Public License.
  13
  14 However the source code for this file must still be made available
  15 in accordance with section (3) of the GNU General Public License.
  16
  17 This exception does not invalidate any other reasons why a work based
  18 on this file might be covered by the GNU General Public License.
  19 */
  20 /** @file
  21  * @brief collection of string tools (/ functions).
  22  *
  23  * contains a collection of miscellaneous functions for dealing with strings.
  24  *
  25  * some functions (like trim, lower case, upper case ...) are available in two versions:
  26  * - a modifying one (suffix "Mod") which modifies the given string argument in place.
  27  * - a non modifying one which take a constant string reference and returns a new string.
  28  * .
  29  *
  30  *
  31  * (c) Copyright 2007-2008 by Intra2net AG
  32  */
  33
  34 #ifndef __STRINGFUNC_HXX
  35 #define __STRINGFUNC_HXX
  36
  37 #include <list>
  38 #include <vector>
  39 #include <string>
  40 #include <sstream>
  41 #include <stdexcept>
  42 #include <sys/types.h>
  43
  44 namespace I2n
  45 {
  46
  47 /*
  48 ** some useful constants:
  49 */
  50
  51 extern const std::string Whitespaces;
  52 extern const std::string LineEndings;
  53
  54
  55 /*
  56 ** predicates:
  57 */
  58
  59
  60 bool has_prefix(const std::string& str, const std::string& prefix);
  61
  62 bool has_suffix(const std::string& str, const std::string& suffix);
  63
  64
  65 /*
  66 ** tool functions(modifying):
  67 */
  68
  69 std::string trim_mod(std::string& str, const std::string& charlist = Whitespaces);
  70
  71 std::string chomp_mod(std::string& str, const std::string& what= LineEndings );
  72
  73 std::string to_lower_mod(std::string& str);
  74
  75 std::string to_upper_mod(std::string& str);
  76
  77
  78 /*
  79 ** tool functions (not modifying):
  80 */
  81
  82 std::string trim(const std::string& str, const std::string& charlist = Whitespaces);
  83
  84 std::string chomp(const std::string& str, const std::string& what= LineEndings );
  85
  86 std::string to_lower(const std::string& str);
  87
  88 std::string to_upper(const std::string& str);
  89
  90
  91 std::string remove_suffix(const std::string& str, const std::string& suffix);
  92
  93 std::string remove_prefix(const std::string& str, const std::string& prefix);
  94
  95
  96
  97 /*
  98 ** split and join:
  99 */
 100
 101
 102 bool pair_split(
 103    const std::string& str,
 104    std::string& key,
 105    std::string& value,
 106    char delimiter = '=');
 107
 108
 109 void split_string(
 110    const std::string& str,
 111    std::list< std::string >& result,
 112    const std::string& delimiter= "\n",
 113    bool omit_empty= false,
 114    const std::string& trim_list= std::string()
 115 );
 116
 117 void split_string(
 118    const std::string& str,
 119    std::vector< std::string >& result,
 120    const std::string& delimiter= "\n",
 121    bool omit_empty= false,
 122    const std::string& trim_list= std::string()
 123 );
 124
 125 std::list< std::string > split_string(
 126    const std::string& str,
 127    const std::string& delimiter = "\n",
 128    bool omit_empty= false,
 129    const std::string& trim_list= std::string()
 130 );
 131
 132
 133 std::string join_string(
 134    const std::list< std::string >& parts,
 135    const std::string& delimiter = "\n"
 136 );
 137
 138 std::string join_string(
 139    const std::vector< std::string >& parts,
 140    const std::string& delimiter = "\n"
 141 );
 142
 143
 144 /*
 145 ** conversions:
 146 */
 147
 148
 149 std::string convert_binary_to_hex(const std::string&str, bool upper_case_digits= false);
 150
 151 std::string convert_hex_to_binary(const std::string& str) throw(std::runtime_error);
 152
 153
 154 /*
 155 ** "type conversions":
 156 */
 157
 158
 159 /**
 160  * convert a datatype @a T to a string via string stream.
 161  *
 162  * This will not report trouble in conversion; for example:
 163  *     string_to<int>("christian")
 164  * will return 0 and not throw an error.
 165  * Use boost::lexical_cast<T>(string) to get error-checked results.
 166  *
 167  * @param s the string which should be converted to @a T.
 168  * @return the value of type T.
 169  */
 170 template<
 171 class T
 172 >
 173 T string_to(const std::string& s)
 174 {
 175    std::istringstream istr(s);
 176    T result;
 177    istr >> result;
 178    return result;
 179 } // eo string_to(const std::string&)
 180
 181
 182 /**
 183  * convert a datatype @a T to a string via string stream.
 184  *
 185  * @param s the string which should be converted to @a T.
 186  * @param result the resulting value of type @a T.
 187  * @return @a true iff the internal string stream was EOF after the conversion.
 188  *
 189  * @attention: does not return if the conversion was successful. So check for empty strings before.
 190  */
 191 template<
 192 class T
 193 >
 194 bool string_to(const std::string& s, T& result)
 195 {
 196    std::istringstream istr(s);
 197    istr >> result;
 198    return istr.eof();
 199 } // eo string_to(const std::string&)
 200
 201
 202 /**
 203  * convert string in hexadecimal notation to a datatype @a T
 204  * supports strings with and without "0x" notation, e.g. 0xff and FF are both valid
 205  *
 206  * @param s the hex string which should be converted to @a T.
 207  * @return the value of type T.
 208  */
 209 template<
 210 class T
 211 >
 212 T hex_string_to(const std::string& s)
 213 {
 214    std::istringstream istr(s);
 215    T result;
 216    istr >> std::hex >> result;
 217    return result;
 218 } // eo string_to(const std::string&)
 219
 220
 221 /**
 222  * convert string in hexadecimal notation to a datatype @a T
 223  * supports strings with and without "0x" notation, e.g. 0xff and FF are both valid
 224  *
 225  * @param s the hex string which should be converted to @a T.
 226  * @param result the resulting value of type @a T.
 227  * @return @a true iff the internal string stream was EOF after the conversion.
 228  *
 229  * @attention: does not return if the conversion was successful. So check for empty strings before.
 230  */
 231 template<
 232 class T
 233 >
 234 bool hex_string_to(const std::string& s, T& result)
 235 {
 236    std::istringstream istr(s);
 237    istr >> std::hex >> result;
 238    return istr.eof();
 239 } // eo string_to(const std::string&)
 240
 241
 242 /**
 243  * convert a string to another datatype @a T via string stream.
 244  *
 245  * @param v the value (of type @a T) which should be converted to a string.
 246  * @return the resulting string.
 247  */
 248 template<
 249 class T
 250 >
 251 std::string to_string(const T& v)
 252 {
 253    std::ostringstream ostr;
 254    ostr << v;
 255    return ostr.str();
 256 } // eo to_string(const T&)
 257
 258
 259 /**
 260  * Create a string with types shortened in texts describing C++ types
 261  *
 262  * for example: std::list<some_long_type, std::allocator<some_long_type> >
 263  * -->  std::list<some_long_type, _alloc_>
 264  *
 265  * and std::basic_string<char, std::char_traits<char>, std::allocator<char> >
 266  * --> std::string
 267  */
 268 std::string shorten_stl_types(const std::string &input);
 269
 270
 271 } // eo namespace I2n
 272
 273
 274 #if 0
 275 std::string to_lower(const std::string &src);
 276 std::string to_upper(const std::string &src);
 277 #else
 278 // compatibility: import lower/upper funcs from I2n:
 279 using I2n::to_lower;
 280 using I2n::to_upper;
 281 #endif
 282
 283
 284 enum UnitBase {
 285     UnitBase1000, // SI decimal, composed by multiples of 1000 (KB, MB, etc.)
 286     UnitBase1024 // IEC binary, composed by multiples of 1024 (KiB, MiB, etc. )
 287 };
 288
 289 enum UnitFormat {
 290     ShortUnitFormat, // B, KB, MB, ...
 291     LongUnitFormat // Byte, KByte, MByte, ...
 292 };
 293
 294 std::string nice_unit_format(
 295         const int64_t input,
 296         const UnitFormat format = ShortUnitFormat,
 297         const UnitBase base = UnitBase1024
 298 );
 299
 300 std::string nice_unit_format(
 301         const double input,
 302         const UnitFormat format = ShortUnitFormat,
 303         const UnitBase base = UnitBase1024
 304 );
 305
 306 bool replace_all(std::string &base, const std::string *ist, const std::string *soll);
 307 bool replace_all(std::string &base, const char *ist, const char *soll);
 308 bool replace_all(std::string &base, const char *ist, const std::string *soll);
 309 bool replace_all(std::string &base, const std::string &ist, const char *soll);
 310 bool replace_all(std::string &base, const std::string &ist, const std::string &soll);
 311
 312 std::string iso_to_utf8(const std::string& isostring);
 313 std::string utf8_to_iso(const std::string& utf8string);
 314 std::string utf7imap_to_utf8(const std::string &utf7imapstring);
 315 std::string utf8_to_utf7imap(const std::string &utf8string);
 316
 317 std::string strip_html_tags(const std::string &input);
 318 std::string smart_html_entities(const std::string &input);
 319 std::string html_entities(std::string str);
 320 std::string html_entities_to_console(std::string str);
 321
 322 typedef std::pair<std::string::size_type, std::string::size_type> CommentZone;
 323 std::vector<CommentZone> find_html_comments(const std::string &str);
 324 void remove_html_comments(std::string &str);
 325 void remove_html_comments(std::string &str, const std::vector<CommentZone> &comments);
 326
 327 std::string sanitize_for_logging(const std::string &str, const char replace_with='?');
 328
 329 std::string escape(const std::string &s);
 330
 331 std::string descape(const std::string &s, int startpos, int &endpos);
 332 inline std::string descape(const std::string &s)
 333 {
 334    int endpos;
 335    return descape(s,0,endpos);
 336 }
 337
 338 std::string escape_shellarg(const std::string &input);
 339
 340 #endif