C++ Utilities  5.6.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 <system_error>
18 #include <vector>
19 
20 namespace CppUtilities {
21 
30  void operator()(char *stringData)
31  {
32  std::free(stringData);
33  }
34 };
35 
39 using StringData = std::pair<std::unique_ptr<char[], StringDataDeleter>, std::size_t>;
40 //using StringData = std::pair<std::unique_ptr<char>, std::size_t>; // might work too
41 
43  const char *fromCharset, const char *toCharset, const char *inputBuffer, std::size_t inputBufferSize, float outputBufferSizeFactor = 1.0f);
44 CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16LE(const char *inputBuffer, std::size_t inputBufferSize);
45 CPP_UTILITIES_EXPORT StringData convertUtf16LEToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
46 CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16BE(const char *inputBuffer, std::size_t inputBufferSize);
47 CPP_UTILITIES_EXPORT StringData convertUtf16BEToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
48 CPP_UTILITIES_EXPORT StringData convertLatin1ToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
49 CPP_UTILITIES_EXPORT StringData convertUtf8ToLatin1(const char *inputBuffer, std::size_t inputBufferSize);
50 
51 #ifdef PLATFORM_WINDOWS
52 using WideStringData = std::pair<std::unique_ptr<wchar_t[]>, int>;
53 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(std::error_code &ec, const char *inputBuffer, int inputBufferSize = -1);
54 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(std::error_code &ec, const std::string &inputBuffer);
55 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(const char *inputBuffer, int inputBufferSize = -1);
56 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(const std::string &inputBuffer);
57 #endif
58 
59 CPP_UTILITIES_EXPORT void truncateString(std::string &str, char terminationChar = '\0');
60 
74 template <class Container = std::initializer_list<std::string>, class ReturnType = typename Container::value_type>
75 ReturnType joinStrings(const Container &strings, const typename Container::value_type &delimiter = typename Container::value_type(),
76  bool omitEmpty = false, const typename Container::value_type &leftClosure = typename Container::value_type(),
77  const typename Container::value_type &rightClosure = typename Container::value_type())
78 {
79  ReturnType res;
80  if (!strings.size()) {
81  return res;
82  }
83  std::size_t entries = 0, size = 0;
84  for (const auto &str : strings) {
85  if (omitEmpty && str.empty()) {
86  continue;
87  }
88  size += str.size();
89  ++entries;
90  }
91  if (!entries) {
92  return res;
93  }
94  size += (entries * leftClosure.size()) + (entries * rightClosure.size()) + ((entries - 1) * delimiter.size());
95  res.reserve(size);
96  for (const auto &str : strings) {
97  if (omitEmpty && str.empty()) {
98  continue;
99  }
100  if (!res.empty()) {
101  res.append(delimiter);
102  }
103  res.append(leftClosure);
104  res.append(str);
105  res.append(rightClosure);
106  }
107  return res;
108 }
109 
113 template <class Container = std::initializer_list<std::string>> inline std::vector<std::string> toMultiline(const Container &arrayOfLines)
114 {
115  return joinStrings(arrayOfLines, "\n", false);
116 }
117 
121 enum class EmptyPartsTreat {
122  Keep,
123  Omit,
124  Merge
125 };
126 
136 template <class Container = std::list<std::string>>
137 Container splitString(const typename Container::value_type &string, const typename Container::value_type &delimiter,
138  EmptyPartsTreat emptyPartsRole = EmptyPartsTreat::Keep, int maxParts = -1)
139 {
140  --maxParts;
141  Container res;
142  bool merge = false;
143  for (typename Container::value_type::size_type i = 0, end = string.size(), delimPos; i < end; i = delimPos + delimiter.size()) {
144  delimPos = string.find(delimiter, i);
145  if (!merge && maxParts >= 0 && res.size() == static_cast<typename Container::value_type::size_type>(maxParts)) {
146  if (delimPos == i && emptyPartsRole == EmptyPartsTreat::Merge) {
147  if (!res.empty()) {
148  merge = true;
149  continue;
150  }
151  }
152  delimPos = Container::value_type::npos;
153  }
154  if (delimPos == Container::value_type::npos) {
155  delimPos = string.size();
156  }
157  if (emptyPartsRole == EmptyPartsTreat::Keep || i != delimPos) {
158  if (merge) {
159  res.back().append(delimiter);
160  res.back().append(string.substr(i, delimPos - i));
161  merge = false;
162  } else {
163  res.emplace_back(string.substr(i, delimPos - i));
164  }
165  } else if (emptyPartsRole == EmptyPartsTreat::Merge) {
166  if (!res.empty()) {
167  merge = true;
168  }
169  }
170  }
171  return res;
172 }
173 
183 template <class Container = std::list<std::string>>
184 Container splitStringSimple(const typename Container::value_type &string, const typename Container::value_type &delimiter, int maxParts = -1)
185 {
186  --maxParts;
187  Container res;
188  for (typename Container::value_type::size_type i = 0, end = string.size(), delimPos; i < end; i = delimPos + delimiter.size()) {
189  delimPos = string.find(delimiter, i);
190  if (maxParts >= 0 && res.size() == static_cast<typename Container::value_type::size_type>(maxParts)) {
191  delimPos = Container::value_type::npos;
192  }
193  if (delimPos == Container::value_type::npos) {
194  delimPos = string.size();
195  }
196  res.emplace_back(string.substr(i, delimPos - i));
197  }
198  return res;
199 }
200 
204 template <class Container = std::vector<std::string>> inline std::vector<std::string> toArrayOfLines(const std::string &multilineString)
205 {
206  return splitString<Container>(multilineString, "\n", EmptyPartsTreat::Keep);
207 }
208 
212 template <typename StringType> bool startsWith(const StringType &str, const StringType &phrase)
213 {
214  if (str.size() < phrase.size()) {
215  return false;
216  }
217  for (auto stri = str.cbegin(), strend = str.cend(), phrasei = phrase.cbegin(), phraseend = phrase.cend();; ++stri, ++phrasei) {
218  if (phrasei == phraseend) {
219  return true;
220  } else if (stri == strend) {
221  return false;
222  } else if (*stri != *phrasei) {
223  return false;
224  }
225  }
226  return false;
227 }
228 
232 template <typename StringType> bool startsWith(const StringType &str, const typename StringType::value_type *phrase)
233 {
234  for (auto stri = str.cbegin(), strend = str.cend();; ++stri, ++phrase) {
235  if (!*phrase) {
236  return true;
237  } else if (stri == strend) {
238  return false;
239  } else if (*stri != *phrase) {
240  return false;
241  }
242  }
243  return false;
244 }
245 
249 template <typename StringType> bool endsWith(const StringType &str, const StringType &phrase)
250 {
251  if (str.size() < phrase.size()) {
252  return false;
253  }
254  for (auto stri = str.cend() - phrase.size(), strend = str.cend(), phrasei = phrase.cbegin(); stri != strend; ++stri, ++phrasei) {
255  if (*stri != *phrasei) {
256  return false;
257  }
258  }
259  return true;
260 }
261 
265 template <typename StringType> bool endsWith(const StringType &str, const typename StringType::value_type *phrase)
266 {
267  const auto phraseSize = std::strlen(phrase);
268  if (str.size() < phraseSize) {
269  return false;
270  }
271  for (auto stri = str.cend() - phraseSize, strend = str.cend(); stri != strend; ++stri, ++phrase) {
272  if (*stri != *phrase) {
273  return false;
274  }
275  }
276  return true;
277 }
278 
283 template <typename StringType> bool containsSubstrings(const StringType &str, std::initializer_list<StringType> substrings)
284 {
285  typename StringType::size_type currentPos = 0;
286  for (const auto &substr : substrings) {
287  if ((currentPos = str.find(substr, currentPos)) == StringType::npos) {
288  return false;
289  }
290  currentPos += substr.size();
291  }
292  return true;
293 }
294 
299 template <typename StringType>
300 bool containsSubstrings(const StringType &str, std::initializer_list<const typename StringType::value_type *> substrings)
301 {
302  typename StringType::size_type currentPos = 0;
303  for (const auto *substr : substrings) {
304  if ((currentPos = str.find(substr, currentPos)) == StringType::npos) {
305  return false;
306  }
307  currentPos += std::strlen(substr);
308  }
309  return true;
310 }
311 
315 template <typename StringType> void findAndReplace(StringType &str, const StringType &find, const StringType &replace)
316 {
317  for (typename StringType::size_type i = 0; (i = str.find(find, i)) != StringType::npos; i += replace.size()) {
318  str.replace(i, find.size(), replace);
319  }
320 }
321 
328 template <typename CharType> constexpr CharType digitToChar(CharType digit)
329 {
330  return digit <= 9 ? (digit + '0') : (digit + 'A' - 10);
331 }
332 
339 template <typename IntegralType, class StringType = std::string,
340  CppUtilities::Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
341 StringType numberToString(IntegralType number, typename StringType::value_type base = 10)
342 {
343  std::size_t resSize = 0;
344  for (auto n = number; n; n /= base, ++resSize)
345  ;
346  StringType res;
347  res.reserve(resSize);
348  do {
349  res.insert(res.begin(), digitToChar<typename StringType::value_type>(number % base));
350  number /= base;
351  } while (number);
352  return res;
353 }
354 
361 template <typename IntegralType, class StringType = std::string,
362  Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
363 StringType numberToString(IntegralType number, typename StringType::value_type base = 10)
364 {
365  const bool negative = number < 0;
366  std::size_t resSize;
367  if (negative) {
368  number = -number, resSize = 1;
369  } else {
370  resSize = 0;
371  }
372  for (auto n = number; n; n /= base, ++resSize)
373  ;
374  StringType res;
375  res.reserve(resSize);
376  do {
377  res.insert(res.begin(), digitToChar<typename StringType::value_type>(number % base));
378  number /= base;
379  } while (number);
380  if (negative) {
381  res.insert(res.begin(), '-');
382  }
383  return res;
384 }
385 
394 template <typename FloatingType, class StringType = std::string, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
395 StringType numberToString(FloatingType number, typename StringType::value_type base = 10)
396 {
397  std::basic_stringstream<typename StringType::value_type> ss;
398  ss << std::setbase(base) << number;
399  return ss.str();
400 }
401 
407 template <typename CharType> CharType charToDigit(CharType character, CharType base)
408 {
409  CharType res = base;
410  if (character >= '0' && character <= '9') {
411  res = character - '0';
412  } else if (character >= 'a' && character <= 'z') {
413  res = character - 'a' + 10;
414  } else if (character >= 'A' && character <= 'Z') {
415  res = character - 'A' + 10;
416  }
417  if (res < base) {
418  return res;
419  }
420  std::string errorMsg;
421  errorMsg.reserve(36);
422  errorMsg += "The character \"";
423  errorMsg += character;
424  errorMsg += "\" is no valid digit.";
425  throw ConversionException(std::move(errorMsg));
426 }
427 
436 template <typename IntegralType, typename StringType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
437 IntegralType stringToNumber(const StringType &string, typename StringType::value_type base = 10)
438 {
439  IntegralType result = 0;
440  for (const auto &c : string) {
441  if (c == ' ') {
442  continue;
443  }
444  result *= base;
445  result += charToDigit<typename StringType::value_type>(c, base);
446  }
447  return result;
448 }
449 
458 template <typename IntegralType, class StringType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
459 IntegralType stringToNumber(const StringType &string, typename StringType::value_type base = 10)
460 {
461  auto i = string.begin();
462  auto end = string.end();
463  for (; i != end && *i == ' '; ++i)
464  ;
465  if (i == end) {
466  return 0;
467  }
468  const bool negative = (*i == '-');
469  if (negative) {
470  ++i;
471  }
472  IntegralType result = 0;
473  for (; i != end; ++i) {
474  if (*i == ' ') {
475  continue;
476  }
477  result *= base;
478  result += charToDigit<typename StringType::value_type>(*i, base);
479  }
480  return negative ? -result : result;
481 }
482 
493 template <typename FloatingType, class StringType, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
494 FloatingType stringToNumber(const StringType &string, typename StringType::value_type base = 10)
495 {
496  std::basic_stringstream<typename StringType::value_type> ss;
497  ss << std::setbase(base) << string;
498  FloatingType result;
499  if ((ss >> result) && ss.eof()) {
500  return result;
501  }
502  std::string errorMsg;
503  errorMsg.reserve(42 + string.size());
504  errorMsg += "The string \"";
505  errorMsg += string;
506  errorMsg += "\" is no valid floating number.";
507  throw ConversionException(errorMsg);
508 }
509 
518 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
519 IntegralType stringToNumber(const CharType *string, unsigned char base = 10)
520 {
521  IntegralType result = 0;
522  for (; *string; ++string) {
523  if (*string == ' ') {
524  continue;
525  }
526  result *= base;
527  result += charToDigit<CharType>(*string, base);
528  }
529  return result;
530 }
531 
542 template <typename FloatingType, class CharType, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
543 FloatingType stringToNumber(const CharType *string, unsigned char base = 10)
544 {
545  std::basic_stringstream<CharType> ss;
546  ss << std::setbase(base) << string;
547  FloatingType result;
548  if ((ss >> result) && ss.eof()) {
549  return result;
550  }
551  std::string errorMsg;
552  errorMsg.reserve(42 + std::char_traits<CharType>::length(string));
553  errorMsg += "The string \"";
554  errorMsg += string;
555  errorMsg += "\" is no valid floating number.";
556  throw ConversionException(errorMsg);
557 }
558 
566 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
567 IntegralType bufferToNumber(const CharType *string, std::size_t size, unsigned char base = 10)
568 {
569  IntegralType result = 0;
570  for (const CharType *end = string + size; string != end; ++string) {
571  if (*string == ' ') {
572  continue;
573  }
574  result *= base;
575  result += charToDigit<CharType>(*string, base);
576  }
577  return result;
578 }
579 
587 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
588 IntegralType stringToNumber(const CharType *string, unsigned char base = 10)
589 {
590  if (!*string) {
591  return 0;
592  }
593  for (; *string && *string == ' '; ++string)
594  ;
595  if (!*string) {
596  return 0;
597  }
598  const bool negative = (*string == '-');
599  if (negative) {
600  ++string;
601  }
602  IntegralType result = 0;
603  for (; *string; ++string) {
604  if (*string == ' ') {
605  continue;
606  }
607  result *= base;
608  result += charToDigit<CharType>(*string, base);
609  }
610  return negative ? -result : result;
611 }
612 
620 template <typename IntegralType, class CharType, Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
621 IntegralType bufferToNumber(const CharType *string, std::size_t size, unsigned char base = 10)
622 {
623  if (!size) {
624  return 0;
625  }
626  const CharType *end = string + size;
627  for (; string != end && *string == ' '; ++string)
628  ;
629  if (string == end) {
630  return 0;
631  }
632  const bool negative = (*string == '-');
633  if (negative) {
634  ++string;
635  }
636  IntegralType result = 0;
637  for (; string != end; ++string) {
638  if (*string == ' ') {
639  continue;
640  }
641  result *= base;
642  result += charToDigit<CharType>(*string, base);
643  }
644  return negative ? -result : result;
645 }
646 
656 template <typename T> std::string interpretIntegerAsString(T integer, int startOffset = 0)
657 {
658  char buffer[sizeof(T)];
659  BE::getBytes(integer, buffer);
660  return std::string(buffer + startOffset, sizeof(T) - startOffset);
661 }
662 
663 CPP_UTILITIES_EXPORT std::string dataSizeToString(std::uint64_t sizeInByte, bool includeByte = false);
664 CPP_UTILITIES_EXPORT std::string bitrateToString(double speedInKbitsPerSecond, bool useByteInsteadOfBits = false);
665 CPP_UTILITIES_EXPORT std::string encodeBase64(const std::uint8_t *data, std::uint32_t dataSize);
666 CPP_UTILITIES_EXPORT std::pair<std::unique_ptr<std::uint8_t[]>, std::uint32_t> decodeBase64(const char *encodedStr, const std::uint32_t strSize);
667 } // namespace CppUtilities
668 
669 #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:567
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:257
CppUtilities::containsSubstrings
bool containsSubstrings(const StringType &str, std::initializer_list< StringType > substrings)
Returns whether str contains the specified substrings.
Definition: stringconversion.h:283
CppUtilities::startsWith
bool startsWith(const StringType &str, const StringType &phrase)
Returns whether str starts with phrase.
Definition: stringconversion.h:212
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:184
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:30
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:204
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:302
CppUtilities::joinStrings
ReturnType 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:75
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:315
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:381
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:328
i
constexpr int i
Definition: traitstests.cpp:106
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:270
CppUtilities::charToDigit
CharType charToDigit(CharType character, CharType base)
Returns number/digit of the specified character representation using the specified base.
Definition: stringconversion.h:407
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:121
CppUtilities::StringData
std::pair< std::unique_ptr< char[], StringDataDeleter >, std::size_t > StringData
Type used to return string encoding conversion result.
Definition: stringconversion.h:39
CppUtilities::endsWith
bool endsWith(const StringType &str, const StringType &phrase)
Returns whether str ends with phrase.
Definition: stringconversion.h:249
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:137
CppUtilities::StringDataDeleter
The StringDataDeleter struct deletes the data of a StringData instance.
Definition: stringconversion.h:25
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:656
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:437
CppUtilities::toMultiline
std::vector< std::string > toMultiline(const Container &arrayOfLines)
Converts the specified arrayOfLines to a multiline string.
Definition: stringconversion.h:113
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:341
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:341