src/support/lstrings.h

   1 // -*- C++ -*-
   2 /**
   3  * \file lstrings.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjønnes
   8  * \author Jean-Marc Lasgouttes
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  *
  12  * A collection of string helper functions that works with string.
  13  * Some of these would certainly benefit from a rewrite/optimization.
  14  */
  15
  16 #ifndef LSTRINGS_H
  17 #define LSTRINGS_H
  18
  19 #include "support/docstring.h"
  20
  21 #include <vector>
  22
  23
  24 namespace lyx {
  25 namespace support {
  26
  27 /// Compare \p s and \p s2, ignoring the case.
  28 /// Does not depend on the locale.
  29 int compare_no_case(docstring const & s, docstring const & s2);
  30
  31 /// Compare \p s and \p s2, ignoring the case of ASCII characters only.
  32 int compare_ascii_no_case(std::string const & s, std::string const & s2);
  33
  34 /// Compare \p s and \p s2, ignoring the case of ASCII characters only.
  35 int compare_ascii_no_case(docstring const & s, docstring const & s2);
  36
  37 ///
  38 inline
  39 int compare(char const * a, char const * b)
  40 {
  41 #ifndef CXX_GLOBAL_CSTD
  42         return std::strcmp(a, b);
  43 #else
  44         return strcmp(a, b);
  45 #endif
  46 }
  47
  48 ///
  49 inline
  50 int compare(char const * a, char const * b, unsigned int len)
  51 {
  52 #ifndef CXX_GLOBAL_CSTD
  53         return std::strncmp(a, b, len);
  54 #else
  55         return strncmp(a, b, len);
  56 #endif
  57 }
  58
  59 ///
  60 bool isStrInt(std::string const & str);
  61
  62 /// does the std::string represent an unsigned integer value ?
  63 bool isStrUnsignedInt(std::string const & str);
  64
  65 ///
  66 bool isStrDbl(std::string const & str);
  67
  68 bool isHex(lyx::docstring const & str);
  69
  70 int hexToInt(lyx::docstring const & str);
  71
  72 /// is \p str pure ascii?
  73 bool isAscii(docstring const & str);
  74
  75 /// is \p str pure ascii?
  76 bool isAscii(std::string const & str);
  77
  78 /**
  79  * Changes the case of \p c to lowercase.
  80  * Don't use this for non-ASCII characters, since it depends on the locale.
  81  * This overloaded function is only implemented because the char_type variant
  82  * would be used otherwise, and we assert in this function that \p c is in
  83  * the ASCII range.
  84  */
  85 char lowercase(char c);
  86
  87 /**
  88  * Changes the case of \p c to uppercase.
  89  * Don't use this for non-ASCII characters, since it depends on the locale.
  90  * This overloaded function is only implemented because the char_type variant
  91  * would be used otherwise, and we assert in this function that \p c is in
  92  * the ASCII range.
  93  */
  94 char uppercase(char c);
  95
  96 /// Changes the case of \p c to lowercase.
  97 /// Does not depend on the locale.
  98 char_type lowercase(char_type c);
  99
 100 /// Changes the case of \p c to uppercase.
 101 /// Does not depend on the locale.
 102 char_type uppercase(char_type c);
 103
 104 /// same as lowercase(), but ignores locale
 105 std::string const ascii_lowercase(std::string const &);
 106 docstring const ascii_lowercase(docstring const &);
 107
 108 /// Changes the case of \p s to lowercase.
 109 /// Does not depend on the locale.
 110 docstring const lowercase(docstring const & s);
 111
 112 /// Changes the case of \p s to uppercase.
 113 /// Does not depend on the locale.
 114 docstring const uppercase(docstring const & s);
 115
 116 /// Does the string start with this prefix?
 117 bool prefixIs(docstring const &, char_type);
 118
 119 /// Does the std::string start with this prefix?
 120 bool prefixIs(std::string const &, std::string const &);
 121 bool prefixIs(docstring const &, docstring const &);
 122
 123 /// Does the string end with this char?
 124 bool suffixIs(std::string const &, char);
 125 bool suffixIs(docstring const &, char_type);
 126
 127 /// Does the std::string end with this suffix?
 128 bool suffixIs(std::string const &, std::string const &);
 129
 130 ///
 131 inline bool contains(std::string const & a, std::string const & b)
 132 {
 133         return a.find(b) != std::string::npos;
 134 }
 135
 136 inline bool contains(docstring const & a, docstring const & b)
 137 {
 138         return a.find(b) != docstring::npos;
 139 }
 140
 141 inline bool contains(std::string const & a, char b)
 142 {
 143         return a.find(b) != std::string::npos;
 144 }
 145
 146 inline bool contains(docstring const & a, char_type b)
 147 {
 148         return a.find(b) != docstring::npos;
 149 }
 150
 151 ///
 152 bool containsOnly(std::string const &, std::string const &);
 153
 154 /** Extracts a token from this string at the nth delim.
 155     Doesn't modify the original string. Similar to strtok.
 156     Example:
 157     \code
 158     token("a;bc;d", ';', 1) == "bc";
 159     token("a;bc;d", ';', 2) == "d";
 160     \endcode
 161 */
 162 std::string const token(std::string const & a, char delim, int n);
 163
 164 docstring const token(docstring const & a, char_type delim, int n);
 165
 166 /** Search a token in this string using the delim.
 167     Doesn't modify the original string. Returns -1 in case of
 168     failure.
 169     Example:
 170     \code
 171     tokenPos("a;bc;d", ';', "bc") == 1;
 172     tokenPos("a;bc;d", ';', "d") == 2;
 173     \endcode
 174 */
 175 int tokenPos(std::string const & a, char delim, std::string const & tok);
 176
 177
 178 /// Substitute all \a oldchar with \a newchar
 179 std::string const subst(std::string const & a, char oldchar, char newchar);
 180
 181 /// Substitute all \a oldchar with \a newchar
 182 docstring const subst(docstring const & a, char_type oldchar, char_type newchar);
 183
 184 /// substitutes all instances of \a oldstr with \a newstr
 185 std::string const subst(std::string const & a,
 186                    std::string const & oldstr, std::string const & newstr);
 187
 188 /// substitutes all instances of \a oldstr with \a newstr
 189 docstring const subst(docstring const & a,
 190                 docstring const & oldstr, docstring const & newstr);
 191
 192 /** Trims characters off the end and beginning of a string.
 193     \code
 194     trim("ccabccc", "c") == "ab".
 195     \endcode
 196 */
 197 docstring const trim(docstring const & a, char const * p = " ");
 198
 199 /** Trims characters off the end and beginning of a string.
 200     \code
 201     trim("ccabccc", "c") == "ab".
 202     \endcode
 203 */
 204 std::string const trim(std::string const & a, char const * p = " ");
 205
 206 /** Trims characters off the end of a string.
 207     \code
 208     rtrim("abccc", "c") == "ab".
 209     \endcode
 210 */
 211 std::string const rtrim(std::string const & a, char const * p = " ");
 212 docstring const rtrim(docstring const & a, char const * p = " ");
 213
 214 /** Trims characters off the beginning of a string.
 215     \code
 216    ("ababcdef", "ab") = "cdef"
 217     \endcode
 218 */
 219 std::string const ltrim(std::string const & a, char const * p = " ");
 220 docstring const ltrim(docstring const & a, char const * p = " ");
 221
 222 /** Splits the string given in the first argument at the first occurence
 223     of the third argumnent, delim.
 224     What precedes delim is returned in the second argument, piece; this
 225     will be the whole of the string if no delimiter is found.
 226     The return value is what follows delim, if anything. So the return
 227     value is the null string if no delimiter is found.
 228     Examples:
 229     \code
 230     s1= "a;bc"; s2= ""
 231     ret = split(s1, s2, ';') -> ret = "bc", s2 == "a"
 232     \endcode
 233  */
 234 std::string const split(std::string const & a, std::string & piece, char delim);
 235 docstring const split(docstring const & a, docstring & piece, char_type delim);
 236
 237 /// Same as split but does not return a piece
 238 std::string const split(std::string const & a, char delim);
 239
 240 /// Same as split but uses the last delim.
 241 std::string const rsplit(std::string const & a, std::string & piece, char delim);
 242
 243 /// Escapes non ASCII chars and other problematic characters that cause
 244 /// problems in latex labels.
 245 docstring const escape(docstring const & lab);
 246
 247 /// gives a vector of stringparts which have the delimiter delim
 248 std::vector<std::string> const getVectorFromString(std::string const & str,
 249                                               std::string const & delim = std::string(","));
 250 std::vector<docstring> const getVectorFromString(docstring const & str,
 251                 docstring const & delim = from_ascii(","));
 252
 253 // the same vice versa
 254 std::string const getStringFromVector(std::vector<std::string> const & vec,
 255                                  std::string const & delim = std::string(","));
 256
 257 /// Search \p search_token in \p str and return the position if it is
 258 /// found, else -1. The last item in \p str must be "".
 259 int findToken(char const * const str[], std::string const & search_token);
 260
 261 /// Convert internal line endings to line endings as expected by the OS
 262 docstring const externalLineEnding(docstring const & str);
 263
 264 /// Convert line endings in any formnat to internal line endings
 265 docstring const internalLineEnding(docstring const & str);
 266
 267
 268 #ifdef I_AM_NOT_AFRAID_OF_HEADER_LIBRARIES
 269
 270 #include <boost/format.hpp>
 271
 272 template<class Arg1>
 273 docstring bformat(docstring const & fmt, Arg1 arg1)
 274 {
 275         return (boost::basic_format<char_type>(fmt) % arg1).str();
 276 }
 277
 278
 279 template<class Arg1, class Arg2>
 280 docstring bformat(docstring const & fmt, Arg1 arg1, Arg2 arg2)
 281 {
 282         return (boost::basic_format<char_type>(fmt) % arg1 % arg2).str();
 283 }
 284
 285
 286 template<class Arg1, class Arg2, class Arg3>
 287 docstring bformat(docstring const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3)
 288 {
 289         return (boost::basic_format<char_type>(fmt) % arg1 % arg2 % arg3).str();
 290 }
 291
 292
 293 template<class Arg1, class Arg2, class Arg3, class Arg4>
 294 docstring bformat(docstring const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
 295 {
 296         return (boost::basic_format<char_type>(fmt) % arg1 % arg2 % arg3 % arg4).str();
 297 }
 298
 299 #else
 300
 301 template <class Arg1>
 302 docstring bformat(docstring const & fmt, Arg1);
 303
 304 template <class Arg1, class Arg2>
 305 docstring bformat(docstring const & fmt, Arg1, Arg2);
 306
 307 template <class Arg1, class Arg2, class Arg3>
 308 docstring bformat(docstring const & fmt, Arg1, Arg2, Arg3);
 309
 310 template <class Arg1, class Arg2, class Arg3, class Arg4>
 311 docstring bformat(docstring const & fmt, Arg1, Arg2, Arg3, Arg4);
 312
 313 #endif
 314
 315 } // namespace support
 316 } // namespace lyx
 317
 318 #endif