C++ Utilities  5.2.0
Useful C++ classes and routines such as argument parser, IO and conversion utilities
stringconversion.h
Go to the documentation of this file.
1 #ifndef CONVERSION_UTILITIES_STRINGCONVERSION_H
2 #define CONVERSION_UTILITIES_STRINGCONVERSION_H
3 
4 #include "./binaryconversion.h"
6 
7 #include "../misc/traits.h"
8 
9 #include <cstdlib>
10 #include <cstring>
11 #include <initializer_list>
12 #include <iomanip>
13 #include <list>
14 #include <memory>
15 #include <sstream>
16 #include <string>
17 #include <vector>
18 
19 namespace CppUtilities {
20 
29  void operator()(char *stringData)
30  {
31  std::free(stringData);
32  }
33 };
34 
38 using StringData = std::pair<std::unique_ptr<char[], StringDataDeleter>, std::size_t>;
39 //using StringData = std::pair<std::unique_ptr<char>, std::size_t>; // might work too
40 
42  const char *fromCharset, const char *toCharset, const char *inputBuffer, std::size_t inputBufferSize, float outputBufferSizeFactor = 1.0f);
43 CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16LE(const char *inputBuffer, std::size_t inputBufferSize);
44 CPP_UTILITIES_EXPORT StringData convertUtf16LEToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
45 CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16BE(const char *inputBuffer, std::size_t inputBufferSize);
46 CPP_UTILITIES_EXPORT StringData convertUtf16BEToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
47 CPP_UTILITIES_EXPORT StringData convertLatin1ToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
48 CPP_UTILITIES_EXPORT StringData convertUtf8ToLatin1(const char *inputBuffer, std::size_t inputBufferSize);
49 
50 #ifdef PLATFORM_WINDOWS
51 using WideStringData = std::pair<std::unique_ptr<wchar_t[]>, int>;
52 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(const char *inputBuffer, int inputBufferSize = -1);
53 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(const std::string &inputBuffer);
54 #endif
55 
56 CPP_UTILITIES_EXPORT void truncateString(std::string &str, char terminationChar = '\0');
57 
71 template <class Container = std::initializer_list<std::string>>
72 typename Container::value_type joinStrings(const Container &strings,
73  const typename Container::value_type &delimiter = typename Container::value_type(), bool omitEmpty = false,
74  const typename Container::value_type &leftClosure = typename Container::value_type(),
75  const typename Container::value_type &rightClosure = typename Container::value_type())
76 {
77  typename Container::value_type res;
78  if (!strings.size()) {
79  return res;
80  }
81  std::size_t entries = 0, size = 0;
82  for (const auto &str : strings) {
83  if (omitEmpty && str.empty()) {
84  continue;
85  }
86  size += str.size();
87  ++entries;
88  }
89  if (!entries) {
90  return res;
91  }
92  size += (entries * leftClosure.size()) + (entries * rightClosure.size()) + ((entries - 1) * delimiter.size());
93  res.reserve(size);
94  for (const auto &str : strings) {
95  if (omitEmpty && str.empty()) {
96  continue;
97  }
98  if (!res.empty()) {
99  res.append(delimiter);
100  }
101  res.append(leftClosure);
102  res.append(str);
103  res.append(rightClosure);
104  }
105  return res;
106 }
107 
111 template <class Container = std::initializer_list<std::string>> inline std::vector<std::string> toMultiline(const Container &arrayOfLines)
112 {
113  return joinStrings(arrayOfLines, "\n", false);
114 }
115 
119 enum class EmptyPartsTreat {
120  Keep,
121  Omit,
122  Merge
123 };
124 
134 template <class Container = std::list<std::string>>
135 Container splitString(const typename Container::value_type &string, const typename Container::value_type &delimiter,
136  EmptyPartsTreat emptyPartsRole = EmptyPartsTreat::Keep, int maxParts = -1)
137 {
138  --maxParts;
139  Container res;
140  bool merge = false;
141  for (typename Container::value_type::size_type i = 0, end = string.size(), delimPos; i < end; i = delimPos + delimiter.size()) {
142  delimPos = string.find(delimiter, i);
143  if (!merge && maxParts >= 0 && res.size() == static_cast<typename Container::value_type::size_type>(maxParts)) {
144  if (delimPos == i && emptyPartsRole == EmptyPartsTreat::Merge) {
145  if (!res.empty()) {
146  merge = true;
147  continue;
148  }
149  }
150  delimPos = Container::value_type::npos;
151  }
152  if (delimPos == Container::value_type::npos) {
153  delimPos = string.size();
154  }
155  if (emptyPartsRole == EmptyPartsTreat::Keep || i != delimPos) {
156  if (merge) {
157  res.back().append(delimiter);
158  res.back().append(string.substr(i, delimPos - i));
159  merge = false;
160  } else {
161  res.emplace_back(string.substr(i, delimPos - i));
162  }
163  } else if (emptyPartsRole == EmptyPartsTreat::Merge) {
164  if (!res.empty()) {
165  merge = true;
166  }
167  }
168  }
169  return res;
170 }
171 
181 template <class Container = std::list<std::string>>
182 Container splitStringSimple(const typename Container::value_type &string, const typename Container::value_type &delimiter, int maxParts = -1)
183 {
184  --maxParts;
185  Container res;
186  for (typename Container::value_type::size_type i = 0, end = string.size(), delimPos; i < end; i = delimPos + delimiter.size()) {
187  delimPos = string.find(delimiter, i);
188  if (maxParts >= 0 && res.size() == static_cast<typename Container::value_type::size_type>(maxParts)) {
189  delimPos = Container::value_type::npos;
190  }
191  if (delimPos == Container::value_type::npos) {
192  delimPos = string.size();
193  }
194  res.emplace_back(string.substr(i, delimPos - i));
195  }
196  return res;
197 }
198 
202 template <class Container = std::vector<std::string>> inline std::vector<std::string> toArrayOfLines(const std::string &multilineString)
203 {
204  return splitString<Container>(multilineString, "\n", EmptyPartsTreat::Keep);
205 }
206 
210 template <typename StringType> bool startsWith(const StringType &str, const StringType &phrase)
211 {
212  if (str.size() < phrase.size()) {
213  return false;
214  }
215  for (auto stri = str.cbegin(), strend = str.cend(), phrasei = phrase.cbegin(), phraseend = phrase.cend();; ++stri, ++phrasei) {
216  if (phrasei == phraseend) {
217  return true;
218  } else if (stri == strend) {
219  return false;
220  } else if (*stri != *phrasei) {
221  return false;
222  }
223  }
224  return false;
225 }
226 
230 template <typename StringType> bool startsWith(const StringType &str, const typename StringType::value_type *phrase)
231 {
232  for (auto stri = str.cbegin(), strend = str.cend();; ++stri, ++phrase) {
233  if (!*phrase) {
234  return true;
235  } else if (stri == strend) {
236  return false;
237  } else if (*stri != *phrase) {
238  return false;
239  }
240  }
241  return false;
242 }
243 
247 template <typename StringType> bool endsWith(const StringType &str, const StringType &phrase)
248 {
249  if (str.size() < phrase.size()) {
250  return false;
251  }
252  for (auto stri = str.cend() - phrase.size(), strend = str.cend(), phrasei = phrase.cbegin(); stri != strend; ++stri, ++phrasei) {
253  if (*stri != *phrasei) {
254  return false;
255  }
256  }
257  return true;
258 }
259 
263 template <typename StringType> bool endsWith(const StringType &str, const typename StringType::value_type *phrase)
264 {
265  const auto phraseSize = std::strlen(phrase);
266  if (str.size() < phraseSize) {
267  return false;
268  }
269  for (auto stri = str.cend() - phraseSize, strend = str.cend(); stri != strend; ++stri, ++phrase) {
270  if (*stri != *phrase) {
271  return false;
272  }
273  }
274  return true;
275 }
276 
281 template <typename StringType> bool containsSubstrings(const StringType &str, std::initializer_list<StringType> substrings)
282 {
283  typename StringType::size_type currentPos = 0;
284  for (const auto &substr : substrings) {
285  if ((currentPos = str.find(substr, currentPos)) == StringType::npos) {
286  return false;
287  }
288  currentPos += substr.size();
289  }
290  return true;
291 }
292 
297 template <typename StringType>
298 bool containsSubstrings(const StringType &str, std::initializer_list<const typename StringType::value_type *> substrings)
299 {
300  typename StringType::size_type currentPos = 0;
301  for (const auto *substr : substrings) {
302  if ((currentPos = str.find(substr, currentPos)) == StringType::npos) {
303  return false;
304  }
305  currentPos += std::strlen(substr);
306  }
307  return true;
308 }
309 
313 template <typename StringType> void findAndReplace(StringType &str, const StringType &find, const StringType &replace)
314 {
315  for (typename StringType::size_type i = 0; (i = str.find(find, i)) != StringType::npos; i += replace.size()) {
316  str.replace(i, find.size(), replace);
317  }
318 }
319 
326 template <typename CharType> constexpr CharType digitToChar(CharType digit)
327 {
328  return digit <= 9 ? (digit + '0') : (digit + 'A' - 10);
329 }
330 
337 template <typename IntegralType, class StringType = std::string,
338  CppUtilities::Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
339 StringType numberToString(IntegralType number, typename StringType::value_type base = 10)
340 {
341  std::size_t resSize = 0;
342  for (auto n = number; n; n /= base, ++resSize)
343  ;
344  StringType res;
345  res.reserve(resSize);
346  do {
347  res.insert(res.begin(), digitToChar<typename StringType::value_type>(number % base));
348  number /= base;
349  } while (number);
350  return res;
351 }
352 
359 template <typename IntegralType, class StringType = std::string,
360  Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
361 StringType numberToString(IntegralType number, typename StringType::value_type base = 10)
362 {
363  const bool negative = number < 0;
364  std::size_t resSize;
365  if (negative) {
366  number = -number, resSize = 1;
367  } else {
368  resSize = 0;
369  }
370  for (auto n = number; n; n /= base, ++resSize)
371  ;
372  StringType res;
373  res.reserve(resSize);
374  do {
375  res.insert(res.begin(), digitToChar<typename StringType::value_type>(number % base));
376  number /= base;
377  } while (number);
378  if (negative) {
379  res.insert(res.begin(), '-');
380  }
381  return res;
382 }
383 
392 template <typename FloatingType, class StringType = std::string, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
393 StringType numberToString(FloatingType number, typename StringType::value_type base = 10)
394 {
395  std::basic_stringstream<typename StringType::value_type> ss;
396  ss << std::setbase(base) << number;
397  return ss.str();
398 }
399 
405 template <typename CharType> CharType charToDigit(CharType character, CharType base)
406 {
407  CharType res = base;
408  if (character >= '0' && character <= '9') {
409  res = character - '0';
410  } else if (character >= 'a' && character <= 'z') {
411  res = character - 'a' + 10;
412  } else if (character >= 'A' && character <= 'Z') {
413  res = character - 'A' + 10;
414  }
415  if (res < base) {
416  return res;
417  }
418  std::string errorMsg;
419  errorMsg.reserve(36);
420  errorMsg += "The character \"";
421  errorMsg += character;
422  errorMsg += "\" is no valid digit.";
423  throw ConversionException(std::move(errorMsg));
424 }
425 
434 template <typename IntegralType, typename StringType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
435 IntegralType stringToNumber(const StringType &string, typename StringType::value_type base = 10)
436 {
437  IntegralType result = 0;
438  for (const auto &c : string) {
439  if (c == ' ') {
440  continue;
441  }
442  result *= base;
443  result += charToDigit<typename StringType::value_type>(c, base);
444  }
445  return result;
446 }
447 
456 template <typename IntegralType, class StringType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
457 IntegralType stringToNumber(const StringType &string, typename StringType::value_type base = 10)
458 {
459  auto i = string.begin();
460  auto end = string.end();
461  for (; i != end && *i == ' '; ++i)
462  ;
463  if (i == end) {
464  return 0;
465  }
466  const bool negative = (*i == '-');
467  if (negative) {
468  ++i;
469  }
470  IntegralType result = 0;
471  for (; i != end; ++i) {
472  if (*i == ' ') {
473  continue;
474  }
475  result *= base;
476  result += charToDigit<typename StringType::value_type>(*i, base);
477  }
478  return negative ? -result : result;
479 }
480 
491 template <typename FloatingType, class StringType, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
492 FloatingType stringToNumber(const StringType &string, typename StringType::value_type base = 10)
493 {
494  std::basic_stringstream<typename StringType::value_type> ss;
495  ss << std::setbase(base) << string;
496  FloatingType result;
497  if ((ss >> result) && ss.eof()) {
498  return result;
499  }
500  std::string errorMsg;
501  errorMsg.reserve(42 + string.size());
502  errorMsg += "The string \"";
503  errorMsg += string;
504  errorMsg += "\" is no valid floating number.";
505  throw ConversionException(errorMsg);
506 }
507 
516 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
517 IntegralType stringToNumber(const CharType *string, unsigned char base = 10)
518 {
519  IntegralType result = 0;
520  for (; *string; ++string) {
521  if (*string == ' ') {
522  continue;
523  }
524  result *= base;
525  result += charToDigit<CharType>(*string, base);
526  }
527  return result;
528 }
529 
540 template <typename FloatingType, class CharType, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
541 FloatingType stringToNumber(const CharType *string, unsigned char base = 10)
542 {
543  std::basic_stringstream<CharType> ss;
544  ss << std::setbase(base) << string;
545  FloatingType result;
546  if ((ss >> result) && ss.eof()) {
547  return result;
548  }
549  std::string errorMsg;
550  errorMsg.reserve(42 + std::char_traits<CharType>::length(string));
551  errorMsg += "The string \"";
552  errorMsg += string;
553  errorMsg += "\" is no valid floating number.";
554  throw ConversionException(errorMsg);
555 }
556 
564 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
565 IntegralType bufferToNumber(const CharType *string, std::size_t size, unsigned char base = 10)
566 {
567  IntegralType result = 0;
568  for (const CharType *end = string + size; string != end; ++string) {
569  if (*string == ' ') {
570  continue;
571  }
572  result *= base;
573  result += charToDigit<CharType>(*string, base);
574  }
575  return result;
576 }
577 
585 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
586 IntegralType stringToNumber(const CharType *string, unsigned char base = 10)
587 {
588  if (!*string) {
589  return 0;
590  }
591  for (; *string && *string == ' '; ++string)
592  ;
593  if (!*string) {
594  return 0;
595  }
596  const bool negative = (*string == '-');
597  if (negative) {
598  ++string;
599  }
600  IntegralType result = 0;
601  for (; *string; ++string) {
602  if (*string == ' ') {
603  continue;
604  }
605  result *= base;
606  result += charToDigit<CharType>(*string, base);
607  }
608  return negative ? -result : result;
609 }
610 
618 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
619 IntegralType bufferToNumber(const CharType *string, std::size_t size, unsigned char base = 10)
620 {
621  if (!size) {
622  return 0;
623  }
624  const CharType *end = string + size;
625  for (; string != end && *string == ' '; ++string)
626  ;
627  if (string == end) {
628  return 0;
629  }
630  const bool negative = (*string == '-');
631  if (negative) {
632  ++string;
633  }
634  IntegralType result = 0;
635  for (; string != end; ++string) {
636  if (*string == ' ') {
637  continue;
638  }
639  result *= base;
640  result += charToDigit<CharType>(*string, base);
641  }
642  return negative ? -result : result;
643 }
644 
654 template <typename T> std::string interpretIntegerAsString(T integer, int startOffset = 0)
655 {
656  char buffer[sizeof(T)];
657  BE::getBytes(integer, buffer);
658  return std::string(buffer + startOffset, sizeof(T) - startOffset);
659 }
660 
661 CPP_UTILITIES_EXPORT std::string dataSizeToString(std::uint64_t sizeInByte, bool includeByte = false);
662 CPP_UTILITIES_EXPORT std::string bitrateToString(double speedInKbitsPerSecond, bool useByteInsteadOfBits = false);
663 CPP_UTILITIES_EXPORT std::string encodeBase64(const std::uint8_t *data, std::uint32_t dataSize);
664 CPP_UTILITIES_EXPORT std::pair<std::unique_ptr<std::uint8_t[]>, std::uint32_t> decodeBase64(const char *encodedStr, const std::uint32_t strSize);
665 } // namespace CppUtilities
666 
667 #endif // CONVERSION_UTILITIES_STRINGCONVERSION_H
CppUtilities::Traits::EnableIf
typename std::enable_if< All< Condition... >::value, Detail::Enabler >::type EnableIf
Shortcut for std::enable_if to omit ::value and ::type.
Definition: traits.h:51
CppUtilities::convertLatin1ToUtf8
CPP_UTILITIES_EXPORT StringData convertLatin1ToUtf8(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified Latin-1 string to UTF-8.
Definition: stringconversion.cpp:179
CppUtilities::convertUtf16BEToUtf8
CPP_UTILITIES_EXPORT StringData convertUtf16BEToUtf8(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-16 (big-endian) string to UTF-8.
Definition: stringconversion.cpp:170
CppUtilities::bufferToNumber
IntegralType bufferToNumber(const CharType *string, std::size_t size, unsigned char base=10)
Converts the given string of size characters to an unsigned numeric value using the specified base.
Definition: stringconversion.h:565
CppUtilities::truncateString
CPP_UTILITIES_EXPORT void truncateString(std::string &str, char terminationChar='\0')
Truncates all characters after the first occurrence of the specified terminationChar and the terminat...
Definition: stringconversion.cpp:233
CppUtilities::containsSubstrings
bool containsSubstrings(const StringType &str, std::initializer_list< StringType > substrings)
Returns whether str contains the specified substrings.
Definition: stringconversion.h:281
CppUtilities::startsWith
bool startsWith(const StringType &str, const StringType &phrase)
Returns whether str starts with phrase.
Definition: stringconversion.h:210
CppUtilities::splitStringSimple
Container splitStringSimple(const typename Container::value_type &string, const typename Container::value_type &delimiter, int maxParts=-1)
Splits the given string (which might also be a string view) at the specified delimiter.
Definition: stringconversion.h:182
CppUtilities::StringDataDeleter::operator()
void operator()(char *stringData)
Deletes the specified stringData with std::free(), because the memory has been allocated using std::m...
Definition: stringconversion.h:29
CppUtilities::convertString
CPP_UTILITIES_EXPORT StringData convertString(const char *fromCharset, const char *toCharset, const char *inputBuffer, std::size_t inputBufferSize, float outputBufferSizeFactor=1.0f)
Converts the specified string from one character set to another.
Definition: stringconversion.cpp:134
CppUtilities::toArrayOfLines
std::vector< std::string > toArrayOfLines(const std::string &multilineString)
Converts the specified multilineString to an array of lines.
Definition: stringconversion.h:202
CppUtilities::convertUtf8ToUtf16BE
CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16BE(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-8 string to UTF-16 (big-endian).
Definition: stringconversion.cpp:161
CppUtilities::EmptyPartsTreat::Omit
@ Omit
binaryconversion.h
CppUtilities::bitrateToString
CPP_UTILITIES_EXPORT std::string bitrateToString(double speedInKbitsPerSecond, bool useByteInsteadOfBits=false)
Converts the specified bitrate in kbit/s to its equivalent std::string representation.
Definition: stringconversion.cpp:278
CppUtilities::joinStrings
Container::value_type joinStrings(const Container &strings, const typename Container::value_type &delimiter=typename Container::value_type(), bool omitEmpty=false, const typename Container::value_type &leftClosure=typename Container::value_type(), const typename Container::value_type &rightClosure=typename Container::value_type())
Joins the given strings using the specified delimiter.
Definition: stringconversion.h:72
CppUtilities::findAndReplace
void findAndReplace(StringType &str, const StringType &find, const StringType &replace)
Replaces all occurences of find with relpace in the specified str.
Definition: stringconversion.h:313
CppUtilities::decodeBase64
CPP_UTILITIES_EXPORT std::pair< std::unique_ptr< std::uint8_t[]>, std::uint32_t > decodeBase64(const char *encodedStr, const std::uint32_t strSize)
Decodes the specified Base64 encoded string.
Definition: stringconversion.cpp:357
CppUtilities
Contains all utilities provides by the c++utilities library.
Definition: argumentparser.h:17
CppUtilities::digitToChar
constexpr CharType digitToChar(CharType digit)
Returns the character representation of the specified digit.
Definition: stringconversion.h:326
i
constexpr int i
Definition: traitstests.cpp:103
CppUtilities::EmptyPartsTreat::Keep
@ Keep
CppUtilities::convertUtf16LEToUtf8
CPP_UTILITIES_EXPORT StringData convertUtf16LEToUtf8(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-16 (little-endian) string to UTF-8.
Definition: stringconversion.cpp:152
CppUtilities::dataSizeToString
CPP_UTILITIES_EXPORT std::string dataSizeToString(std::uint64_t sizeInByte, bool includeByte=false)
Converts the specified data size in byte to its equivalent std::string representation.
Definition: stringconversion.cpp:246
CppUtilities::charToDigit
CharType charToDigit(CharType character, CharType base)
Returns number/digit of the specified character representation using the specified base.
Definition: stringconversion.h:405
CppUtilities::ConversionException
The ConversionException class is thrown by the various conversion functions of this library when a co...
Definition: conversionexception.h:11
CppUtilities::convertUtf8ToLatin1
CPP_UTILITIES_EXPORT StringData convertUtf8ToLatin1(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-8 string to Latin-1.
Definition: stringconversion.cpp:188
CppUtilities::EmptyPartsTreat
EmptyPartsTreat
Specifies the role of empty parts when splitting strings.
Definition: stringconversion.h:119
CppUtilities::StringData
std::pair< std::unique_ptr< char[], StringDataDeleter >, std::size_t > StringData
Type used to return string encoding conversion result.
Definition: stringconversion.h:38
CppUtilities::endsWith
bool endsWith(const StringType &str, const StringType &phrase)
Returns whether str ends with phrase.
Definition: stringconversion.h:247
CppUtilities::EmptyPartsTreat::Merge
@ Merge
CppUtilities::splitString
Container splitString(const typename Container::value_type &string, const typename Container::value_type &delimiter, EmptyPartsTreat emptyPartsRole=EmptyPartsTreat::Keep, int maxParts=-1)
Splits the given string at the specified delimiter.
Definition: stringconversion.h:135
CppUtilities::StringDataDeleter
The StringDataDeleter struct deletes the data of a StringData instance.
Definition: stringconversion.h:24
CPP_UTILITIES_EXPORT
#define CPP_UTILITIES_EXPORT
Marks the symbol to be exported by the c++utilities library.
CppUtilities::interpretIntegerAsString
std::string interpretIntegerAsString(T integer, int startOffset=0)
Interprets the given integer at the specified position as std::string using the specified byte order.
Definition: stringconversion.h:654
conversionexception.h
CppUtilities::stringToNumber
IntegralType stringToNumber(const StringType &string, typename StringType::value_type base=10)
Converts the given string to an unsigned number assuming string uses the specified base.
Definition: stringconversion.h:435
CppUtilities::toMultiline
std::vector< std::string > toMultiline(const Container &arrayOfLines)
Converts the specified arrayOfLines to a multiline string.
Definition: stringconversion.h:111
CppUtilities::numberToString
StringType numberToString(IntegralType number, typename StringType::value_type base=10)
Converts the given number to its equivalent string representation using the specified base.
Definition: stringconversion.h:339
CppUtilities::convertUtf8ToUtf16LE
CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16LE(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-8 string to UTF-16 (little-endian).
Definition: stringconversion.cpp:143
CppUtilities::encodeBase64
CPP_UTILITIES_EXPORT std::string encodeBase64(const std::uint8_t *data, std::uint32_t dataSize)
Encodes the specified data to Base64.
Definition: stringconversion.cpp:317