C++ Utilities  5.10.2
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 <string_view>
18 #include <system_error>
19 #include <vector>
20 
21 #if __cplusplus >= 201709
22 #include <ranges>
23 #endif
24 
25 namespace CppUtilities {
26 
35  void operator()(char *stringData)
36  {
37  std::free(stringData);
38  }
39 };
40 
44 using StringData = std::pair<std::unique_ptr<char[], StringDataDeleter>, std::size_t>;
45 //using StringData = std::pair<std::unique_ptr<char>, std::size_t>; // might work too
46 
48  const char *fromCharset, const char *toCharset, const char *inputBuffer, std::size_t inputBufferSize, float outputBufferSizeFactor = 1.0f);
49 CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16LE(const char *inputBuffer, std::size_t inputBufferSize);
50 CPP_UTILITIES_EXPORT StringData convertUtf16LEToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
51 CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16BE(const char *inputBuffer, std::size_t inputBufferSize);
52 CPP_UTILITIES_EXPORT StringData convertUtf16BEToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
53 CPP_UTILITIES_EXPORT StringData convertLatin1ToUtf8(const char *inputBuffer, std::size_t inputBufferSize);
54 CPP_UTILITIES_EXPORT StringData convertUtf8ToLatin1(const char *inputBuffer, std::size_t inputBufferSize);
55 
56 #ifdef PLATFORM_WINDOWS
57 using WideStringData = std::pair<std::unique_ptr<wchar_t[]>, int>;
58 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(std::error_code &ec, const char *inputBuffer, int inputBufferSize = -1);
59 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(std::error_code &ec, const std::string &inputBuffer);
60 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(const char *inputBuffer, int inputBufferSize = -1);
61 CPP_UTILITIES_EXPORT WideStringData convertMultiByteToWide(const std::string &inputBuffer);
62 #endif
63 
64 CPP_UTILITIES_EXPORT void truncateString(std::string &str, char terminationChar = '\0');
65 
67 namespace Detail {
68 #if __cplusplus >= 201709
69 template <class Container>
70 using ContainerValueType = typename std::conditional_t<std::ranges::range<Container>,
71  std::iterator_traits<std::remove_cvref_t<std::ranges::iterator_t<Container>>>, Container>::value_type;
72 #else
73 template <class Container> using ContainerValueType = typename Container::value_type;
74 #endif
75 template <class Container> using DefaultReturnTypeForContainer = ContainerValueType<Container>;
76 template <class Container> using StringParamForContainer = std::basic_string_view<typename ContainerValueType<Container>::value_type>;
77 } // namespace Detail
79 
94 template <class Container = std::initializer_list<std::string>, class ReturnType = Detail::DefaultReturnTypeForContainer<Container>>
95 ReturnType joinStrings(const Container &strings, Detail::StringParamForContainer<Container> delimiter = Detail::StringParamForContainer<Container>(),
96  bool omitEmpty = false, Detail::StringParamForContainer<Container> leftClosure = Detail::StringParamForContainer<Container>(),
97  Detail::StringParamForContainer<Container> rightClosure = Detail::StringParamForContainer<Container>())
98 {
99  ReturnType res;
100  if (!strings.size()) {
101  return res;
102  }
103  std::size_t entries = 0, size = 0;
104  for (const auto &str : strings) {
105  if (omitEmpty && str.empty()) {
106  continue;
107  }
108  size += str.size();
109  ++entries;
110  }
111  if (!entries) {
112  return res;
113  }
114  size += (entries * leftClosure.size()) + (entries * rightClosure.size()) + ((entries - 1) * delimiter.size());
115  res.reserve(size);
116  for (const auto &str : strings) {
117  if (omitEmpty && str.empty()) {
118  continue;
119  }
120  if (!res.empty()) {
121  res.append(delimiter);
122  }
123  res.append(leftClosure);
124  res.append(str);
125  res.append(rightClosure);
126  }
127  return res;
128 }
129 
133 template <class Container = std::initializer_list<std::string>> inline auto toMultiline(const Container &arrayOfLines)
134 {
135  return joinStrings(arrayOfLines, "\n", false);
136 }
137 
141 enum class EmptyPartsTreat {
142  Keep,
143  Omit,
144  Merge
145 };
146 
156 template <class Container = std::list<std::string>>
157 Container splitString(Detail::StringParamForContainer<Container> string, Detail::StringParamForContainer<Container> delimiter,
158  EmptyPartsTreat emptyPartsRole = EmptyPartsTreat::Keep, int maxParts = -1)
159 {
160  --maxParts;
161  Container res;
162  typename Container::value_type *last = nullptr;
163  bool merge = false;
164  for (typename Container::value_type::size_type i = 0, end = string.size(), delimPos; i < end; i = delimPos + delimiter.size()) {
165  delimPos = string.find(delimiter, i);
166  if (!merge && maxParts >= 0 && res.size() == static_cast<typename Container::value_type::size_type>(maxParts)) {
167  if (delimPos == i && emptyPartsRole == EmptyPartsTreat::Merge) {
168  if (last) {
169  merge = true;
170  continue;
171  }
172  }
173  delimPos = Container::value_type::npos;
174  }
175  if (delimPos == Container::value_type::npos) {
176  delimPos = string.size();
177  }
178  if (emptyPartsRole == EmptyPartsTreat::Keep || i != delimPos) {
179  if (merge) {
180  last->append(delimiter);
181  last->append(string, i, delimPos - i);
182  merge = false;
183  } else {
184  last = &res.emplace_back(string, i, delimPos - i);
185  }
186  } else if (emptyPartsRole == EmptyPartsTreat::Merge) {
187  if (last) {
188  merge = true;
189  }
190  }
191  }
192  return res;
193 }
194 
204 template <class Container = std::list<std::string>>
206  Detail::StringParamForContainer<Container> string, Detail::StringParamForContainer<Container> delimiter, int maxParts = -1)
207 {
208  --maxParts;
209  Container res;
210  for (typename Container::value_type::size_type i = 0, end = string.size(), delimPos; i < end; i = delimPos + delimiter.size()) {
211  delimPos = string.find(delimiter, i);
212  if (maxParts >= 0 && res.size() == static_cast<typename Container::value_type::size_type>(maxParts)) {
213  delimPos = Container::value_type::npos;
214  }
215  if (delimPos == Container::value_type::npos) {
216  delimPos = string.size();
217  }
218 #if __cplusplus >= 201709
219  if constexpr (requires { res.emplace_back(string); }) {
220 #endif
221  res.emplace_back(string.data() + i, delimPos - i);
222 #if __cplusplus >= 201709
223  } else {
224  res.emplace(string.data() + i, delimPos - i);
225  }
226 #endif
227  }
228  return res;
229 }
230 
234 template <class Container = std::vector<std::string>> inline auto toArrayOfLines(const std::string &multilineString)
235 {
236  return splitString<Container>(multilineString, "\n", EmptyPartsTreat::Keep);
237 }
238 
242 template <typename StringType> bool startsWith(const StringType &str, const StringType &phrase)
243 {
244  if (str.size() < phrase.size()) {
245  return false;
246  }
247  for (auto stri = str.cbegin(), strend = str.cend(), phrasei = phrase.cbegin(), phraseend = phrase.cend();; ++stri, ++phrasei) {
248  if (phrasei == phraseend) {
249  return true;
250  } else if (stri == strend) {
251  return false;
252  } else if (*stri != *phrasei) {
253  return false;
254  }
255  }
256  return false;
257 }
258 
262 template <typename StringType> bool startsWith(const StringType &str, const typename StringType::value_type *phrase)
263 {
264  for (auto stri = str.cbegin(), strend = str.cend();; ++stri, ++phrase) {
265  if (!*phrase) {
266  return true;
267  } else if (stri == strend) {
268  return false;
269  } else if (*stri != *phrase) {
270  return false;
271  }
272  }
273  return false;
274 }
275 
279 template <typename StringType> bool endsWith(const StringType &str, const StringType &phrase)
280 {
281  if (str.size() < phrase.size()) {
282  return false;
283  }
284  for (auto stri = str.cend() - static_cast<typename StringType::difference_type>(phrase.size()), strend = str.cend(), phrasei = phrase.cbegin();
285  stri != strend; ++stri, ++phrasei) {
286  if (*stri != *phrasei) {
287  return false;
288  }
289  }
290  return true;
291 }
292 
296 template <typename StringType> bool endsWith(const StringType &str, const typename StringType::value_type *phrase)
297 {
298  const auto phraseSize = std::strlen(phrase);
299  if (str.size() < phraseSize) {
300  return false;
301  }
302  for (auto stri = str.cend() - static_cast<typename StringType::difference_type>(phraseSize), strend = str.cend(); stri != strend;
303  ++stri, ++phrase) {
304  if (*stri != *phrase) {
305  return false;
306  }
307  }
308  return true;
309 }
310 
315 template <typename StringType> bool containsSubstrings(const StringType &str, std::initializer_list<StringType> substrings)
316 {
317  typename StringType::size_type currentPos = 0;
318  for (const auto &substr : substrings) {
319  if ((currentPos = str.find(substr, currentPos)) == StringType::npos) {
320  return false;
321  }
322  currentPos += substr.size();
323  }
324  return true;
325 }
326 
331 template <typename StringType>
332 bool containsSubstrings(const StringType &str, std::initializer_list<const typename StringType::value_type *> substrings)
333 {
334  typename StringType::size_type currentPos = 0;
335  for (const auto *substr : substrings) {
336  if ((currentPos = str.find(substr, currentPos)) == StringType::npos) {
337  return false;
338  }
339  currentPos += std::strlen(substr);
340  }
341  return true;
342 }
343 
347 template <typename StringType1, typename StringType2, typename StringType3>
348 void findAndReplace(StringType1 &str, const StringType2 &find, const StringType3 &replace)
349 {
350  for (typename StringType1::size_type i = 0; (i = str.find(find, i)) != StringType1::npos; i += replace.size()) {
351  str.replace(i, find.size(), replace);
352  }
353 }
354 
358 template <typename StringType>
359 inline void findAndReplace(StringType &str, const typename StringType::value_type *find, const typename StringType::value_type *replace)
360 {
362  str, std::basic_string_view<typename StringType::value_type>(find), std::basic_string_view<typename StringType::value_type>(replace));
363 }
364 
368 template <typename StringType1, typename StringType2>
369 inline void findAndReplace(StringType1 &str, const StringType2 &find, const typename StringType1::value_type *replace)
370 {
371  findAndReplace(str, find, std::basic_string_view<typename StringType1::value_type>(replace));
372 }
373 
377 template <typename StringType1, typename StringType2>
378 inline void findAndReplace(StringType1 &str, const typename StringType1::value_type *find, const StringType2 &replace)
379 {
380  findAndReplace(str, std::basic_string_view<typename StringType1::value_type>(find), replace);
381 }
382 
389 template <typename CharType> constexpr CharType digitToChar(CharType digit)
390 {
391  return digit <= 9 ? (digit + '0') : (digit + 'A' - 10);
392 }
393 
400 template <typename IntegralType, class StringType = std::string, typename BaseType = IntegralType,
401  CppUtilities::Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
402 StringType numberToString(IntegralType number, BaseType base = 10)
403 {
404  std::size_t resSize = 0;
405  for (auto n = number; n; n /= static_cast<IntegralType>(base), ++resSize)
406  ;
407  StringType res;
408  res.reserve(resSize);
409  do {
410  res.insert(res.begin(), digitToChar<typename StringType::value_type>(static_cast<typename StringType::value_type>(number % base)));
411  number /= static_cast<IntegralType>(base);
412  } while (number);
413  return res;
414 }
415 
422 template <typename IntegralType, class StringType = std::string, typename BaseType = IntegralType,
423  Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
424 StringType numberToString(IntegralType number, BaseType base = 10)
425 {
426  const bool negative = number < 0;
427  std::size_t resSize;
428  if (negative) {
429  number = -number, resSize = 1;
430  } else {
431  resSize = 0;
432  }
433  for (auto n = number; n; n /= static_cast<IntegralType>(base), ++resSize)
434  ;
435  StringType res;
436  res.reserve(resSize);
437  do {
438  res.insert(res.begin(),
439  digitToChar<typename StringType::value_type>(static_cast<typename StringType::value_type>(number % static_cast<IntegralType>(base))));
440  number /= static_cast<IntegralType>(base);
441  } while (number);
442  if (negative) {
443  res.insert(res.begin(), '-');
444  }
445  return res;
446 }
447 
456 template <typename FloatingType, class StringType = std::string, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
457 StringType numberToString(FloatingType number, int base = 10)
458 {
459  std::basic_stringstream<typename StringType::value_type> ss;
460  ss << std::setbase(base) << number;
461  return ss.str();
462 }
463 
468 template <typename CharType> CharType charToDigit(CharType character, CharType base)
469 {
470  CharType res = base;
471  if (character >= '0' && character <= '9') {
472  res = character - '0';
473  } else if (character >= 'a' && character <= 'z') {
474  res = character - 'a' + 10;
475  } else if (character >= 'A' && character <= 'Z') {
476  res = character - 'A' + 10;
477  }
478  if (res < base) {
479  return res;
480  }
481  std::string errorMsg;
482  errorMsg.reserve(36);
483  errorMsg += "The character \"";
484  errorMsg += character >= ' ' && character <= '~' ? static_cast<std::string::value_type>(character) : '?';
485  errorMsg += "\" is no valid digit.";
486  throw ConversionException(std::move(errorMsg));
487 }
488 
496 template <typename IntegralType, class StringType, typename BaseType = IntegralType,
497  Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>, Traits::Not<std::is_scalar<std::decay_t<StringType>>>>
498  * = nullptr>
499 IntegralType stringToNumber(const StringType &string, BaseType base = 10)
500 {
501  IntegralType result = 0;
502  for (const auto &c : string) {
503  if (c == ' ') {
504  continue;
505  }
506  result *= static_cast<IntegralType>(base);
507  result += static_cast<IntegralType>(charToDigit<typename StringType::value_type>(c, static_cast<typename StringType::value_type>(base)));
508  }
509  return result;
510 }
511 
519 template <typename IntegralType, class StringType, typename BaseType = IntegralType,
520  Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>, Traits::Not<std::is_scalar<std::decay_t<StringType>>>> * = nullptr>
521 IntegralType stringToNumber(const StringType &string, IntegralType base = 10)
522 {
523  auto i = string.begin();
524  auto end = string.end();
525  for (; i != end && *i == ' '; ++i)
526  ;
527  if (i == end) {
528  return 0;
529  }
530  const bool negative = (*i == '-');
531  if (negative) {
532  ++i;
533  }
534  IntegralType result = 0;
535  for (; i != end; ++i) {
536  if (*i == ' ') {
537  continue;
538  }
539  result *= static_cast<IntegralType>(base);
540  result += static_cast<IntegralType>(charToDigit<typename StringType::value_type>(*i, static_cast<typename StringType::value_type>(base)));
541  }
542  return negative ? -result : result;
543 }
544 
554 template <typename FloatingType, class StringType,
555  Traits::EnableIf<std::is_floating_point<FloatingType>, Traits::Not<std::is_scalar<std::decay_t<StringType>>>> * = nullptr>
556 FloatingType stringToNumber(const StringType &string, int base = 10)
557 {
558  std::basic_stringstream<typename StringType::value_type> ss;
559  ss << std::setbase(base) << string;
560  FloatingType result;
561  if ((ss >> result) && ss.eof()) {
562  return result;
563  }
564  std::string errorMsg;
565  errorMsg.reserve(42 + string.size());
566  errorMsg += "The string \"";
567  errorMsg += string;
568  errorMsg += "\" is no valid floating number.";
569  throw ConversionException(errorMsg);
570 }
571 
579 template <typename IntegralType, typename CharType, typename BaseType = IntegralType,
580  Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
581 IntegralType stringToNumber(const CharType *string, BaseType base = 10)
582 {
583  IntegralType result = 0;
584  for (; *string; ++string) {
585  if (*string == ' ') {
586  continue;
587  }
588  result *= static_cast<IntegralType>(base);
589  result += static_cast<IntegralType>(charToDigit<CharType>(*string, static_cast<CharType>(base)));
590  }
591  return result;
592 }
593 
603 template <typename FloatingType, class CharType, Traits::EnableIf<std::is_floating_point<FloatingType>> * = nullptr>
604 FloatingType stringToNumber(const CharType *string, int base = 10)
605 {
606  std::basic_stringstream<CharType> ss;
607  ss << std::setbase(base) << string;
608  FloatingType result;
609  if ((ss >> result) && ss.eof()) {
610  return result;
611  }
612  std::string errorMsg;
613  errorMsg.reserve(42 + std::char_traits<CharType>::length(string));
614  errorMsg += "The string \"";
615  errorMsg += string;
616  errorMsg += "\" is no valid floating number.";
617  throw ConversionException(errorMsg);
618 }
619 
627 template <typename IntegralType, class CharType, typename BaseType = IntegralType,
628  Traits::EnableIf<std::is_integral<IntegralType>, std::is_unsigned<IntegralType>> * = nullptr>
629 IntegralType bufferToNumber(const CharType *string, std::size_t size, BaseType base = 10)
630 {
631  IntegralType result = 0;
632  for (const CharType *end = string + size; string != end; ++string) {
633  if (*string == ' ') {
634  continue;
635  }
636  result *= static_cast<IntegralType>(base);
637  result += static_cast<IntegralType>(charToDigit<CharType>(*string, static_cast<CharType>(base)));
638  }
639  return result;
640 }
641 
649 template <typename IntegralType, typename CharType, typename BaseType = IntegralType,
650  Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
651 IntegralType stringToNumber(const CharType *string, IntegralType base = 10)
652 {
653  if (!*string) {
654  return 0;
655  }
656  for (; *string && *string == ' '; ++string)
657  ;
658  if (!*string) {
659  return 0;
660  }
661  const bool negative = (*string == '-');
662  if (negative) {
663  ++string;
664  }
665  IntegralType result = 0;
666  for (; *string; ++string) {
667  if (*string == ' ') {
668  continue;
669  }
670  result *= static_cast<IntegralType>(base);
671  result += static_cast<IntegralType>(charToDigit<CharType>(*string, static_cast<CharType>(base)));
672  }
673  return negative ? -result : result;
674 }
675 
683 template <typename IntegralType, typename CharType, typename BaseType = IntegralType,
684  Traits::EnableIf<std::is_integral<IntegralType>, std::is_signed<IntegralType>> * = nullptr>
685 IntegralType bufferToNumber(const CharType *string, std::size_t size, BaseType base = 10)
686 {
687  if (!size) {
688  return 0;
689  }
690  const CharType *end = string + size;
691  for (; string != end && *string == ' '; ++string)
692  ;
693  if (string == end) {
694  return 0;
695  }
696  const bool negative = (*string == '-');
697  if (negative) {
698  ++string;
699  }
700  IntegralType result = 0;
701  for (; string != end; ++string) {
702  if (*string == ' ') {
703  continue;
704  }
705  result *= static_cast<IntegralType>(base);
706  result += static_cast<IntegralType>(charToDigit<CharType>(*string, static_cast<CharType>(base)));
707  }
708  return negative ? -result : result;
709 }
710 
720 template <typename T> std::string interpretIntegerAsString(T integer, int startOffset = 0)
721 {
722  char buffer[sizeof(T)];
723  BE::getBytes(integer, buffer);
724  return std::string(buffer + startOffset, sizeof(T) - static_cast<std::size_t>(startOffset));
725 }
726 
727 CPP_UTILITIES_EXPORT std::string dataSizeToString(std::uint64_t sizeInByte, bool includeByte = false);
728 CPP_UTILITIES_EXPORT std::string bitrateToString(double speedInKbitsPerSecond, bool useByteInsteadOfBits = false);
729 CPP_UTILITIES_EXPORT std::string encodeBase64(const std::uint8_t *data, std::uint32_t dataSize);
730 CPP_UTILITIES_EXPORT std::pair<std::unique_ptr<std::uint8_t[]>, std::uint32_t> decodeBase64(const char *encodedStr, const std::uint32_t strSize);
731 } // namespace CppUtilities
732 
733 #endif // CONVERSION_UTILITIES_STRINGCONVERSION_H
The ConversionException class is thrown by the various conversion functions of this library when a co...
#define CPP_UTILITIES_EXPORT
Marks the symbol to be exported by the c++utilities library.
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
Contains all utilities provides by the c++utilities library.
void findAndReplace(StringType1 &str, const StringType2 &find, const StringType3 &replace)
Replaces all occurences of find with relpace in the specified str.
CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16BE(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-8 string to UTF-16 (big-endian).
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.
StringType numberToString(IntegralType number, BaseType base=10)
Converts the given number to its equivalent string representation using the specified base.
CPP_UTILITIES_EXPORT StringData convertLatin1ToUtf8(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified Latin-1 string to UTF-8.
CPP_UTILITIES_EXPORT StringData convertUtf16LEToUtf8(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-16 (little-endian) string to UTF-8.
EmptyPartsTreat
Specifies the role of empty parts when splitting strings.
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.
ReturnType joinStrings(const Container &strings, Detail::StringParamForContainer< Container > delimiter=Detail::StringParamForContainer< Container >(), bool omitEmpty=false, Detail::StringParamForContainer< Container > leftClosure=Detail::StringParamForContainer< Container >(), Detail::StringParamForContainer< Container > rightClosure=Detail::StringParamForContainer< Container >())
Joins the given strings using the specified delimiter.
bool startsWith(const StringType &str, const StringType &phrase)
Returns whether str starts with phrase.
IntegralType stringToNumber(const StringType &string, BaseType base=10)
Converts the given string to an unsigned number assuming string uses the specified base.
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...
std::pair< std::unique_ptr< char[], StringDataDeleter >, std::size_t > StringData
Type used to return string encoding conversion result.
CPP_UTILITIES_EXPORT StringData convertUtf16BEToUtf8(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-16 (big-endian) string to UTF-8.
constexpr CharType digitToChar(CharType digit)
Returns the character representation of the specified digit.
Container splitStringSimple(Detail::StringParamForContainer< Container > string, Detail::StringParamForContainer< Container > delimiter, int maxParts=-1)
Splits the given string (which might also be a string view) at the specified delimiter.
auto toArrayOfLines(const std::string &multilineString)
Converts the specified multilineString to an array of lines.
bool containsSubstrings(const StringType &str, std::initializer_list< StringType > substrings)
Returns whether str contains the specified substrings.
CPP_UTILITIES_EXPORT StringData convertUtf8ToLatin1(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-8 string to Latin-1.
std::string interpretIntegerAsString(T integer, int startOffset=0)
Interprets the given integer at the specified position as std::string using the specified byte order.
bool endsWith(const StringType &str, const StringType &phrase)
Returns whether str ends with phrase.
auto toMultiline(const Container &arrayOfLines)
Converts the specified arrayOfLines to a multiline string.
CPP_UTILITIES_EXPORT StringData convertUtf8ToUtf16LE(const char *inputBuffer, std::size_t inputBufferSize)
Converts the specified UTF-8 string to UTF-16 (little-endian).
CPP_UTILITIES_EXPORT std::string bitrateToString(double speedInKbitsPerSecond, bool useByteInsteadOfBits=false)
Converts the specified bitrate in kbit/s to its equivalent std::string representation.
CharType charToDigit(CharType character, CharType base)
Returns number/digit of the specified character representation using the specified base.
CPP_UTILITIES_EXPORT std::string encodeBase64(const std::uint8_t *data, std::uint32_t dataSize)
Encodes the specified data to Base64.
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.
IntegralType bufferToNumber(const CharType *string, std::size_t size, BaseType base=10)
Converts the given string of size characters to an unsigned numeric value using the specified base.
Container splitString(Detail::StringParamForContainer< Container > string, Detail::StringParamForContainer< Container > delimiter, EmptyPartsTreat emptyPartsRole=EmptyPartsTreat::Keep, int maxParts=-1)
Splits the given string at the specified delimiter.
The StringDataDeleter struct deletes the data of a StringData instance.
void operator()(char *stringData)
Deletes the specified stringData with std::free(), because the memory has been allocated using std::m...
constexpr int i