Kodi Documentation 22.0
Kodi is an open source media player and entertainment hub.
Loading...
Searching...
No Matches
Static Public Member Functions | Static Public Attributes | List of all members
KODI::UTILS::StringUtils Class Reference

#include <StringUtils.h>

Static Public Member Functions

template<typename... Args>
static constexpr std::string Format (std::string_view format, Args &&... args)
 Get a formatted string similar to sprintf.
 
template<typename... Args>
static constexpr std::wstring Format (std::wstring_view format, Args &&... args)
 
static std::string FormatV (PRINTF_FORMAT_STRING const char *fmt, va_list args)
 
static std::wstring FormatV (PRINTF_FORMAT_STRING const wchar_t *fmt, va_list args)
 
static std::string ToUpper (const std::string &str)
 
static std::wstring ToUpper (const std::wstring &str)
 
static void ToUpper (std::string &str)
 
static void ToUpper (std::wstring &str)
 
static std::string ToLower (const std::string &str)
 
static std::wstring ToLower (const std::wstring &str)
 
static void ToLower (std::string &str)
 
static void ToLower (std::wstring &str)
 
static void ToCapitalize (std::string &str)
 
static void ToCapitalize (std::wstring &str)
 
static bool EqualsNoCase (const std::string &str1, const std::string &str2)
 
static bool EqualsNoCase (const std::string &str1, const char *s2)
 
static bool EqualsNoCase (const char *s1, const char *s2)
 
static int CompareNoCase (const std::string &str1, const std::string &str2, size_t n=0)
 
static int CompareNoCase (const char *s1, const char *s2, size_t n=0)
 
static int ReturnDigits (const std::string &str)
 
static std::string Left (const std::string &str, size_t count)
 
static std::string Mid (const std::string &str, size_t first, size_t count=std::string::npos)
 
static std::string Right (const std::string &str, size_t count)
 
static std::string & Trim (std::string &str)
 
static std::string & Trim (std::string &str, const char *const chars)
 
static std::string & TrimLeft (std::string &str)
 
static std::string & TrimLeft (std::string &str, const char *const chars)
 
static std::string & TrimRight (std::string &str)
 
static std::string & TrimRight (std::string &str, const char *const chars)
 
static std::string & RemoveDuplicatedSpacesAndTabs (std::string &str)
 
static bool IsSpecialCharacter (char c)
 Check if the character is a special character.
 
static std::string ReplaceSpecialCharactersWithSpace (const std::string &str)
 
static int Replace (std::string &str, char oldChar, char newChar)
 
static int Replace (std::string &str, const std::string &oldStr, const std::string &newStr)
 
static int Replace (std::wstring &str, const std::wstring &oldStr, const std::wstring &newStr)
 
static bool StartsWith (const std::string &str1, const std::string &str2)
 
static bool StartsWith (const std::string &str1, const char *s2)
 
static bool StartsWith (const char *s1, const char *s2)
 
static bool StartsWithNoCase (const std::string &str1, const std::string &str2)
 
static bool StartsWithNoCase (const std::string &str1, const char *s2)
 
static bool StartsWithNoCase (const char *s1, const char *s2)
 
static bool EndsWith (const std::string &str1, const std::string &str2)
 
static bool EndsWith (const std::string &str1, const char *s2)
 
static bool EndsWithNoCase (const std::string &str1, const std::string &str2)
 
static bool EndsWithNoCase (const std::string &str1, const char *s2)
 
template<typename CONTAINER>
static std::string Join (const CONTAINER &strings, const std::string &delimiter)
 
static std::vector< std::string > Split (const std::string &input, const std::string &delimiter, unsigned int iMaxStrings=0)
 Splits the given input string using the given delimiter into separate strings.
 
static std::vector< std::string > Split (const std::string &input, const char delimiter, size_t iMaxStrings=0)
 
static std::vector< std::string > Split (const std::string &input, const std::vector< std::string > &delimiters)
 
template<typename OutputIt>
static OutputIt SplitTo (OutputIt d_first, const std::string &input, const std::string &delimiter, unsigned int iMaxStrings=0)
 Splits the given input string using the given delimiter into separate strings.
 
template<typename OutputIt>
static OutputIt SplitTo (OutputIt d_first, const std::string &input, const char delimiter, size_t iMaxStrings=0)
 
template<typename OutputIt>
static OutputIt SplitTo (OutputIt d_first, const std::string &input, const std::vector< std::string > &delimiters)
 
static std::vector< std::string > SplitMulti (const std::vector< std::string > &input, const std::vector< std::string > &delimiters, size_t iMaxStrings=0)
 Splits the given input strings using the given delimiters into further separate strings.
 
static int FindNumber (const std::string &strInput, const std::string &strFind)
 
static int64_t AlphaNumericCompare (const wchar_t *left, const wchar_t *right)
 
static int AlphaNumericCollation (int nKey1, const void *pKey1, int nKey2, const void *pKey2)
 
static long TimeStringToSeconds (const std::string &timeString)
 
static void RemoveCRLF (std::string &strLine)
 
static size_t utf8_strlen (const char *s)
 utf8 version of strlen - skips any non-starting bytes in the count, thus returning the number of utf8 characters
 
static std::string SecondsToTimeString (long seconds, TIME_FORMAT format=TIME_FORMAT_GUESS)
 convert a time in seconds to a string based on the given time format
 
static std::string MillisecondsToTimeString (std::chrono::milliseconds milliSeconds)
 convert a milliseconds value to a time string in the TIME_FORMAT_HH_MM_SS format
 
static bool IsNaturalNumber (const std::string &str)
 check whether a string is a natural number. Matches [ \t]*[0-9]+[ \t]*
 
static bool IsInteger (const std::string &str)
 check whether a string is an integer. Matches [ \t]*[-]*[0-9]+[ \t]*
 
static bool isasciidigit (char chr)
 
static bool isasciixdigit (char chr)
 
static int asciidigitvalue (char chr)
 
static int asciixdigitvalue (char chr)
 
static bool isasciiuppercaseletter (char chr)
 
static bool isasciilowercaseletter (char chr)
 
static bool isasciialphanum (char chr)
 
static std::string SizeToString (int64_t size)
 
static size_t FindWords (const char *str, const char *wordLowerCase)
 
static int FindEndBracket (const std::string &str, char opener, char closer, int startPos=0)
 
static int DateStringToYYYYMMDD (const std::string &dateString)
 
static std::string ISODateToLocalizedDate (const std::string &strIsoDate)
 
static void WordToDigits (std::string &word)
 
static std::string CreateUUID ()
 
static bool ValidateUUID (const std::string &uuid)
 
static double CompareFuzzy (const std::string &left, const std::string &right)
 
static int FindBestMatch (const std::string &str, const std::vector< std::string > &strings, double &matchscore)
 
static bool ContainsKeyword (const std::string &str, const std::vector< std::string > &keywords)
 
static std::string BinaryStringToString (const std::string &in)
 Convert the string of binary chars to the actual string.
 
static std::string ToHexadecimal (const std::string &in)
 
template<typename T>
static std::string FormatNumber (T num)
 Format the string with locale separators.
 
static std::string Paramify (const std::string &param)
 Escapes the given string to be able to be used as a parameter.
 
static std::string DeParamify (const std::string &param)
 Unescapes the given string.
 
static std::vector< std::string > Tokenize (const std::string &input, const std::string &delimiters)
 Split a string by the specified delimiters. Splits a string using one or more delimiting characters, ignoring empty tokens. Differs from Split() in two ways:
 
static void Tokenize (const std::string &input, std::vector< std::string > &tokens, const std::string &delimiters)
 
static std::vector< std::string > Tokenize (const std::string &input, const char delimiter)
 
static void Tokenize (const std::string &input, std::vector< std::string > &tokens, const char delimiter)
 
static uint32_t ToUint32 (std::string_view str, uint32_t fallback=0) noexcept
 Converts a string to a unsigned int number.
 
static uint64_t ToUint64 (std::string_view str, uint64_t fallback=0) noexcept
 Converts a string to a unsigned long long number.
 
static float ToFloat (std::string_view str, float fallback=0.0f) noexcept
 Converts a string to a float number.
 
static std::string FormatFileSize (uint64_t bytes)
 
static std::string CreateFromCString (const char *cstr)
 Converts a cstring pointer (const char*) to a std::string. In case nullptr is passed the result is an empty string.
 
static bool Contains (std::string_view str, std::string_view keyword, bool isCaseInsensitive=true)
 Check if a keyword string is contained on another string.
 

Static Public Attributes

static const std::string Empty = ""
 

Member Function Documentation

◆ AlphaNumericCollation()

int KODI::UTILS::StringUtils::AlphaNumericCollation ( int nKey1,
const void * pKey1,
int nKey2,
const void * pKey2 )
static

◆ AlphaNumericCompare()

int64_t KODI::UTILS::StringUtils::AlphaNumericCompare ( const wchar_t * left,
const wchar_t * right )
static

◆ asciidigitvalue()

int KODI::UTILS::StringUtils::asciidigitvalue ( char chr)
static

◆ asciixdigitvalue()

int KODI::UTILS::StringUtils::asciixdigitvalue ( char chr)
static

◆ BinaryStringToString()

std::string KODI::UTILS::StringUtils::BinaryStringToString ( const std::string & in)
static

Convert the string of binary chars to the actual string.

Convert the string representation of binary chars to the actual string. For example \1\2\3 is converted to a string with binary char \1, \2 and \3

Parameters
paramString to convert
Returns
Converted string

◆ CompareFuzzy()

double KODI::UTILS::StringUtils::CompareFuzzy ( const std::string & left,
const std::string & right )
static

◆ CompareNoCase() [1/2]

int KODI::UTILS::StringUtils::CompareNoCase ( const char * s1,
const char * s2,
size_t n = 0 )
static

◆ CompareNoCase() [2/2]

int KODI::UTILS::StringUtils::CompareNoCase ( const std::string & str1,
const std::string & str2,
size_t n = 0 )
static

◆ Contains()

bool KODI::UTILS::StringUtils::Contains ( std::string_view str,
std::string_view keyword,
bool isCaseInsensitive = true )
static

Check if a keyword string is contained on another string.

Parameters
strThe string in which to search for the keyword
keywordThe string to search for
Returns
True if the keyword if found.

◆ ContainsKeyword()

bool KODI::UTILS::StringUtils::ContainsKeyword ( const std::string & str,
const std::vector< std::string > & keywords )
static

◆ CreateFromCString()

std::string KODI::UTILS::StringUtils::CreateFromCString ( const char * cstr)
static

Converts a cstring pointer (const char*) to a std::string. In case nullptr is passed the result is an empty string.

Parameters
cstrthe const pointer to char
Returns
the resulting std::string or ""

◆ CreateUUID()

std::string KODI::UTILS::StringUtils::CreateUUID ( )
static

◆ DateStringToYYYYMMDD()

int KODI::UTILS::StringUtils::DateStringToYYYYMMDD ( const std::string & dateString)
static

◆ DeParamify()

std::string KODI::UTILS::StringUtils::DeParamify ( const std::string & param)
static

Unescapes the given string.

Unescapes backslashes and double-quotes and removes double-quotes around the whole string.

Parameters
paramString to unescape/deparamify
Returns
Unescaped/Deparamified string

◆ EndsWith() [1/2]

bool KODI::UTILS::StringUtils::EndsWith ( const std::string & str1,
const char * s2 )
static

◆ EndsWith() [2/2]

bool KODI::UTILS::StringUtils::EndsWith ( const std::string & str1,
const std::string & str2 )
static

◆ EndsWithNoCase() [1/2]

bool KODI::UTILS::StringUtils::EndsWithNoCase ( const std::string & str1,
const char * s2 )
static

◆ EndsWithNoCase() [2/2]

bool KODI::UTILS::StringUtils::EndsWithNoCase ( const std::string & str1,
const std::string & str2 )
static

◆ EqualsNoCase() [1/3]

bool KODI::UTILS::StringUtils::EqualsNoCase ( const char * s1,
const char * s2 )
static

◆ EqualsNoCase() [2/3]

bool KODI::UTILS::StringUtils::EqualsNoCase ( const std::string & str1,
const char * s2 )
static

◆ EqualsNoCase() [3/3]

bool KODI::UTILS::StringUtils::EqualsNoCase ( const std::string & str1,
const std::string & str2 )
static

◆ FindBestMatch()

int KODI::UTILS::StringUtils::FindBestMatch ( const std::string & str,
const std::vector< std::string > & strings,
double & matchscore )
static

◆ FindEndBracket()

int KODI::UTILS::StringUtils::FindEndBracket ( const std::string & str,
char opener,
char closer,
int startPos = 0 )
static

◆ FindNumber()

int KODI::UTILS::StringUtils::FindNumber ( const std::string & strInput,
const std::string & strFind )
static

◆ FindWords()

size_t KODI::UTILS::StringUtils::FindWords ( const char * str,
const char * wordLowerCase )
static

◆ Format() [1/2]

template<typename... Args>
static constexpr std::string KODI::UTILS::StringUtils::Format ( std::string_view format,
Args &&... args )
inlinestaticconstexpr

Get a formatted string similar to sprintf.

Parameters
fmtFormat of the resulting string
...variable number of value type arguments
Returns
Formatted string

◆ Format() [2/2]

template<typename... Args>
static constexpr std::wstring KODI::UTILS::StringUtils::Format ( std::wstring_view format,
Args &&... args )
inlinestaticconstexpr

◆ FormatFileSize()

std::string KODI::UTILS::StringUtils::FormatFileSize ( uint64_t bytes)
static

Returns bytes in a human readable format using the smallest unit that will fit bytes in at most three digits. The number of decimals are adjusted with significance such that 'small' numbers will have more decimals than larger ones.

For example: 1024 bytes will be formatted as "1.00kB", 10240 bytes as "10.0kB" and 102400 bytes as "100kB". See TestStringUtils for more examples.

◆ FormatNumber()

template<typename T>
static std::string KODI::UTILS::StringUtils::FormatNumber ( T num)
inlinestatic

Format the string with locale separators.

Format the string with locale separators. For example 10000.57 in en-us is '10,000.57' but in italian is '10.000,57'

Parameters
paramString to format
Returns
Formatted string

◆ FormatV() [1/2]

static std::string KODI::UTILS::StringUtils::FormatV ( PRINTF_FORMAT_STRING const char * fmt,
va_list args )
static

◆ FormatV() [2/2]

static std::wstring KODI::UTILS::StringUtils::FormatV ( PRINTF_FORMAT_STRING const wchar_t * fmt,
va_list args )
static

◆ isasciialphanum()

static bool KODI::UTILS::StringUtils::isasciialphanum ( char chr)
inlinestatic

◆ isasciidigit()

static bool KODI::UTILS::StringUtils::isasciidigit ( char chr)
inlinestatic

◆ isasciilowercaseletter()

static bool KODI::UTILS::StringUtils::isasciilowercaseletter ( char chr)
inlinestatic

◆ isasciiuppercaseletter()

static bool KODI::UTILS::StringUtils::isasciiuppercaseletter ( char chr)
inlinestatic

◆ isasciixdigit()

static bool KODI::UTILS::StringUtils::isasciixdigit ( char chr)
inlinestatic

◆ IsInteger()

bool KODI::UTILS::StringUtils::IsInteger ( const std::string & str)
static

check whether a string is an integer. Matches [ \t]*[-]*[0-9]+[ \t]*

Parameters
strthe string to check
Returns
true if the string is an integer, false otherwise.

◆ IsNaturalNumber()

bool KODI::UTILS::StringUtils::IsNaturalNumber ( const std::string & str)
static

check whether a string is a natural number. Matches [ \t]*[0-9]+[ \t]*

Parameters
strthe string to check
Returns
true if the string is a natural number, false otherwise.

◆ ISODateToLocalizedDate()

std::string KODI::UTILS::StringUtils::ISODateToLocalizedDate ( const std::string & strIsoDate)
static

◆ IsSpecialCharacter()

bool KODI::UTILS::StringUtils::IsSpecialCharacter ( char c)
static

Check if the character is a special character.

A special character is not an alphanumeric character, and is not useful to provide information

Parameters
cInput character to be checked

◆ Join()

template<typename CONTAINER>
static std::string KODI::UTILS::StringUtils::Join ( const CONTAINER & strings,
const std::string & delimiter )
inlinestatic

◆ Left()

std::string KODI::UTILS::StringUtils::Left ( const std::string & str,
size_t count )
static

◆ Mid()

std::string KODI::UTILS::StringUtils::Mid ( const std::string & str,
size_t first,
size_t count = std::string::npos )
static

◆ MillisecondsToTimeString()

std::string KODI::UTILS::StringUtils::MillisecondsToTimeString ( std::chrono::milliseconds milliSeconds)
static

convert a milliseconds value to a time string in the TIME_FORMAT_HH_MM_SS format

Parameters
milliSecondstime in milliseconds
Returns
the formatted time
See also
TIME_FORMAT

◆ Paramify()

std::string KODI::UTILS::StringUtils::Paramify ( const std::string & param)
static

Escapes the given string to be able to be used as a parameter.

Escapes backslashes and double-quotes with an additional backslash and adds double-quotes around the whole string.

Parameters
paramString to escape/paramify
Returns
Escaped/Paramified string

◆ RemoveCRLF()

void KODI::UTILS::StringUtils::RemoveCRLF ( std::string & strLine)
static

◆ RemoveDuplicatedSpacesAndTabs()

std::string & KODI::UTILS::StringUtils::RemoveDuplicatedSpacesAndTabs ( std::string & str)
static

◆ Replace() [1/3]

int KODI::UTILS::StringUtils::Replace ( std::string & str,
char oldChar,
char newChar )
static

◆ Replace() [2/3]

int KODI::UTILS::StringUtils::Replace ( std::string & str,
const std::string & oldStr,
const std::string & newStr )
static

◆ Replace() [3/3]

int KODI::UTILS::StringUtils::Replace ( std::wstring & str,
const std::wstring & oldStr,
const std::wstring & newStr )
static

◆ ReplaceSpecialCharactersWithSpace()

std::string KODI::UTILS::StringUtils::ReplaceSpecialCharactersWithSpace ( const std::string & str)
static

◆ ReturnDigits()

int KODI::UTILS::StringUtils::ReturnDigits ( const std::string & str)
static

◆ Right()

std::string KODI::UTILS::StringUtils::Right ( const std::string & str,
size_t count )
static

◆ SecondsToTimeString()

std::string KODI::UTILS::StringUtils::SecondsToTimeString ( long seconds,
TIME_FORMAT format = TIME_FORMAT_GUESS )
static

convert a time in seconds to a string based on the given time format

Parameters
secondstime in seconds
formatthe format we want the time in.
Returns
the formatted time
See also
TIME_FORMAT

◆ SizeToString()

std::string KODI::UTILS::StringUtils::SizeToString ( int64_t size)
static

◆ Split() [1/3]

std::vector< std::string > KODI::UTILS::StringUtils::Split ( const std::string & input,
const char delimiter,
size_t iMaxStrings = 0 )
static

◆ Split() [2/3]

std::vector< std::string > KODI::UTILS::StringUtils::Split ( const std::string & input,
const std::string & delimiter,
unsigned int iMaxStrings = 0 )
static

Splits the given input string using the given delimiter into separate strings.

If the given input string is empty the result will be an empty array (not an array containing an empty string).

Parameters
inputInput string to be split
delimiterDelimiter to be used to split the input string
iMaxStrings(optional) Maximum number of split strings

◆ Split() [3/3]

std::vector< std::string > KODI::UTILS::StringUtils::Split ( const std::string & input,
const std::vector< std::string > & delimiters )
static

◆ SplitMulti()

std::vector< std::string > KODI::UTILS::StringUtils::SplitMulti ( const std::vector< std::string > & input,
const std::vector< std::string > & delimiters,
size_t iMaxStrings = 0 )
static

Splits the given input strings using the given delimiters into further separate strings.

If the given input string vector is empty the result will be an empty array (not an array containing an empty string).

Delimiter strings are applied in order, so once the (optional) maximum number of items is produced no other delimiters are applied. This produces different results to applying all delimiters at once e.g. "a/b#c/d" becomes "a", "b#c", "d" rather than "a", "b", "c/d"

Parameters
inputInput vector of strings each to be split
delimitersDelimiter strings to be used to split the input strings
iMaxStrings(optional) Maximum number of resulting split strings

◆ SplitTo() [1/3]

template<typename OutputIt>
static OutputIt KODI::UTILS::StringUtils::SplitTo ( OutputIt d_first,
const std::string & input,
const char delimiter,
size_t iMaxStrings = 0 )
inlinestatic

◆ SplitTo() [2/3]

template<typename OutputIt>
static OutputIt KODI::UTILS::StringUtils::SplitTo ( OutputIt d_first,
const std::string & input,
const std::string & delimiter,
unsigned int iMaxStrings = 0 )
inlinestatic

Splits the given input string using the given delimiter into separate strings.

If the given input string is empty nothing will be put into the target iterator.

Parameters
d_firstthe beginning of the destination range
inputInput string to be split
delimiterDelimiter to be used to split the input string
iMaxStrings(optional) Maximum number of split strings
Returns
output iterator to the element in the destination range, one past the last element that was put there

◆ SplitTo() [3/3]

template<typename OutputIt>
static OutputIt KODI::UTILS::StringUtils::SplitTo ( OutputIt d_first,
const std::string & input,
const std::vector< std::string > & delimiters )
inlinestatic

◆ StartsWith() [1/3]

bool KODI::UTILS::StringUtils::StartsWith ( const char * s1,
const char * s2 )
static

◆ StartsWith() [2/3]

bool KODI::UTILS::StringUtils::StartsWith ( const std::string & str1,
const char * s2 )
static

◆ StartsWith() [3/3]

bool KODI::UTILS::StringUtils::StartsWith ( const std::string & str1,
const std::string & str2 )
static

◆ StartsWithNoCase() [1/3]

bool KODI::UTILS::StringUtils::StartsWithNoCase ( const char * s1,
const char * s2 )
static

◆ StartsWithNoCase() [2/3]

bool KODI::UTILS::StringUtils::StartsWithNoCase ( const std::string & str1,
const char * s2 )
static

◆ StartsWithNoCase() [3/3]

bool KODI::UTILS::StringUtils::StartsWithNoCase ( const std::string & str1,
const std::string & str2 )
static

◆ TimeStringToSeconds()

long KODI::UTILS::StringUtils::TimeStringToSeconds ( const std::string & timeString)
static

◆ ToCapitalize() [1/2]

void KODI::UTILS::StringUtils::ToCapitalize ( std::string & str)
static

◆ ToCapitalize() [2/2]

void KODI::UTILS::StringUtils::ToCapitalize ( std::wstring & str)
static

◆ ToFloat()

float KODI::UTILS::StringUtils::ToFloat ( std::string_view str,
float fallback = 0.0f )
staticnoexcept

Converts a string to a float number.

Parameters
strThe string to convert
fallback[OPT] The number to return when the conversion fails
Returns
The converted number, otherwise fallback if conversion fails

◆ ToHexadecimal()

std::string KODI::UTILS::StringUtils::ToHexadecimal ( const std::string & in)
static

Convert each character in the string to its hexadecimal representation and return the concatenated result

example: "abc\n" -> "6162630a"

◆ Tokenize() [1/4]

std::vector< std::string > KODI::UTILS::StringUtils::Tokenize ( const std::string & input,
const char delimiter )
static

◆ Tokenize() [2/4]

std::vector< std::string > KODI::UTILS::StringUtils::Tokenize ( const std::string & input,
const std::string & delimiters )
static

Split a string by the specified delimiters. Splits a string using one or more delimiting characters, ignoring empty tokens. Differs from Split() in two ways:

  1. The delimiters are treated as individual characters, rather than a single delimiting string.
  2. Empty tokens are ignored.
    Returns
    a vector of tokens

◆ Tokenize() [3/4]

void KODI::UTILS::StringUtils::Tokenize ( const std::string & input,
std::vector< std::string > & tokens,
const char delimiter )
static

◆ Tokenize() [4/4]

void KODI::UTILS::StringUtils::Tokenize ( const std::string & input,
std::vector< std::string > & tokens,
const std::string & delimiters )
static

◆ ToLower() [1/4]

std::string KODI::UTILS::StringUtils::ToLower ( const std::string & str)
static

◆ ToLower() [2/4]

std::wstring KODI::UTILS::StringUtils::ToLower ( const std::wstring & str)
static

◆ ToLower() [3/4]

void KODI::UTILS::StringUtils::ToLower ( std::string & str)
static

◆ ToLower() [4/4]

void KODI::UTILS::StringUtils::ToLower ( std::wstring & str)
static

◆ ToUint32()

uint32_t KODI::UTILS::StringUtils::ToUint32 ( std::string_view str,
uint32_t fallback = 0 )
staticnoexcept

Converts a string to a unsigned int number.

Parameters
strThe string to convert
fallback[OPT] The number to return when the conversion fails
Returns
The converted number, otherwise fallback if conversion fails

◆ ToUint64()

uint64_t KODI::UTILS::StringUtils::ToUint64 ( std::string_view str,
uint64_t fallback = 0 )
staticnoexcept

Converts a string to a unsigned long long number.

Parameters
strThe string to convert
fallback[OPT] The number to return when the conversion fails
Returns
The converted number, otherwise fallback if conversion fails

◆ ToUpper() [1/4]

std::string KODI::UTILS::StringUtils::ToUpper ( const std::string & str)
static

◆ ToUpper() [2/4]

std::wstring KODI::UTILS::StringUtils::ToUpper ( const std::wstring & str)
static

◆ ToUpper() [3/4]

void KODI::UTILS::StringUtils::ToUpper ( std::string & str)
static

◆ ToUpper() [4/4]

void KODI::UTILS::StringUtils::ToUpper ( std::wstring & str)
static

◆ Trim() [1/2]

std::string & KODI::UTILS::StringUtils::Trim ( std::string & str)
static

◆ Trim() [2/2]

std::string & KODI::UTILS::StringUtils::Trim ( std::string & str,
const char *const chars )
static

◆ TrimLeft() [1/2]

std::string & KODI::UTILS::StringUtils::TrimLeft ( std::string & str)
static

◆ TrimLeft() [2/2]

std::string & KODI::UTILS::StringUtils::TrimLeft ( std::string & str,
const char *const chars )
static

◆ TrimRight() [1/2]

std::string & KODI::UTILS::StringUtils::TrimRight ( std::string & str)
static

◆ TrimRight() [2/2]

std::string & KODI::UTILS::StringUtils::TrimRight ( std::string & str,
const char *const chars )
static

◆ utf8_strlen()

size_t KODI::UTILS::StringUtils::utf8_strlen ( const char * s)
static

utf8 version of strlen - skips any non-starting bytes in the count, thus returning the number of utf8 characters

Parameters
sc-string to find the length of.
Returns
the number of utf8 characters in the string.

◆ ValidateUUID()

bool KODI::UTILS::StringUtils::ValidateUUID ( const std::string & uuid)
static

◆ WordToDigits()

void KODI::UTILS::StringUtils::WordToDigits ( std::string & word)
static

Member Data Documentation

◆ Empty

const std::string KODI::UTILS::StringUtils::Empty = ""
static
The documentation for this class was generated from the following files: