util

Miscellaneous string, parsing, and version utilities.

Classes

Name	Description
`Version`	Semantic version number with major, minor, and patch fields.

Functions

Return	Name	Description
`std::string`	`format`	Printf-style string formatting for POD types.
`void`	`toUnderscore`	Replaces all non-alphanumeric characters in str with underscores and converts to lowercase.
`bool`	`isNumber`	Returns true if str consists entirely of digit characters.
`bool`	`endsWith`	Returns true if str ends with the given suffix.
`void`	`removeSpecialCharacters`	Replaces non-alphanumeric characters. Removes all non-alphanumeric characters from str in place.
`void`	`replaceSpecialCharacters`	Replaces all non-alphanumeric characters in str with `with` in place.
`bool`	`tryParseHex`	Attempts to parse a hex string into an unsigned integer.
`unsigned`	`parseHex`	Parses a hex string into an unsigned integer.
`std::string`	`dumpbin`	Formats the binary contents of data as a hex+ASCII dump string.
`bool`	`compareVersion`	Compares two dot-separated version strings.
`bool`	`matchNodes`	Checks whether node matches xnode by splitting both on delim and comparing element-wise.
`bool`	`matchNodes`	Checks whether params matches xparams element-wise.
`std::string`	`memAddress`	Returns the memory address of ptr as a hex string (e.g. "0x7f3a2b10c0").
`std::string`	`itostr`	Converts an integer (or any stream-insertable type) to its string representation.
`T`	`strtoi`	Parses a string into integer type T using std::istringstream. Returns 0 if parsing fails. Ensure T has sufficient range for the value.
`uint32_t`	`randomNumber`	Generates a 31-bit pseudo random number using the internal Random instance.
`std::string`	`randomString`	Generates a random alphanumeric string of the given length.
`std::string`	`randomBinaryString`	Generates a random binary string of the given byte length.
`void`	`split`	Splits str on the delimiter string and appends tokens to elems.
`std::vector< std::string >`	`split`	Splits str on the delimiter string and returns the tokens as a vector.
`void`	`split`	Splits str on the delimiter character and appends tokens to elems.
`std::vector< std::string >`	`split`	Splits str on the delimiter character and returns the tokens as a vector.
`S &`	`replaceInPlace`	Replace all occurrences of `from` in `str` with `to`, starting at position `start`. Modifies and returns `str` in place. `from` must not be empty.
`S &`	`replaceInPlace`	Replace all occurrences of `from` in `str` with `to`, starting at position `start`. C-string overload. Modifies and returns `str` in place.
`S`	`replace`	Replace all occurences of from (which must not be the empty string) in str with to, starting at position start.
`S`	`replace`	Returns a copy of str with all occurrences of from replaced by to (C-string overload).
`S`	`trimLeft`	Returns a copy of str with all leading whitespace removed.
`S &`	`trimLeftInPlace`	Removes all leading whitespace in str.
`S`	`trimRight`	Returns a copy of str with all trailing whitespace removed.
`S &`	`trimRightInPlace`	Removes all trailing whitespace in str.
`S`	`trim`	Returns a copy of str with all leading and trailing whitespace removed.
`S &`	`trimInPlace`	Removes all leading and trailing whitespace in str.
`S`	`toUpper`	Returns a copy of str containing all upper-case characters.
`S &`	`toUpperInPlace`	Replaces all characters in str with their upper-case counterparts.
`S`	`toLower`	Returns a copy of str containing all lower-case characters.
`S &`	`toLowerInPlace`	Replaces all characters in str with their lower-case counterparts.
`int`	`icompare` `inline`	Case-insensitive string comparison (locale-independent, ASCII only).
`std::streamsize`	`copyStreamUnbuffered`	Copies all bytes from istr to ostr one byte at a time (no internal buffer).
`std::streamsize`	`copyStream`	Copies all bytes from istr to ostr using an internal buffer.
`std::streamsize`	`copyToString`	Reads all bytes from istr and appends them to str.
`void`	`clearList` `inline`	Delete all elements from a list of pointers.
`void`	`clearDeque` `inline`	Delete all elements from a deque of pointers.
`void`	`clearVector` `inline`	Delete all elements from a vector of pointers.
`void`	`clearMap` `inline`	Delete all associated values from a map (not the key elements).

format

std::string format(const char * fmt, ...)

Printf-style string formatting for POD types.

Parameters

fmt printf format string.
... Format arguments.

Returns

Formatted string.

toUnderscore

void toUnderscore(std::string & str)

Replaces all non-alphanumeric characters in str with underscores and converts to lowercase.

Parameters

str String to transform in place.

isNumber

bool isNumber(std::string_view str)

Returns true if str consists entirely of digit characters.

Parameters

str String to test.

Returns

true if every character in str is a decimal digit.

endsWith

bool endsWith(std::string_view str, std::string_view suffix)

Returns true if str ends with the given suffix.

Parameters

str String to test.
suffix Suffix to look for.

Returns

true if str ends with suffix.

removeSpecialCharacters

void removeSpecialCharacters(std::string & str, bool allowSpaces)

Replaces non-alphanumeric characters. Removes all non-alphanumeric characters from str in place.

Parameters

str String to modify.
allowSpaces If true, ASCII spaces are preserved.

replaceSpecialCharacters

void replaceSpecialCharacters(std::string & str, char with, bool allowSpaces)

Replaces all non-alphanumeric characters in str with with in place.

Parameters

str String to modify.
with Replacement character (default: '_').
allowSpaces If true, ASCII spaces are preserved rather than replaced.

tryParseHex

bool tryParseHex(std::string_view s, unsigned & value)

Attempts to parse a hex string into an unsigned integer.

Parameters

s Hex string (with or without 0x prefix).
value Output: parsed value on success.

Returns

true if parsing succeeded, false otherwise.

parseHex

unsigned parseHex(std::string_view s)

Parses a hex string into an unsigned integer.

Parameters

s Hex string (with or without 0x prefix).

Returns

Parsed value.

Exceptions

std::invalid_argument if the string is not valid hex.

dumpbin

std::string dumpbin(const char * data, size_t len)

Formats the binary contents of data as a hex+ASCII dump string.

Parameters

data Pointer to the buffer to dump.
len Number of bytes to dump.

Returns

Multi-line hex dump string.

compareVersion

bool compareVersion(std::string_view l, std::string_view r)

Compares two dot-separated version strings.

Parameters

l Left (local) version string.
r Right (remote) version string.

Returns

true if l is strictly greater than r, false if l is equal or less.

matchNodes

bool matchNodes(std::string_view node, std::string_view xnode, std::string_view delim)

Checks whether node matches xnode by splitting both on delim and comparing element-wise.

Parameters

node Node list string to test.
xnode Expected node list pattern.
delim Delimiter used to split both strings (default: "\r\n").

Returns

true if all elements of node match the corresponding elements of xnode.

matchNodes

bool matchNodes(const std::vector< std::string > & params, const std::vector< std::string > & xparams)

Checks whether params matches xparams element-wise.

Parameters

params Parameter list to test.
xparams Expected parameter list.

Returns

true if every element of params matches the corresponding element of xparams.

memAddress

std::string memAddress(const void * ptr)

Returns the memory address of ptr as a hex string (e.g. "0x7f3a2b10c0").

Parameters

ptr Pointer whose address to format.

Returns

Hex string representation of the pointer value.

itostr

template<typename T> std::string itostr(const T & t)

Converts an integer (or any stream-insertable type) to its string representation.

Parameters

T Type to convert; must support operator<< on std::ostream.

Parameters

t Value to convert.

Returns

String representation of t.

strtoi

template<typename T> T strtoi(std::string_view s)

Parses a string into integer type T using std::istringstream. Returns 0 if parsing fails. Ensure T has sufficient range for the value.

Parameters

T Target integer type.

Parameters

s String to parse.

Returns

Parsed value, or 0 on failure.

randomNumber

uint32_t randomNumber()

Generates a 31-bit pseudo random number using the internal Random instance.

Returns

Pseudo random uint32_t value.

randomString

std::string randomString(int size)

Generates a random alphanumeric string of the given length.

Parameters

size Number of characters to generate.

Returns

Random string of length size.

randomBinaryString

std::string randomBinaryString(int size, bool doBase64)

Generates a random binary string of the given byte length.

Parameters

size Number of random bytes to generate.
doBase64 If true, returns the bytes as a base64-encoded string.

Returns

Random binary string, optionally base64-encoded.

split

void split(std::string_view str, std::string_view delim, std::vector< std::string > & elems, int limit)

Splits str on the delimiter string and appends tokens to elems.

Parameters

str String to split.
delim Delimiter string.
elems Output vector; tokens are appended to it.
limit Maximum number of splits (-1 for unlimited).

split

std::vector< std::string > split(std::string_view str, std::string_view delim, int limit)

Splits str on the delimiter string and returns the tokens as a vector.

Parameters

str String to split.
delim Delimiter string.
limit Maximum number of splits (-1 for unlimited).

Returns

Vector of token strings.

split

void split(std::string_view str, char delim, std::vector< std::string > & elems, int limit)

Splits str on the delimiter character and appends tokens to elems.

Parameters

str String to split.
delim Delimiter character.
elems Output vector; tokens are appended to it.
limit Maximum number of splits (-1 for unlimited).

split

std::vector< std::string > split(std::string_view str, char delim, int limit)

Splits str on the delimiter character and returns the tokens as a vector.

Parameters

str String to split.
delim Delimiter character.
limit Maximum number of splits (-1 for unlimited).

Returns

Vector of token strings.

replaceInPlace

template<class S> S & replaceInPlace(S & str, const S & from, const S & to, typename S::size_type start)

Replace all occurrences of from in str with to, starting at position start. Modifies and returns str in place. from must not be empty.

replaceInPlace

template<class S> S & replaceInPlace(S & str, const typename S::value_type * from, const typename S::value_type * to, typename S::size_type start)

Replace all occurrences of from in str with to, starting at position start. C-string overload. Modifies and returns str in place.

replace

template<class S> S replace(const S & str, const S & from, const S & to, typename S::size_type start)

Replace all occurences of from (which must not be the empty string) in str with to, starting at position start.

replace

template<class S> S replace(const S & str, const typename S::value_type * from, const typename S::value_type * to, typename S::size_type start)

Returns a copy of str with all occurrences of from replaced by to (C-string overload).

Parameters

str Source string.
from Substring to search for; must not be empty.
to Replacement string.
start Position in str at which to begin searching (default: 0).

Returns

New string with all replacements applied.

trimLeft

template<class S> S trimLeft(const S & str)

Returns a copy of str with all leading whitespace removed.

trimLeftInPlace

template<class S> S & trimLeftInPlace(S & str)

Removes all leading whitespace in str.

trimRight

template<class S> S trimRight(const S & str)

Returns a copy of str with all trailing whitespace removed.

trimRightInPlace

template<class S> S & trimRightInPlace(S & str)

Removes all trailing whitespace in str.

trim

template<class S> S trim(const S & str)

Returns a copy of str with all leading and trailing whitespace removed.

trimInPlace

template<class S> S & trimInPlace(S & str)

Removes all leading and trailing whitespace in str.

toUpper

template<class S> S toUpper(const S & str)

Returns a copy of str containing all upper-case characters.

toUpperInPlace

template<class S> S & toUpperInPlace(S & str)

Replaces all characters in str with their upper-case counterparts.

toLower

template<class S> S toLower(const S & str)

Returns a copy of str containing all lower-case characters.

toLowerInPlace

template<class S> S & toLowerInPlace(S & str)

Replaces all characters in str with their lower-case counterparts.

icompare

inline

inline int icompare(std::string_view a, std::string_view b)

Case-insensitive string comparison (locale-independent, ASCII only).

Parameters

a First string.
b Second string.

Returns

Negative if a < b, zero if a == b, positive if a > b.

copyStreamUnbuffered

std::streamsize copyStreamUnbuffered(std::istream & istr, std::ostream & ostr)

Copies all bytes from istr to ostr one byte at a time (no internal buffer).

Parameters

istr Source stream.
ostr Destination stream.

Returns

Total number of bytes copied.

copyStream

std::streamsize copyStream(std::istream & istr, std::ostream & ostr, size_t bufferSize)

Copies all bytes from istr to ostr using an internal buffer.

Parameters

istr Source stream.
ostr Destination stream.
bufferSize Internal buffer size in bytes (default: 8192).

Returns

Total number of bytes copied.

copyToString

std::streamsize copyToString(std::istream & istr, std::string & str, size_t bufferSize)

Reads all bytes from istr and appends them to str.

Parameters

istr Source stream.
str Output string to append data to.
bufferSize Internal buffer size in bytes (default: 8192).

Returns

Total number of bytes read.

clearList

inline

template<typename Val> inline void clearList(std::list< Val * > & L)

Delete all elements from a list of pointers.

clearDeque

inline

template<typename Val> inline void clearDeque(std::deque< Val * > & D)

Delete all elements from a deque of pointers.

clearVector

inline

template<typename Val> inline void clearVector(std::vector< Val * > & V)

Delete all elements from a vector of pointers.

clearMap

inline

template<typename Key, typename Val> inline void clearMap(std::map< Key, Val * > & M)

Delete all associated values from a map (not the key elements).