pystring (C++)¶

namespace Foundry¶

namespace Katana¶

namespace pystring_v1¶

Functions

std::string capitalize(const std::string &str)¶

Return a copy of the string with only its first character capitalized.

std::string center(const std::string &str, int width)¶

Return centered in a string of length width. Padding is done using spaces.

int count(const std::string &str, const std::string &substr, int start = 0, int end = MAX_32BIT_INT)¶

Return the number of occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation.

bool endswith(const std::string &str, const std::string &suffix, int start = 0, int end = MAX_32BIT_INT)¶

Return True if the string ends with the specified suffix, otherwise return False. With optional start, test beginning at that position. With optional end, stop comparing at that position.

std::string expandtabs(const std::string &str, int tabsize = 8)¶

Return a copy of the string where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed.

int find(const std::string &str, const std::string &sub, int start = 0, int end = MAX_32BIT_INT)¶

Return the lowest index in the string where substring sub is found, such that sub is contained in the range [start, end). Optional arguments start and end are interpreted as in slice notation. Return -1 if sub is not found.

int index(const std::string &str, const std::string &sub, int start = 0, int end = MAX_32BIT_INT)¶

Synonym of find right now. Python version throws exceptions. This one currently doesn’t.

bool isalnum(const std::string &str)¶

Return true if all characters in the string are alphanumeric and there is at least one character, false otherwise.

bool isalpha(const std::string &str)¶

Return true if all characters in the string are alphabetic and there is at least one character, false otherwise.

bool isdigit(const std::string &str)¶

Return true if all characters in the string are digits and there is at least one character, false otherwise.

bool islower(const std::string &str)¶

Return true if all cased characters in the string are lowercase and there is at least one cased character, false otherwise.

bool isspace(const std::string &str)¶

Return true if there are only whitespace characters in the string and there is at least one character, false otherwise.

bool istitle(const std::string &str)¶

Return true if the string is a titlecased string and there is at least one character, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return false otherwise.

bool isupper(const std::string &str)¶

Return true if all cased characters in the string are uppercase and there is at least one cased character, false otherwise.

std::string join(const std::string &str, const std::vector<std::string> &seq)¶

Return a string which is the concatenation of the strings in the sequence seq. The separator between elements is the str argument.

std::string ljust(const std::string &str, int width)¶

Return the string left justified in a string of length width. Padding is done using spaces. The original string is returned if width is less than str.size().

std::string lower(const std::string &str)¶

Return a copy of the string converted to lowercase.

std::string lstrip(const std::string &str, const std::string &chars = "")¶

Return a copy of the string with leading characters removed. If chars is omitted or None, whitespace characters are removed. If given and not “”, chars must be a string; the characters in the string will be stripped from the beginning of the string this method is called on (argument “str” ).

std::string mul(const std::string &str, int n)¶

Return a copy of the string, concatenated N times, together. Corresponds to the __mul__ operator.

void partition(const std::string &str, const std::string &sep, std::vector<std::string> &result)¶

Split the string around first occurance of sep. Three strings will always placed into result. If sep is found, the strings will be the text before sep, sep itself, and the remaining text. If sep is not found, the original string will be returned with two empty strings.

std::string replace(const std::string &str, const std::string &oldstr, const std::string &newstr, int count = -1)¶

Return a copy of the string with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced.

int rfind(const std::string &str, const std::string &sub, int start = 0, int end = MAX_32BIT_INT)¶

Return the highest index in the string where substring sub is found, such that sub is contained within s[start,end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.

int rindex(const std::string &str, const std::string &sub, int start = 0, int end = MAX_32BIT_INT)¶

Currently a synonym of rfind. The python version raises exceptions. This one currently does not.

std::string rjust(const std::string &str, int width)¶

Return the string right justified in a string of length width. Padding is done using spaces. The original string is returned if width is less than str.size().

void rpartition(const std::string &str, const std::string &sep, std::vector<std::string> &result)¶

Split the string around last occurance of sep. Three strings will always placed into result. If sep is found, the strings will be the text before sep, sep itself, and the remaining text. If sep is not found, the original string will be returned with two empty strings.

std::string rstrip(const std::string &str, const std::string &chars = "")¶

Return a copy of the string with trailing characters removed. If chars is “”, whitespace characters are removed. If not “”, the characters in the string will be stripped from the end of the string this method is called on.

void split(const std::string &str, std::vector<std::string> &result, const std::string &sep = "", int maxsplit = -1)¶

Fills the “result” list with the words in the string, using sep as the delimiter string. If maxsplit is > -1, at most maxsplit splits are done. If sep is “”, any whitespace string is a separator.

void rsplit(const std::string &str, std::vector<std::string> &result, const std::string &sep = "", int maxsplit = -1)¶

Fills the “result” list with the words in the string, using sep as the delimiter string. Does a number of splits starting at the end of the string, the result still has the split strings in their original order. If maxsplit is > -1, at most maxsplit splits are done. If sep is “”, any whitespace string is a separator.

void splitlines(const std::string &str, std::vector<std::string> &result, bool keepends = false)¶

Return a list of the lines in the string, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true.

bool startswith(const std::string &str, const std::string &prefix, int start = 0, int end = MAX_32BIT_INT)¶

Return True if string starts with the prefix, otherwise return False. With optional start, test string beginning at that position. With optional end, stop comparing string at that position.

std::string strip(const std::string &str, const std::string &chars = "")¶

Return a copy of the string with leading and trailing characters removed. If chars is “”, whitespace characters are removed. If given not “”, the characters in the string will be stripped from the both ends of the string this method is called on.

std::string swapcase(const std::string &str)¶

Return a copy of the string with uppercase characters converted to lowercase and vice versa.

std::string title(const std::string &str)¶

Return a titlecased version of the string: words start with uppercase characters, all remaining cased characters are lowercase.

std::string translate(const std::string &str, const std::string &table, const std::string &deletechars = "")¶

Return a copy of the string where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a string of length 256.

std::string upper(const std::string &str)¶

Return a copy of the string converted to uppercase.

std::string zfill(const std::string &str, int width)¶

Return the numeric string left filled with zeros in a string of length width. The original string is returned if width is less than str.size().

std::string slice(const std::string &str, int start = 0, int end = MAX_32BIT_INT)¶

function matching python’s slice functionality.

namespace os¶

Variables

Foundry::Katana::pystring_v1::os::sep

The character used by the operating system to separate pathname components. This is ‘/’ for POSIX and ‘\’ for Windows. Note that knowing this is not sufficient to be able to parse or concatenate pathnames – use path::split() and path::join() – but it is occasionally useful.

Foundry::Katana::pystring_v1::os::pathsep

The character conventionally used by the operating system to separate search path components (as in PATH), such as ‘:’ for POSIX or ‘;’ for Windows.

namespace path¶

Functions

std::string basename(const std::string &path)¶

Return the base name of pathname path. This is the second half of the pair returned by split(path). Note that the result of this function is different from the Unix basename program; where basename for ‘/foo/bar/’ returns ‘bar’, the basename() function returns an empty string (‘’).

std::string basename_nt(const std::string &path)¶

std::string basename_posix(const std::string &path)¶

std::string dirname(const std::string &path)¶

Return the directory name of pathname path. This is the first half of the pair returned by split(path).

std::string dirname_nt(const std::string &path)¶

std::string dirname_posix(const std::string &path)¶

bool isabs(const std::string &path)¶

Return True if path is an absolute pathname. On Unix, that means it begins with a slash, on Windows that it begins with a (back)slash after chopping off a potential drive letter.

bool isabs_nt(const std::string &path)¶

bool isabs_posix(const std::string &s)¶

std::string abspath(const std::string &path, const std::string &cwd)¶

Return a normalized absolutized version of the pathname path.

NOTE: This differs from the interface of the python equivalent in that it requires you to pass in the current working directory as an argument.

std::string abspath_nt(const std::string &path, const std::string &cwd)¶

std::string abspath_posix(const std::string &path, const std::string &cwd)¶

std::string join(const std::string &path1, const std::string &path2)¶

Join one or more path components intelligently. If any component is an absolute path, all previous components (on Windows, including the previous drive letter, if there was one) are thrown away, and joining continues. The return value is the concatenation of path1, and optionally path2, etc., with exactly one directory separator (os.sep) inserted between components, unless path2 is empty. Note that on Windows, since there is a current directory for each drive, os.path.join(“c:”, “foo”) represents a path relative to the current directory on drive C: (c:foo), not c:.

This dispatches based on the compilation OS

std::string join_nt(const std::string &path1, const std::string &path2)¶

std::string join_posix(const std::string &path1, const std::string &path2)¶

std::string join(const std::vector<std::string> &paths)¶

std::string join_nt(const std::vector<std::string> &paths)¶

std::string join_posix(const std::vector<std::string> &paths)¶

std::string normpath(const std::string &path)¶

Normalize a pathname. This collapses redundant separators and up-level references so that A//B, A/B/, A/./B and A/foo/../B all become A/B. It does not normalize the case. On Windows, it converts forward slashes to backward slashes. It should be understood that this may change the meaning of the path if it contains symbolic links!

std::string normpath_nt(const std::string &path)¶

std::string normpath_posix(const std::string &path)¶

void split(std::string &head, std::string &tail, const std::string &path)¶

Split the pathname path into a pair, (head, tail) where tail is the last pathname component and head is everything leading up to that. The tail part will never contain a slash; if path ends in a slash, tail will be empty. If there is no slash in path, head will be empty. If path is empty, both head and tail are empty. Trailing slashes are stripped from head unless it is the root (one or more slashes only). In all cases, join(head, tail) returns a path to the same location as path (but the strings may differ).

void split_nt(std::string &head, std::string &tail, const std::string &path)¶

void split_posix(std::string &head, std::string &tail, const std::string &path)¶

void splitdrive(std::string &drivespec, std::string &pathspec, const std::string &path)¶

Split the pathname path into a pair (drive, tail) where drive is either a drive specification or the empty string. On systems which do not use drive specifications, drive will always be the empty string. In all cases, drive + tail will be the same as path.

void splitdrive_nt(std::string &drivespec, std::string &pathspec, const std::string &p)¶

void splitdrive_posix(std::string &drivespec, std::string &pathspec, const std::string &path)¶

void splitext(std::string &root, std::string &ext, const std::string &path)¶

Split the pathname path into a pair (root, ext) such that root + ext == path, and ext is empty or begins with a period and contains at most one period. Leading periods on the basename are ignored; splitext(‘.cshrc’) returns (‘.cshrc’, ‘’).

void splitext_nt(std::string &root, std::string &ext, const std::string &path)¶

void splitext_posix(std::string &root, std::string &ext, const std::string &path)¶

std::string expanduser(const std::string &path)¶

Expand paths beginning with ‘~’ or ‘~user’. ‘~’ means the current user’s home directory; ‘~user’ means that user’s home directory. If the path doesn’t begin with ‘~’, or if the user or their home directory is unknown, the path is returned unchanged (leaving error reporting to whatever function is called with the expanded path as argument).

std::string expandvars(const std::string &path, EnvironmentInterface *environment = NULL)¶

Return the argument with environment variables expanded. Substrings of the form ‘$name’ or ‘${name}’ are replaced by the value of environment variable name. Malformed variable names and references to non-existent variables are left unchanged. By default, environment variables are provided by ::getenv(), but a custom environment may also be specified.

class EnvironmentInterface¶

Public Functions

virtual ~EnvironmentInterface()¶

virtual bool getenv(const std::string &key, std::string &result) const = 0¶