src/libs/common/StringFunctions.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2004-2008 Angel Vidal ( kry@amule.org )
   5 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26
  27 #ifndef STRING_FUNCTIONS_H
  28 #define STRING_FUNCTIONS_H
  29
  30 #include "../../Types.h"                // Needed for uint16 and uint32
  31
  32 class CPath;
  33
  34
  35 // UTF8 types: No UTF8, BOM prefix, or Raw UTF8
  36 enum EUtf8Str
  37 {
  38         utf8strNone,
  39         utf8strOptBOM,
  40         utf8strRaw
  41 };
  42
  43 /****************************************************/
  44 /******************* Inlines ************************/
  45 /****************************************************/
  46
  47 /**
  48  * Functions to perform Unicode <-> (char *) and UTF-8 conversion
  49  *
  50  * Please, DO NOT store pointers returned by unicode2char(), because they
  51  * get free'ed as soon as the return value of cWX2MB gets out of scope.
  52  * If you need to store a pointer, use a buffer of type wxWX2MBbuf:
  53  * and then cast it to a char pointer, e.g.:
  54  *
  55  * const wxWX2MBbuf buf(unicode2char(aWxString));
  56  *
  57  * --- Now you can freely use buf as if it were a (const char *) ---
  58  *
  59  * puts(buf);
  60  * printf("%s", (const char *)buf);
  61  *
  62  * The cast in printf is necessary because variable number of parameter
  63  * functions have no type for these parameters, so the automatic casting
  64  * of wxWX2MBbuf to (const char *) is not performed.
  65  *
  66  * --- don't worry about memory allocation, memory will be       ---
  67  * --- free'ed when buf gets out of scope, i.e., upon return     ---
  68  *
  69  * wxMB2WXbuf, wxWX2MBbuf are always the appropriate return type,
  70  * either (wxChar *) or (wxWCharBuffer)
  71  *
  72  * Use the simplified names Unicode2CharBuf and Char2UnicodeBuf, and
  73  * do not declare these names const or the compiler will complain about
  74  * a double const.
  75  */
  76 typedef const wxWX2MBbuf Unicode2CharBuf;
  77 typedef const wxMB2WXbuf Char2UnicodeBuf;
  78
  79 Unicode2CharBuf unicode2char(const wxChar* x);
  80 inline Char2UnicodeBuf char2unicode(const char* x)      { return wxConvLocal.cMB2WX(x); }
  81
  82 inline Unicode2CharBuf unicode2UTF8(const wxChar* x)    { return wxConvUTF8.cWX2MB(x); }
  83 inline Char2UnicodeBuf UTF82unicode(const char* x)      { return wxConvUTF8.cMB2WX(x); }
  84
  85 inline const wxCharBuffer char2UTF8(const char *x)      { return unicode2UTF8(char2unicode(x)); }
  86 inline const wxCharBuffer UTF82char(const char *x)      { return unicode2char(UTF82unicode(x)); }
  87
  88 inline Unicode2CharBuf filename2char(const wxChar* x)   { return wxConvFile.cWC2MB(x); }
  89 inline Char2UnicodeBuf char2filename(const char* x)     { return wxConvFile.cMB2WC(x); }
  90
  91
  92 //
  93 // Replaces "&" with "&&" in 'in' for use with text-labels
  94 //
  95 inline wxString MakeStringEscaped(wxString in) {
  96         in.Replace(wxT("&"),wxT("&&"));
  97         return in;
  98 }
  99
 100 // Make a string be a folder
 101 inline wxString MakeFoldername(wxString path) {
 102
 103         if ( !path.IsEmpty() && ( path.Right(1) == wxT('/' )) ) {
 104                 path.RemoveLast();
 105         }
 106
 107         return path;
 108 }
 109
 110 // Duplicates a string
 111 inline char* nstrdup(const char* src)
 112 {
 113         size_t len = (src ? strlen(src) : 0) + 1;
 114         char *res = new char[len];
 115         if ( src ) strcpy(res, src);
 116         res[len-1] = 0;
 117         return res;
 118 }
 119
 120
 121 // Replacements for atoi and atol that removes the need for converting
 122 // a string to normal chars with unicode2char. The value returned is the
 123 // value represented in the string or 0 if the conversion failed.
 124 inline long StrToLong(const wxString& str)
 125 {
 126         long value = 0;
 127         if (!str.ToLong(&value)) {      // value may be changed even if it failes according to wx docu
 128                 value = 0;
 129         }
 130         return value;
 131 }
 132
 133 inline unsigned long StrToULong(const wxString& str)
 134 {
 135         unsigned long value = 0;
 136         if (!str.ToULong(&value)) {
 137                 value = 0;
 138         }
 139         return value;
 140 }
 141
 142 inline unsigned long long StrToULongLong(const wxString& str)
 143 {
 144 #if wxCHECK_VERSION(2, 9, 0)
 145         unsigned long long value = 0;
 146         if (!str.ToULongLong(&value)) {
 147                 value = 0;
 148         }
 149         return value;
 150
 151 #else   // wx 2.8
 152
 153         Unicode2CharBuf buf = unicode2char(str);
 154         if (!buf) {             // something went wrong
 155                 return 0;
 156         }
 157 #ifdef _MSC_VER
 158         return _atoi64(buf);
 159 #else
 160         return atoll(buf);
 161 #endif
 162 #endif  // wx 2.8
 163 }
 164
 165 inline size_t GetRawSize(const wxString& rstr, EUtf8Str eEncode)
 166 {
 167         size_t RealLen = 0;
 168         switch (eEncode) {
 169                 case utf8strOptBOM:
 170                         RealLen = 3;
 171                 case utf8strRaw: {
 172                         Unicode2CharBuf s(unicode2UTF8(rstr));
 173                         if (s) {
 174                                 RealLen += strlen(s);
 175                                 break;
 176                         } else {
 177                                 RealLen = 0;
 178                         }
 179                 }
 180                 default: {
 181                         Unicode2CharBuf s(unicode2char(rstr));
 182                         if (s) {
 183                                 RealLen = strlen(s);
 184                         }
 185                 }
 186         }
 187
 188         return RealLen;
 189 }
 190
 191
 192 /****************************************************/
 193 /***************** Non-inlines **********************/
 194 /****************************************************/
 195
 196 /**
 197  * Truncates a filename to the specified length.
 198  *
 199  * @param filename The original filename.
 200  * @param length The max length of the resulting filename.
 201  * @param isFilePath If true, then the path will be truncated rather than the filename if possible.
 202  * @return The truncated filename.
 203  */
 204 wxString TruncateFilename(const CPath& filename, size_t length, bool isFilePath = false);
 205
 206 /**
 207  * Strips all path separators from the specified end of a path.
 208  *
 209  * Note: type must be either leading or trailing.
 210  */
 211 wxString StripSeparators(wxString path, wxString::stripType type);
 212
 213
 214 /**
 215  * Joins two path with the operating system specific path-separator.
 216  *
 217  * If any of the parameters are empty, the other parameter is
 218  * returned unchanged.
 219  */
 220 wxString JoinPaths(const wxString& path, const wxString& file);
 221
 222 // Makes sIn suitable for inclusion in an URL, by escaping all chars that could cause trouble.
 223 wxString URLEncode(const wxString& sIn);
 224
 225
 226 /**
 227  * Converts a hexadecimal number to a char.
 228  *
 229  * @param hex The hex-number, must be at most 2 digits long.
 230  * @return The resulting char or \0 if conversion failed.
 231  */
 232 wxChar HexToDec( const wxString& hex );
 233
 234
 235 /**
 236  * This function converts all valid HTML escape-codes to their corresponding chars.
 237  *
 238  * @param str The string to unescape.
 239  * @return The unescaped version of the input string.
 240  */
 241 wxString UnescapeHTML( const wxString& str );
 242
 243
 244 /**
 245  * Ensures that the url pass is valid by escaping various chars.
 246  */
 247 wxString validateURI(const wxString& url);
 248
 249
 250 /**
 251  * Compares two strings, while taking numerals into consideration.
 252  *
 253  * @return Returns -1 if a < b, 1 if a > b and 0 if a = b
 254  *
 255  * This function basically splits the two strings into a number of
 256  * fields, deliniated by whitespace, non-alphanumerical chars. The
 257  * numerals are then converted to integers, and the fields are
 258  * compared. This allows strings such as "a (2)" and "a (10)" to
 259  * be properly sorted for displaying.
 260  *
 261  * Currently does not handle floats (they are treated as to seperate
 262  * fields, nor negative numbers.
 263  */
 264 int FuzzyStrCmp(const wxString& a, const wxString& b);
 265
 266 /**
 267  * As with FuzzyStrCmp, but case insensitive.
 268  */
 269 int FuzzyStrCaseCmp(const wxString& a, const wxString& b);
 270
 271
 272 /**
 273  * This class provides a simple and fast tokenizer.
 274  */
 275 class CSimpleTokenizer
 276 {
 277 public:
 278         /**
 279          * @param str The string to tokenize.
 280          * @param delim The delimiter used to split the string.
 281          */
 282         CSimpleTokenizer(const wxString& str, wxChar delim);
 283
 284         /**
 285          * Returns the next part of the string separated by the
 286          * given delimiter. When the entire string has been
 287          * tokenized, an empty string is returned. Note that
 288          * empty tokens are also returned.
 289          */
 290         wxString next();
 291
 292         /**
 293          * Returns the remaining part of the string.
 294          *
 295          * The remaining part is defined as being the part after
 296          * the last encountered token, or an empty string if the
 297          * entire string has been tokenized.
 298          *
 299          * If next() has yet to be called, the entire string will
 300          * be returned.
 301          */
 302         wxString remaining() const;
 303
 304         /**
 305          * Returns the number of tokens encountered so far.
 306          */
 307         size_t tokenCount() const;
 308
 309 private:
 310         //! The string being tokenized.
 311         wxString m_string;
 312
 313         //! The delimiter used to split the string.
 314         wxChar m_delim;
 315
 316         //! A pointer to the current position in the string.
 317         const wxChar* m_ptr;
 318
 319         //! The number of tokens encountered.
 320         size_t m_count;
 321 };
 322
 323
 324 #endif // STRING_FUNCTIONS_H
 325 // File_checked_for_headers