zfc9000: comparison sources/mystring.cpp

-:be953e1621d9
+:819fdef70d68
 #include "mystring.h"
 BEGIN_ZFC_NAMESPACE
 /*!
-* \returns a lower-case version of this string.
+* \brief Converts the given string to lowercase.
+* \param string string to convert
+* \return converted string
 */
 std::string to_lowercase(const std::string& string)
 {
 	std::string result = string;
 	return result;
 }
 /*!
-* \brief Joins the elements of this string list into one longer string.
+* \brief Joins a list of strings to a single string.
-* \param delimeter The delimeter to place between the element strings.
+* \param strings strings to join together
-* \returns the catenated string.
+* \param delimeter delimeter to join the strings together with
+* \return joined string
 */
 std::string join_string_list(const std::vector<std::string>& strings, const std::string& delimeter)
 {
 	std::string result;
 	return result;
 }
 /*!
-* \brief Modifies the given index so that if it is negative, it is translated into a positive index starting from the
+* \brief Extracts a substring from the middle of the given string
-*        end of the string. For example, an index of -1 will be modified to point to the last character in the string,
+* \param str string to extract from
-*        -2 to the second last, etc.
+* \param rangeBegin starting index of the substring
-* \param index Index to translate.
+* \param rangeEnd end index of the substring
-*/
+* \return substring
-inline void modifyIndex(const std::string& str, int& index)
-{
-	if (index < 0)
-		index = str.length() - index;
-}
-/*!
-* \param a Starting index of the range.
-* \param b Ending index of the range.
-* \returns a sub-string containing all characters from \c a to \c b, not including the character at \c b.
 */
 std::string mid(const std::string& str, int rangeBegin, int rangeEnd)
 {
-	modifyIndex(str, rangeBegin);
-	modifyIndex(str, rangeEnd);
 	rangeBegin = max(rangeBegin, 0);
 	rangeEnd = min(rangeEnd, static_cast<signed>(str.length()));
+	std::string result;
-	if (rangeEnd <= rangeBegin)
+	if (rangeEnd > rangeBegin)
-		return "";
+	{
-	else
+		result = str.substr(rangeBegin, rangeEnd - rangeBegin);
-		return str.substr(rangeBegin, rangeEnd - rangeBegin);
+	}
-}
+	return result;
+}
-/*!
-* \param length Amount of characters to return.
+/*!
-* \returns the \c length right-most characters of the string.
+* \brief right Extracts a substring from the end of the substring
+* \param str string to extract from
+* \param length desired length of the new substring
+* \return substring
 */
 std::string right(const std::string& str, int length)
 {
 	if (length >= static_cast<signed>(str.length()))
 		return str;
 	else
 		return std::string{str.data() + str.length() - length};
 }
 /*!
-* \brief Formats this string using \c vsnprintf, using the provided arguments.
+* \brief Formats a string using \c vsnprintf, using a va_list argument list
-* \param formatString Template string to use with formatting.
+* \param formatString formatting string
-* \param args Variadic arguments to use with formatting.
+* \param args argument list
+* \return formatted string
 */
 std::string vsprintf(const char* formatString, va_list args)
 {
 	std::string result;
 	// Copy the argument list so that we have something to provide to vsnprintf in case we have to call it again.
 	va_list argsCopy;
 	va_copy(argsCopy, args);
 	// First, attempt to format using a fixed-size buffer.
 	static char buffer[1024];
-	size_t length = vsnprintf(buffer, sizeof buffer, formatString, args);
+	const std::size_t length = std::vsnprintf(buffer, countof(buffer), formatString, args);
 	if (length < sizeof buffer)
 	{
 		// vsnprintf succeeded in fitting the formatted string into the buffer, so we're done.
 		result = buffer;
 	}
 	else
 	{
 		// vsnprintf needs more space, so we have to allocate a new buffer and try again.
-		std::vector<char> newBuffer(length + 1);
+		result.resize(length + 1);
-		vsnprintf(newBuffer.data(), length + 1, formatString, argsCopy);
+		std::vsnprintf(result.data(), length + 1, formatString, argsCopy);
-		result = newBuffer.data();
+	}
-	}
+	return result;
+}
-	return result;
-}
+/*!
+* \brief Formats a string using \c printf -like syntax
-/*!
+* \param formatString formatting string
-* \brief Formats this string using \c printf -like syntax.
+* \param ... printf-like arguments
-* \param formatString Template string to use with formatting.
+* \return formatted string
-* \param ... Variadic arguments to use with formatting.
 */
 std::string __cdecl sprintf(const char* formatString, ...)
 {
 	va_list args;
 	va_start (args, formatString);
 	std::string result = vsprintf(formatString, args);
 	va_end (args);
 	return result;
 }
+/*!
+* \brief Removes a substring from the middle of a string
+* \param string original string
+* \param start start index to remove
+* \param end end index to remove
+* \return modified string
+*/
 std::string remove_range(const std::string &string, int start, int end)
 {
 	std::string result;
 	result.reserve(string.length() - (end - start));
 	std::copy(string.begin(), string.begin() + start, std::back_inserter(result));
 	std::copy(string.begin() + end, string.end(), std::back_inserter(result));
 	return result;
 }
+/*!
-/*!
+* \brief Finds out whether the specified string starts with the specified substring.
-* \param other Sub-string to find from the beginning of this string.
+* \param string string to test
-* \returns whether or not this string begins with the provided sub-string.
+* \param substring substring to look for
-*/
+* \return bool
-bool starts_with(const std::string& str, const std::string& other)
+*/
-{
+bool starts_with(const std::string& string, const std::string& substring)
-	if (str.length() < other.length())
+{
+	if (string.length() < substring.length())
 		return false;
 	else
-		return std::strncmp(str.data(), other.data(), other.length()) == 0;
+		return std::strncmp(string.data(), substring.data(), substring.length()) == 0;
 }
 /*!
-* \brief Replaces all instances of \c text with \c replacement.
+* \brief Replaces all instances of \c text with \c replacement in place.
 * \param text Text to replace away.
 * \param replacement Text to replace \c text with.
 */
 void replace_all(std::string& str, const char* text, const char* replacement)
 {
 	return result;
 }
 /*!
-* \brief Converts this string to an integer.
+* \brief Attempts to convert the specified string to an integer.
-* \param ok An pointer to a boolean to store whether or not the conversion was successful.
+* \param str string to convert
-*           If \c ok is \c NULL, the success state is not stored.
+* \param base numeric base to convert using.
-* \param base The base to interpret this string with.
+* \return the integer if conversion is successful.
-* \returns the resulting integer.
 */
 std::optional<long> to_int(const char* str, int base)
 {
 	errno = 0;
 	char* endPointer;
 		return {};
 	}
 }
 /*!
-* \brief Removes leading and trailing whitespace from this string. Alternatively a custom filter can be used to strip
+* \brief Removes unwanted characters from the specified string. Modification is done in place.
-*        something else than whitespace.
+* \param string String to modify.
-* \param filter The filtering function to use.
+* \param filter The filtering function to use, defaults to std::isspace in order to remove whitespace.
 */
 void normalize(std::string& string, int (*filter)(int))
 {
 	int a = 0;
 	int b = string.length() - 1;

Mercurial > zfc9000 / file comparison

comparison: sources/mystring.cpp

sources/mystring.cpp