Skip to content

Rose::StringUtility

Functions for operating on strings.

Description

This name space provides functions for operating on strings.

Types

Name Description
FileNameClassification
NumberParseResult
StringWithLineNumber String with source location information.

Type Aliases

Name Description
FileNameLibrary
FileWithLineNumbers A vector of strings with line numbers and file names.

Enums

Name Description
FileNameLocation
OSType /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Functions

Name Description
addrToString
[[visibility("default")]] std::string addrToString( uint64_t value, size_t nbits = 0);
Convert a virtual address to a string.
bourneEscape
[[visibility("default")]] std::string bourneEscape(std::string const&);
Escapes characters that are special to the Bourne shell.
cEscape
[[visibility("default")]] std::string cEscape( char, char context = '\'');
Escapes characters that are special to C/C++.
cUnescape
[[visibility("default")]] std::string cUnescape(std::string const&);
Unescapes C++ string literals.
centerJustify
[[visibility("default")]] std::string centerJustify( std::string const& input, size_t width, char fill = ' ');
Center a string in a field.
classifyFileName
[[visibility("default")]] FileNameClassification classifyFileName( std::string const& fileName, std::string const& appPath);
Determine whether a file is source code or system library.
convertToLowerCase
[[visibility("default")]] std::string convertToLowerCase(std::string const& inputString);
Convert to lower case.
copyEdit
[[visibility("default")]] FileWithLineNumbers copyEdit( FileWithLineNumbers const& inputString, std::string const& oldToken, FileWithLineNumbers const& newToken);
Replace all occurrences of a string with another string.
csvEscape
[[visibility("default")]] std::string csvEscape(std::string const&);
Escapes characters that are special in CSV tables.
decode_base64
[[visibility("default")]] std::vector<uint8_t> decode_base64(std::string const& encoded);
Convert base-64 to binary.
directoryDistance
[[visibility("default")]] int directoryDistance( std::string const& left, std::string const& right);
Edit distance between two directory names.
encode_base64
[[visibility("default")]] std::string encode_base64( std::vector<uint8_t> const& data, bool do_pad = true);
Convert binary data to base-64.
escapeNewlineAndDoubleQuoteCharacters
[[visibility("default")]] std::string escapeNewlineAndDoubleQuoteCharacters(std::string const&);
Escapes line feeds as l and double quotes for DOT labels.
fileNameSuffix
[[visibility("default")]] std::string fileNameSuffix(std::string const& fileName);
Get the file name suffix (extension) without the leading dot.
fixLineTermination
[[visibility("default")]] std::string fixLineTermination(std::string const& input);
Normalizes line termination.
getAbsolutePathFromRelativePath
[[visibility("default")]] std::string getAbsolutePathFromRelativePath(std::string const& relativePath);
Get the canonical absolute path of an existing filesystem entry.
getOSType
[[visibility("default")]] OSType getOSType();
Obtain operating system type information.
getPathFromFileName
[[visibility("default")]] std::string getPathFromFileName(std::string const& fileNameWithPath);
Returns all but the last component of a path in a filesystem.
hexadecimalToInt
[[visibility("default")]] unsigned int hexadecimalToInt(char);
Convert an ASCII hexadecimal character to an integer.
htmlEscape
[[visibility("default")]] std::string htmlEscape(std::string const&);
Escapes HTML special characters.
intToHex
[[visibility("default")]] std::string intToHex(uint64_t);
Convert an integer to a hexadecimal string.
isContainedIn
bool isContainedIn( std::string const& longString, std::string const& shortString);
Determines whether one string contains another.
isLineTerminated
[[visibility("default")]] bool isLineTerminated(std::string const& s);
Returns true if the string ends with line termination.
join
template<class Container> std::string join( char separator, Container const& container);
join_range
template<class Iterator> std::string join_range( std::string const& separator, Iterator begin, Iterator end);
Join individual items to form a single string.
jsonEscape
[[visibility("default")]] std::string jsonEscape(std::string const&);
Escapes characters that are special inside a JSON string.
leftJustify
[[visibility("default")]] std::string leftJustify( std::string const& input, size_t width, char fill = ' ');
Left justify a string to specified width.
listToString
[[visibility("default")]] std::string listToString( std::list<int> const&, bool separateStrings = false);
listToString overloads
makeOneLine
[[visibility("default")]] std::string makeOneLine( std::string const& s, std::string replacement = " ");
Converts a multi-line string to a single line.
numberToString
[[visibility("default")]] std::string numberToString(__int128 x);
numberToString overloads
operator+
FileWithLineNumbers operator+( FileWithLineNumbers const& a, FileWithLineNumbers const& b);
Concatenate vectors of strings with source location.
operator+=
FileWithLineNumbers& operator+=( FileWithLineNumbers& a, FileWithLineNumbers const& b);
Append strings with source location information to vector of such.
prefixLines
[[visibility("default")]] std::string prefixLines( std::string const& lines, std::string const& prefix, bool prefixAtFront = true, bool prefixAtBack = false);
Insert a prefix string before every line.
readFile
[[visibility("default")]] std::string readFile(std::string const& fileName);
Reads entire text file.
readFileWithPos
[[visibility("default")]] FileWithLineNumbers readFileWithPos(std::string const& fileName);
Reads an entire text file.
removeAnsiEscapes
[[visibility("default")]] std::string removeAnsiEscapes(std::string const&);
Remove ANSI escape characters.
removeRedundantSubstrings
[[visibility("default")]] std::string removeRedundantSubstrings(std::string const&);
Remove redundant and blank lines.
replaceAllCopy
[[visibility("default")]] std::string replaceAllCopy( std::string const& input, std::string const& search, std::string const& replacedWith);
Replace every occurrence of a nonempty pattern in a string.
rightJustify
[[visibility("default")]] std::string rightJustify( std::string const& input, size_t width, char fill = ' ');
Right justify a string to specified width.
signedToHex
template<typename T> std::string signedToHex(T value);
signedToHex2
[[visibility("default")]] std::string signedToHex2( uint64_t value, size_t nbits);
split
[[visibility("default")]] std::vector<std::string> split( char separator, std::string const& str, size_t maxparts = UNLIMITED, bool trim_white_space = false);
Splits strings into parts.
splitStringIntoStrings
[[visibility("default")]] void splitStringIntoStrings( std::string const& inputString, char separator, std::vector<std::string>& stringList);
Splits string into substring based on a separator character.
stringToList
[[visibility("default")]] std::list<std::string> stringToList(std::string const&);
Split a string into substrings at line feeds.
stripDotsFromHeaderFileName
[[visibility("default")]] std::string const stripDotsFromHeaderFileName(std::string const& name);
Remove leading dots.
stripFileSuffixFromFileName
[[visibility("default")]] std::string stripFileSuffixFromFileName(std::string const& fileNameWithSuffix);
Get the file name without the ".suffix".
stripPathFromFileName
[[visibility("default")]] std::string stripPathFromFileName(std::string const& fileNameWithPath);
Returns the last component of a path in a filesystem.
toHex2
[[visibility("default")]] std::string toHex2( uint64_t value, size_t nbits, bool show_unsigned_decimal = true, bool show_signed_decimal = true, uint64_t decimal_threshold = 256);
Convert a number to a hexadecimal and decimal string.
toNumber
template<typename T> NumberParseResult<T> toNumber(std::string const& input);
toString
[[visibility("default")]] std::string toString( FileWithLineNumbers const& strings, std::string const& filename = "<unknown>", int line = 1);
Generate C preprocessor #line directives.
tokenize
[[visibility("default")]] std::list<std::string> tokenize( std::string const&, char delim);
Split a string into a list based on a separator character.
trim
[[visibility("default")]] std::string trim( std::string const& str, std::string const& strip = " \t\r\n", bool at_beginning = true, bool at_end = true);
Trims white space from the beginning and end of a string.
unsignedToHex
template<typename T> std::string unsignedToHex(T value);
unsignedToHex2
[[visibility("default")]] std::string unsignedToHex2( uint64_t value, size_t nbits);
writeFile
[[visibility("default")]] void writeFile( std::string const& outputString, std::string const& fileNameString, std::string const& directoryName);
Create a file.
operator<<
std::ostream& operator<<( std::ostream& os, StringWithLineNumber const& s);
Stream insertion operators

Created with MrDocs