zfc9000: comparison sources/mystring.cpp

-:81357dcd3da4
+:12c93c4a137c
 #include "mystring.h"
 #include "md5.h"
 BEGIN_ZFC_NAMESPACE
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Compares this string with another.
+* \param other The string to compare with.
+* \returns -1 if this string is lexicographically less than \c other,
+*          0 if they are equal, or
+*          1 if this string is lexicographically greater than \c other.
+*/
 int String::compare (const String& other) const
 {
 	return m_string.compare (other.stdString());
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Removes all instances of an unwanted character from this string.
-void String::trim (int n)
+* \param unwanted Character to remove.
-{
+*/
-	if (n > 0)
+void String::strip (char unwanted)
-		m_string = mid (0, length() - n).stdString();
+{
-	else
+	for (int pos = 0; (pos = find (unwanted)) != -1;)
-		m_string = mid (n, -1).stdString();
+		removeAt (pos--);
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Removes all instances of multiple characters from this string.
-String String::strip (char unwanted) const
+* \param unwanted Characters to remove.
-{
+*/
-	String result (m_string);
+void String::strip (const List<char>& unwanted)
+{
-	for (int pos = 0; (pos = result.find (unwanted)) != -1;)
+	for (char character : unwanted)
-		result.removeAt (pos--);
+		strip(character);
+}
-	return result;
-}
+/*!
+* \returns an upper-case version of this string.
-// -------------------------------------------------------------------------------------------------
+*/
-//
-String String::strip (const List<char>& unwanted) const
-{
-	String result (m_string);
-	for (String c : unwanted)
-	for (int pos = 0; (pos = result.find (c)) != -1;)
-		result.removeAt (pos--);
-	return result;
-}
-// -------------------------------------------------------------------------------------------------
-//
 String String::toUpperCase() const
 {
 	String result (m_string);
 	for (char &ch : result)
 	}
 	return result;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \returns a lower-case version of this string.
+*/
 String String::toLowerCase() const
 {
 	String result (m_string);
 	for (char &ch : result)
 	}
 	return result;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Splits this string using the provided delimeter.
-StringList String::split (char del) const
+* \param delimeter Delimeter to use for splitting.
-{
+* \returns a string list containing the split strings.
-	String delimstr;
+*/
-	delimstr += del;
+StringList String::split (char delimeter) const
-	return split (delimstr);
+{
-}
+	String delimeterString;
+	delimeterString += delimeter;
-// -------------------------------------------------------------------------------------------------
+	return split (delimeterString);
-//
+}
-StringList String::split (const String& del) const
-{
+/*!
-	StringList res;
+* \brief Splits this string using the provided delimeter.
+* \param delimeter Delimeter to use for splitting.
+* \returns a string list containing the split strings.
+*/
+StringList String::split (const String& delimeter) const
+{
+	StringList result;
 	int a = 0;
 	int b;
 	// Find all separators and store the text left to them.
-	while ((b = find (del, a)) != -1)
+	while ((b = find (delimeter, a)) != -1)
 	{
 		String sub = mid (a, b);
 		if (sub.length() > 0)
-			res << sub;
+			result << sub;
-		a = b + del.length();
+		a = b + delimeter.length();
 	}
 	// Add the string at the right of the last separator
 	if (a < (int) length())
-		res.append (mid (a, length()));
+		result.append (mid (a, length()));
-	return res;
+	return result;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Replaces all instances of \c text with \c replacement.
-void String::replace (const char* a, const char* b)
+* \param text Text to replace away.
-{
+* \param replacement Text to replace \c text with.
-	long pos;
+*/
+void String::replace (const char* text, const char* replacement)
-	while ((pos = find (a)) != -1)
+{
-		m_string = m_string.replace (pos, strlen (a), b);
+	int position;
-}
+	while ((position = find (text)) != -1)
-// -------------------------------------------------------------------------------------------------
+		m_string = m_string.replace (position, strlen (text), replacement);
-//
+}
-int String::count (char needle) const
+/*!
+* \param character Character to count.
+* \returns the amount of \c character found in the string.
+*/
+int String::count (char character) const
 {
 	int result = 0;
 	for (char ch : *this)
 	{
-		if (ch == needle)
+		if (ch == character)
 			result++;
 	}
 	return result;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \param a Starting index of the range.
-// Returns a substring from [a, b)
+* \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.
-String String::mid (int a, int b) const
+*/
-{
+String String::mid (int rangeBegin, int rangeEnd) const
-	a = max(a, 0);
+{
-	b = min(b, length());
+	modifyIndex(rangeBegin);
+	modifyIndex(rangeEnd);
-	if (b == -1)
+	rangeBegin = max(rangeBegin, 0);
-		b = length();
+	rangeEnd = min(rangeEnd, length());
-	if (b <= a)
+	if (rangeEnd <= rangeBegin)
 		return "";
 	else
-		return m_string.substr(a, b - a);
+		return m_string.substr(rangeBegin, rangeEnd - rangeBegin);
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \param length Amount of characters to return.
+* \returns the \c length right-most characters of the string.
+*/
 String String::right(int length) const
 {
 	if (length >= this->length())
 		return *this;
 	else
 		return String(chars() + this->length() - length);
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Finds the first instance of a sub-string.
-int String::find (const char* c, int a) const
+* \param subString Sub-string to search within this string.
-{
+* \param startingPosition Position to start looking for the sub-string from.
-	int pos = m_string.find (c, a);
+* \returns the position the first instance of sub-string found, or -1 if not found.
+*/
-	if (pos == int (std::string::npos))
+int String::find (const char* subString, int startingPosition) const
+{
+	int position = m_string.find (subString, startingPosition);
+	if (position == int (std::string::npos))
 		return -1;
+	else
-	return pos;
+		return position;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Finds the first instance of a character.
-int String::find (char ch, int a) const
+* \param character Character to search within this string.
-{
+* \param startingPosition Position to start looking for the character from.
-	int pos = m_string.find (ch, a);
+* \returns the position of the first instance of the provided character found, or -1 if not found.
+*/
-	if (pos == int (std::string::npos))
+int String::find (char character, int startingPosition) const
+{
+	int position = m_string.find (character, startingPosition);
+	if (position == int (std::string::npos))
 		return -1;
+	else
-	return pos;
+		return position;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Finds the last instance of a sub-string.
-int String::findLast (const char* c, int a) const
+* \param subString Sub-string to search within this string.
-{
+* \param startingPosition Position to start looking for the sub-string from.
-	if (a == -1 or a >= length())
+* \returns the position the last instance of sub-string found, or -1 if not found.
-		a = length() - 1;
+*/
+int String::findLast (const char* subString, int startingPosition) const
-	for (; a > 0; a--)
+{
-		if (m_string[a] == c[0] and strncmp (chars() + a, c, strlen (c)) == 0)
+	modifyIndex(startingPosition);
-			return a;
+	for (; startingPosition > 0; startingPosition--)
+	{
+		if (strncmp (chars() + startingPosition, subString, strlen (subString)) == 0)
+			return startingPosition;
+	}
 	return -1;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Converts this string to an integer.
+* \param ok An pointer to a boolean to store whether or not the conversion was successful.
+*           If \c ok is \c NULL, the success state is not stored.
+* \param base The base to interpret this string with.
+* \returns the resulting integer.
+*/
 long String::toInt (bool* ok, int base) const
 {
 	errno = 0;
-	char* endptr;
+	char* endPointer;
-	long i = strtol (chars(), &endptr, base);
+	long result = strtol (chars(), &endPointer, base);
-	if (ok)
+	if (ok != nullptr)
-		*ok = (errno == 0 and *endptr == '\0');
+		*ok = (errno == 0 and *endPointer == '\0');
-	return i;
+	return result;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Converts this string to a floating-point number.
+* \param ok An pointer to a boolean to store whether or not the conversion was successful.
+*           If \c ok is \c NULL, the success state is not stored.
+* \returns the resulting floating-point number.
+*/
 float String::toFloat (bool* ok) const
 {
-	errno = 0;
+	return static_cast<float>(toDouble(ok));
-	char* endptr;
+}
-	float i = (float) strtod (chars(), &endptr);
+/*!
-	if (ok != nullptr)
+* \brief Converts this string to a double-precision floating-point number.
-		*ok = (errno == 0 and *endptr == '\0');
+* \param ok An pointer to a boolean to store whether or not the conversion was successful.
+*           If \c ok is \c NULL, the success state is not stored.
-	return i;
+* \returns the resulting floating-point number.
-}
+*/
-// -------------------------------------------------------------------------------------------------
-//
 double String::toDouble (bool* ok) const
 {
 	errno = 0;
 	char* endptr;
 	double i = strtod (chars(), &endptr);
 		*ok = (errno == 0 and *endptr == '\0');
 	return i;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Catenates this string with another string.
-String String::operator+ (const String& data) const
+* \param text String to catenate to the end of this string.
+* \returns the resulting string.
+*/
+String String::operator+ (const String& text) const
 {
 	String newString = *this;
-	newString.append (data);
+	newString.append (text);
 	return newString;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Catenates this string with another string.
-String String::operator+ (const char* data) const
+* \param text String to catenate to the end of this string.
-{
+* \returns the resulting string.
-	String newstr = *this;
+*/
-	newstr.append (data);
+String String::operator+ (const char* text) const
-	return newstr;
+{
-}
+	String newString = *this;
+	newString.append (text);
-// -------------------------------------------------------------------------------------------------
+	return newString;
-//
+}
+/*!
+* \returns whether or not this string represents a number.
+*/
 bool String::isNumeric() const
 {
-	char* endptr;
+	char* endPointer;
-	strtol (chars(), &endptr, 10);
+	strtol (chars(), &endPointer, 10);
-	return not (endptr && *endptr);
+	return (endPointer != nullptr) and (*endPointer != '\0');
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \param other Sub-string to find from the end of this string.
+* \return whether or not this string ends with the provided sub-string.
+*/
 bool String::endsWith (const String& other) const
+{
+	if (length() < other.length())
+	{
+		return false;
+	}
+	else
+	{
+		const int offset = length() - other.length();
+		return strncmp (chars() + offset, other.chars(), other.length()) == 0;
+	}
+}
+/*!
+* \param other Sub-string to find from the beginning of this string.
+* \returns whether or not this string begins with the provided sub-string.
+*/
+bool String::startsWith (const String& other) const
 {
 	if (length() < other.length())
 		return false;
+	else
-	const int ofs = length() - other.length();
+		return strncmp (chars(), other.chars(), other.length()) == 0;
-	return strncmp (chars() + ofs, other.chars(), other.length()) == 0;
+}
-}
+/*!
-// -------------------------------------------------------------------------------------------------
+* \brief Formats this string using \c printf -like syntax.
-//
+* \param formatString Template string to use with formatting.
-bool String::startsWith (const String& other) const
+* \param ... Variadic arguments to use with formatting.
-{
+*/
-	if (length() < other.length())
+void __cdecl String::sprintf (const char* formatString, ...)
-		return false;
-	return strncmp (chars(), other.chars(), other.length()) == 0;
-}
-// -------------------------------------------------------------------------------------------------
-//
-void __cdecl String::sprintf (const char* fmtstr, ...)
 {
 	va_list args;
-	va_start (args, fmtstr);
+	va_start (args, formatString);
-	this->vsprintf (fmtstr, args);
+	this->vsprintf (formatString, args);
 	va_end (args);
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Formats this string using \c vsnprintf, using the provided arguments. The buffer string will be repeatedly
-void String::vsprintf (const char* fmtstr, va_list args)
+*        allocated larger and larger until \c vsnprintf succeeds.
+* \param formatString Template string to use with formatting.
+* \param args Variadic arguments to use with formatting.
+*/
+void String::vsprintf (const char* formatString, va_list args)
 {
 	char* buf = nullptr;
 	int bufsize = 256;
 	do
 	{
 		bufsize *= 2;
 		delete[] buf;
 		buf = new char[bufsize];
 	}
-	while (vsnprintf (buf, bufsize, fmtstr, args) >= bufsize);
+	while (vsnprintf (buf, bufsize, formatString, args) >= bufsize);
 	m_string = buf;
 	delete[] buf;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Joins the elements of this string list into one longer string.
-String StringList::join (const String& delim)
+* \param delimeter The delimeter to place between the element strings.
+* \returns the catenated string.
+*/
+String StringList::join (const String& delimeter)
 {
 	String result;
 	for (const String &item : container())
 	{
 		if (result.isEmpty() == false)
-			result += delim;
+			result += delimeter;
 		result += item;
 	}
 	return result;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Tries to match this string against a mask pattern. In the pattern, '?' refers to one character, and '*' to
+*        any number of characters.
+* \param pattern The masking pattern to use for matching.
+* \returns whether or not this string matches the provided pattern.
+*/
 bool String::maskAgainst (const String& pattern) const
 {
 	// Elevate to uppercase for case-insensitive matching
 	String pattern_upper = pattern.toUpperCase();
 	String this_upper = toUpperCase();
 	}
 	return true;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Converts a short integer into a string.
-String String::fromNumber (short int a)
+* \param value The value to convert.
-{
+* \returns the resulting string.
-	char buf[32];
+*/
-	::sprintf (buf, "%d", a);
+String String::fromNumber (short int value)
-	return String (buf);
+{
-}
+	char buffer[32];
+	::sprintf (buffer, "%d", value);
-// -------------------------------------------------------------------------------------------------
+	return String (buffer);
-//
+}
-String String::fromNumber (int a)
-{
+/*!
-	char buf[32];
+* \brief Converts an integer into a string.
-	::sprintf (buf, "%d", a);
+* \param value The value to convert.
-	return String (buf);
+* \returns the resulting string.
-}
+*/
+String String::fromNumber (int value)
-// -------------------------------------------------------------------------------------------------
+{
-//
+	char buffer[32];
-String String::fromNumber (long int a)
+	::sprintf (buffer, "%d", value);
-{
+	return String (buffer);
-	char buf[32];
+}
-	::sprintf (buf, "%ld", a);
-	return String (buf);
+/*!
-}
+* \brief Converts a long integer into a string.
+* \param value The value to convert.
-// -------------------------------------------------------------------------------------------------
+* \returns the resulting string.
-//
+*/
-String String::fromNumber (unsigned short int a)
+String String::fromNumber (long int value)
 {
-	char buf[32];
+	char buffer[32];
-	::sprintf (buf, "%u", a);
+	::sprintf (buffer, "%ld", value);
-	return String (buf);
+	return String (buffer);
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Converts an unsigned short integer into a string.
-String String::fromNumber (unsigned int a)
+* \param value The value to convert.
-{
+* \returns the resulting string.
-	char buf[32];
+*/
-	::sprintf (buf, "%u", a);
+String String::fromNumber (unsigned short int value)
-	return String (buf);
+{
-}
+	char buffer[32];
+	::sprintf (buffer, "%u", value);
-// -------------------------------------------------------------------------------------------------
+	return String (buffer);
-//
+}
-String String::fromNumber (unsigned long int a)
-{
+/*!
-	char buf[32];
+* \brief Converts an unsigned integer into a string.
-	::sprintf (buf, "%lu", a);
+* \param value The value to convert.
-	return String (buf);
+* \returns the resulting string.
-}
+*/
+String String::fromNumber (unsigned int value)
-// -------------------------------------------------------------------------------------------------
+{
-//
+	char buffer[32];
-String String::fromNumber (double a)
+	::sprintf (buffer, "%u", value);
-{
+	return String (buffer);
-	char buf[64];
+}
-	::sprintf (buf, "%f", a);
-	return String (buf);
+/*!
-}
+* \brief Converts an unsigned long integer into a string.
+* \param value The value to convert.
-// -------------------------------------------------------------------------------------------------
+* \returns the resulting string.
-//
+*/
+String String::fromNumber (unsigned long int value)
+{
+	char buffer[32];
+	::sprintf (buffer, "%lu", value);
+	return String (buffer);
+}
+/*!
+* \brief Converts a double-precision floating point number into a string, using the "%f" format specifier.
+* \param value The value to convert.
+* \returns the resulting string.
+*/
+String String::fromNumber (double value)
+{
+	char buffer[64];
+	::sprintf (buffer, "%f", value);
+	return String (buffer);
+}
+/*!
+* \returns the MD5-checksum of this string.
+*/
 String String::md5() const
 {
 	char checksum[33];
 	CalculateMD5 (reinterpret_cast<const unsigned char*> (chars()), length(), checksum);
 	checksum[sizeof checksum - 1] = '\0';
 	return String (checksum);
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Removes leading and trailing whitespace from this string. Alternatively a custom filter can be used to strip
+*        something else than whitespace.
+* \param filter The filtering function to use.
+*/
 void String::normalize (int (*filter)(int))
 {
 	int a = 0;
 	int b = length() - 1;
 		m_string = "";
 	else if (a != 0 or b != length() - 1)
 		m_string = m_string.substr (a, b - a + 1);
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \returns a version of this string without leading or trailing whitespace. Alternatively a custom filter can be used
+*          to strip something else than whitespace.
+*/
 String String::normalized (int (*filter)(int)) const
 {
 	String result = *this;
 	result.normalize(filter);
 	return result;

Mercurial > zfc9000 / file comparison

comparison: sources/mystring.cpp

sources/mystring.cpp