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 by the first delim.
 223     Splits the string by the first appearance of delim.
 224     The leading string up to delim is returned in piece (not including
 225     delim), while the original string is cut from after the delimiter.
 226     Example:
 227     \code
 228     s1= ""; s2= "a;bc".split(s1, ';') -> s1 == "a"; s2 == "bc";
 229     \endcode
 230 */
 231 std::string const split(std::string const & a, std::string & piece, char delim);
 232 docstring const split(docstring const & a, docstring & piece, char_type delim);
 233
 234 /// Same as split but does not return a piece
 235 std::string const split(std::string const & a, char delim);
 236
 237 /// Same as split but uses the last delim.
 238 std::string const rsplit(std::string const & a, std::string & piece, char delim);
 239
 240 /// Escapes non ASCII chars and other problematic characters that cause
 241 /// problems in latex labels.
 242 docstring const escape(docstring const & lab);
 243
 244 /// gives a vector of stringparts which have the delimiter delim
 245 std::vector<std::string> const getVectorFromString(std::string const & str,
 246                                               std::string const & delim = std::string(","));
 247 std::vector<docstring> const getVectorFromString(docstring const & str,
 248                 docstring const & delim = from_ascii(","));
 249
 250 // the same vice versa
 251 std::string const getStringFromVector(std::vector<std::string> const & vec,
 252                                  std::string const & delim = std::string(","));
 253
 254 /// Search \p search_token in \p str and return the position if it is
 255 /// found, else -1. The last item in \p str must be "".
 256 int findToken(char const * const str[], std::string const & search_token);
 257
 258 /// Convert internal line endings to line endings as expected by the OS
 259 docstring const externalLineEnding(docstring const & str);
 260
 261 /// Convert line endings in any formnat to internal line endings
 262 docstring const internalLineEnding(docstring const & str);
 263
 264
 265 #ifdef I_AM_NOT_AFRAID_OF_HEADER_LIBRARIES
 266
 267 #include <boost/format.hpp>
 268
 269 template<class Arg1>
 270 docstring bformat(docstring const & fmt, Arg1 arg1)
 271 {
 272         return (boost::basic_format<char_type>(fmt) % arg1).str();
 273 }
 274
 275
 276 template<class Arg1, class Arg2>
 277 docstring bformat(docstring const & fmt, Arg1 arg1, Arg2 arg2)
 278 {
 279         return (boost::basic_format<char_type>(fmt) % arg1 % arg2).str();
 280 }
 281
 282
 283 template<class Arg1, class Arg2, class Arg3>
 284 docstring bformat(docstring const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3)
 285 {
 286         return (boost::basic_format<char_type>(fmt) % arg1 % arg2 % arg3).str();
 287 }
 288
 289
 290 template<class Arg1, class Arg2, class Arg3, class Arg4>
 291 docstring bformat(docstring const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
 292 {
 293         return (boost::basic_format<char_type>(fmt) % arg1 % arg2 % arg3 % arg4).str();
 294 }
 295
 296 #else
 297
 298 template <class Arg1>
 299 docstring bformat(docstring const & fmt, Arg1);
 300
 301 template <class Arg1, class Arg2>
 302 docstring bformat(docstring const & fmt, Arg1, Arg2);
 303
 304 template <class Arg1, class Arg2, class Arg3>
 305 docstring bformat(docstring const & fmt, Arg1, Arg2, Arg3);
 306
 307 template <class Arg1, class Arg2, class Arg3, class Arg4>
 308 docstring bformat(docstring const & fmt, Arg1, Arg2, Arg3, Arg4);
 309
 310 #endif
 311
 312 } // namespace support
 313 } // namespace lyx
 314
 315 #endif