source/ps/CStr.cpp

   1 /* Copyright (C) 2014 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /**
  19  * File        : CStr.cpp
  20  * Project     : engine
  21  * Description : Controls compilation of CStr class and
  22  *             : includes some function implementations.
  23  **/
  24 #include "precompiled.h"
  25
  26 #ifndef CStr_CPP_FIRST
  27 #define CStr_CPP_FIRST
  28
  29 #include "lib/fnv_hash.h"
  30 #include "lib/utf8.h"
  31 #include "lib/byte_order.h"
  32 #include "network/Serialization.h"
  33
  34 #include <iomanip>
  35 #include <sstream>
  36
  37 #define UNIDOUBLER_HEADER "CStr.cpp"
  38 #include "UniDoubler.h"
  39
  40
  41 // Only include these function definitions in the first instance of CStr.cpp:
  42
  43 /**
  44  * Convert CStr to UTF-8
  45  *
  46  * @return CStr8 converted string
  47  **/
  48 CStr8 CStrW::ToUTF8() const
  49 {
  50         Status err;
  51         return utf8_from_wstring(*this, &err);
  52 }
  53
  54 /**
  55  * Convert UTF-8 to CStr
  56  *
  57  * @return CStrW converted string
  58  **/
  59 CStrW CStr8::FromUTF8() const
  60 {
  61         Status err;
  62         return wstring_from_utf8(*this, &err);
  63 }
  64
  65 #else
  66
  67 // The following code is compiled twice, as CStrW then as CStr8:
  68
  69 #include "CStr.h"
  70
  71 #include <sstream>
  72
  73 #ifdef  _UNICODE
  74  #define tstringstream wstringstream
  75  #define _istspace iswspace
  76  #define _totlower towlower
  77  #define _totupper towupper
  78 #else
  79  #define tstringstream stringstream
  80  #define _istspace isspace
  81  #define _totlower tolower
  82  #define _totupper toupper
  83 #endif
  84
  85 CStr CStr::Repeat(const CStr& String, size_t Reps)
  86 {
  87         CStr ret;
  88         ret.reserve(String.length() * Reps);
  89         while (Reps--) ret += String;
  90         return ret;
  91 }
  92
  93 // Construction from numbers:
  94
  95 CStr CStr::FromInt(int n)
  96 {
  97         std::tstringstream ss;
  98         ss << n;
  99         return ss.str();
 100 }
 101
 102 CStr CStr::FromUInt(unsigned int n)
 103 {
 104         std::tstringstream ss;
 105         ss << n;
 106         return ss.str();
 107 }
 108
 109 CStr CStr::FromInt64(i64 n)
 110 {
 111         std::tstringstream ss;
 112         ss << n;
 113         return ss.str();
 114 }
 115
 116 CStr CStr::FromDouble(double n)
 117 {
 118         std::tstringstream ss;
 119         ss << n;
 120         return ss.str();
 121 }
 122
 123 // Conversion to numbers:
 124
 125 int CStr::ToInt() const
 126 {
 127         int ret = 0;
 128         std::tstringstream str(*this);
 129         str >> ret;
 130         return ret;
 131 }
 132
 133 unsigned int CStr::ToUInt() const
 134 {
 135         unsigned int ret = 0;
 136         std::tstringstream str(*this);
 137         str >> ret;
 138         return ret;
 139 }
 140
 141 long CStr::ToLong() const
 142 {
 143         long ret = 0;
 144         std::tstringstream str(*this);
 145         str >> ret;
 146         return ret;
 147 }
 148
 149 unsigned long CStr::ToULong() const
 150 {
 151         unsigned long ret = 0;
 152         std::tstringstream str(*this);
 153         str >> ret;
 154         return ret;
 155 }
 156
 157 float CStr::ToFloat() const
 158 {
 159         float ret = 0;
 160         std::tstringstream str(*this);
 161         str >> ret;
 162         return ret;
 163 }
 164
 165 double CStr::ToDouble() const
 166 {
 167         double ret = 0;
 168         std::tstringstream str(*this);
 169         str >> ret;
 170         return ret;
 171 }
 172
 173
 174 // Search the string for another string
 175 long CStr::Find(const CStr& Str) const
 176 {
 177         size_t Pos = find(Str, 0);
 178
 179         if (Pos != npos)
 180                 return (long)Pos;
 181
 182         return -1;
 183 }
 184
 185 // Search the string for another string
 186 long CStr::Find(const tchar chr) const
 187 {
 188         size_t Pos = find(chr, 0);
 189
 190         if (Pos != npos)
 191                 return (long)Pos;
 192
 193         return -1;
 194 }
 195
 196 // Search the string for another string
 197 long CStr::Find(const int start, const tchar chr) const
 198 {
 199         size_t Pos = find(chr, start);
 200
 201         if (Pos != npos)
 202                 return (long)Pos;
 203
 204         return -1;
 205 }
 206
 207 long CStr::FindInsensitive(const int start, const tchar chr) const { return LowerCase().Find(start, _totlower(chr)); }
 208 long CStr::FindInsensitive(const tchar chr) const { return LowerCase().Find(_totlower(chr)); }
 209 long CStr::FindInsensitive(const CStr& Str) const { return LowerCase().Find(Str.LowerCase()); }
 210
 211
 212 long CStr::ReverseFind(const CStr& Str) const
 213 {
 214         size_t Pos = rfind(Str, length() );
 215
 216         if (Pos != npos)
 217                 return (long)Pos;
 218
 219         return -1;
 220
 221 }
 222
 223 // Lowercase and uppercase
 224 CStr CStr::LowerCase() const
 225 {
 226         std::tstring NewString = *this;
 227         for (size_t i = 0; i < length(); i++)
 228                 NewString[i] = (tchar)_totlower((*this)[i]);
 229
 230         return NewString;
 231 }
 232
 233 CStr CStr::UpperCase() const
 234 {
 235         std::tstring NewString = *this;
 236         for (size_t i = 0; i < length(); i++)
 237                 NewString[i] = (tchar)_totupper((*this)[i]);
 238
 239         return NewString;
 240 }
 241
 242
 243 // Retrieve the substring of the first n characters
 244 CStr CStr::Left(size_t len) const
 245 {
 246         ENSURE(len <= length());
 247         return substr(0, len);
 248 }
 249
 250 // Retrieve the substring of the last n characters
 251 CStr CStr::Right(size_t len) const
 252 {
 253         ENSURE(len <= length());
 254         return substr(length()-len, len);
 255 }
 256
 257 // Retrieve the substring following the last occurrence of Str
 258 // (or the whole string if it doesn't contain Str)
 259 CStr CStr::AfterLast(const CStr& Str, size_t startPos) const
 260 {
 261         size_t pos = rfind(Str, startPos);
 262         if (pos == npos)
 263                 return *this;
 264         else
 265                 return substr(pos + Str.length());
 266 }
 267
 268 // Retrieve the substring preceding the last occurrence of Str
 269 // (or the whole string if it doesn't contain Str)
 270 CStr CStr::BeforeLast(const CStr& Str, size_t startPos) const
 271 {
 272         size_t pos = rfind(Str, startPos);
 273         if (pos == npos)
 274                 return *this;
 275         else
 276                 return substr(0, pos);
 277 }
 278
 279 // Retrieve the substring following the first occurrence of Str
 280 // (or the whole string if it doesn't contain Str)
 281 CStr CStr::AfterFirst(const CStr& Str, size_t startPos) const
 282 {
 283         size_t pos = find(Str, startPos);
 284         if (pos == npos)
 285                 return *this;
 286         else
 287                 return substr(pos + Str.length());
 288 }
 289
 290 // Retrieve the substring preceding the first occurrence of Str
 291 // (or the whole string if it doesn't contain Str)
 292 CStr CStr::BeforeFirst(const CStr& Str, size_t startPos) const
 293 {
 294         size_t pos = find(Str, startPos);
 295         if (pos == npos)
 296                 return *this;
 297         else
 298                 return substr(0, pos);
 299 }
 300
 301 // Remove all occurrences of some character or substring
 302 void CStr::Remove(const CStr& Str)
 303 {
 304         size_t FoundAt = 0;
 305         while (FoundAt != npos)
 306         {
 307                 FoundAt = find(Str, 0);
 308
 309                 if (FoundAt != npos)
 310                         erase(FoundAt, Str.length());
 311         }
 312 }
 313
 314 // Replace all occurrences of some substring by another
 315 void CStr::Replace(const CStr& ToReplace, const CStr& ReplaceWith)
 316 {
 317         size_t Pos = 0;
 318
 319         while (Pos != npos)
 320         {
 321                 Pos = find(ToReplace, Pos);
 322                 if (Pos != npos)
 323                 {
 324                         erase(Pos, ToReplace.length());
 325                         insert(Pos, ReplaceWith);
 326                         Pos += ReplaceWith.length();
 327                 }
 328         }
 329 }
 330
 331 std::string CStr::EscapeToPrintableASCII() const
 332 {
 333         std::string NewString;
 334         for (size_t i = 0; i < length(); i++)
 335         {
 336                 tchar ch = (*this)[i];
 337
 338                 if (ch == '"') NewString += "\\\"";
 339                 else if (ch == '\\') NewString += "\\\\";
 340                 else if (ch == '\b') NewString += "\\b";
 341                 else if (ch == '\f') NewString += "\\f";
 342                 else if (ch == '\n') NewString += "\\n";
 343                 else if (ch == '\r') NewString += "\\r";
 344                 else if (ch == '\t') NewString += "\\t";
 345                 else if (ch >= 32 && ch <= 126)
 346                         NewString += ch;
 347                 else
 348                 {
 349                         std::stringstream ss;
 350                         ss << "\\u" << std::hex << std::setfill('0') << std::setw(4) << (int)(unsigned char)ch;
 351                         NewString += ss.str();
 352                 }
 353         }
 354         return NewString;
 355 }
 356
 357 // Returns a trimmed string, removes whitespace from the left/right/both
 358 CStr CStr::Trim(PS_TRIM_MODE Mode) const
 359 {
 360         size_t Left = 0, Right = 0;
 361
 362         switch (Mode)
 363         {
 364                 case PS_TRIM_LEFT:
 365                 {
 366                         for (Left = 0; Left < length(); Left++)
 367                                 if (_istspace((*this)[Left]) == false)
 368                                         break; // end found, trim 0 to Left-1 inclusive
 369                 } break;
 370
 371                 case PS_TRIM_RIGHT:
 372                 {
 373                         Right = length();
 374                         while (Right--)
 375                                 if (_istspace((*this)[Right]) == false)
 376                                         break; // end found, trim len-1 to Right+1      inclusive
 377                 } break;
 378
 379                 case PS_TRIM_BOTH:
 380                 {
 381                         for (Left = 0; Left < length(); Left++)
 382                                 if (_istspace((*this)[Left]) == false)
 383                                         break; // end found, trim 0 to Left-1 inclusive
 384
 385                         Right = length();
 386                         while (Right--)
 387                                 if (_istspace((*this)[Right]) == false)
 388                                         break; // end found, trim len-1 to Right+1      inclusive
 389                 } break;
 390
 391                 default:
 392                         debug_warn(L"CStr::Trim: invalid Mode");
 393         }
 394
 395
 396         return substr(Left, Right-Left+1);
 397 }
 398
 399 CStr CStr::Pad(PS_TRIM_MODE Mode, size_t Length) const
 400 {
 401         size_t Left = 0, Right = 0;
 402
 403         if (Length <= length())
 404                 return *this;
 405
 406         // From here: Length-length() >= 1
 407
 408         switch (Mode)
 409         {
 410         case PS_TRIM_LEFT:
 411                 Left = Length - length();
 412                 break;
 413
 414         case PS_TRIM_RIGHT:
 415                 Right = Length - length();
 416                 break;
 417
 418         case PS_TRIM_BOTH:
 419                 Left  = (Length - length() + 1)/2;
 420                 Right = (Length - length() - 1)/2; // cannot be negative
 421                 break;
 422
 423         default:
 424                 debug_warn(L"CStr::Trim: invalid Mode");
 425         }
 426
 427         return std::tstring(Left, _T(' ')) + *this + std::tstring(Right, _T(' '));
 428 }
 429
 430 size_t CStr::GetHashCode() const
 431 {
 432         return (size_t)fnv_hash(data(), length()*sizeof(value_type));
 433                 // janwas 2005-03-18: now use 32-bit version; 64 is slower and
 434                 // the result was truncated down to 32 anyway.
 435 }
 436
 437 #ifdef _UNICODE
 438 /*
 439         CStrW is always serialized to/from UTF-16
 440 */
 441
 442 u8* CStrW::Serialize(u8* buffer) const
 443 {
 444         size_t len = length();
 445         size_t i = 0;
 446         for (i = 0; i < len; i++)
 447         {
 448                 const u16 bigEndian = to_be16((*this)[i]);
 449                 *(u16 *)(buffer + i*2) = bigEndian;
 450         }
 451         *(u16 *)(buffer + i*2) = 0;
 452         return buffer + len*2 + 2;
 453 }
 454
 455 const u8* CStrW::Deserialize(const u8* buffer, const u8* bufferend)
 456 {
 457         const u16 *strend = (const u16 *)buffer;
 458         while ((const u8 *)strend < bufferend && *strend) strend++;
 459         if ((const u8 *)strend >= bufferend) return NULL;
 460
 461         resize(strend - (const u16 *)buffer);
 462         const u16 *ptr = (const u16 *)buffer;
 463
 464         std::wstring::iterator str = begin();
 465         while (ptr < strend)
 466         {
 467                 const u16 native = to_be16(*(ptr++));   // we want from_be16, but that's the same
 468                 *(str++) = (tchar)native;
 469         }
 470
 471         return (const u8 *)(strend+1);
 472 }
 473
 474 size_t CStr::GetSerializedLength() const
 475 {
 476         return size_t(length()*2 + 2);
 477 }
 478
 479 #else
 480 /*
 481         CStr8 is always serialized to/from ASCII (or whatever 8-bit codepage stored
 482         in the CStr)
 483 */
 484
 485 u8* CStr8::Serialize(u8* buffer) const
 486 {
 487         size_t len = length();
 488         Serialize_int_4(buffer, (u32)len);
 489         size_t i = 0;
 490         for (i = 0; i < len; i++)
 491                 buffer[i] = (*this)[i];
 492         return buffer + len;
 493 }
 494
 495 const u8* CStr8::Deserialize(const u8* buffer, const u8* bufferend)
 496 {
 497         u32 len;
 498         Deserialize_int_4(buffer, len);
 499         if (buffer + len > bufferend)
 500                 return NULL;
 501         *this = std::string(buffer, buffer + len);
 502         return buffer + len;
 503 }
 504
 505 size_t CStr::GetSerializedLength() const
 506 {
 507         return length() + 4;
 508 }
 509
 510 #endif // _UNICODE
 511
 512 // Clean up, to keep the second pass through unidoubler happy
 513 #undef tstringstream
 514 #undef _tstod
 515 #undef _ttoi
 516 #undef _ttol
 517 #undef _istspace
 518 #undef _totlower
 519 #undef _totupper
 520
 521 #endif // CStr_CPP_FIRST