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