zfc9000: comparison sources/mystring.cpp

-:d9073c13dc98
+:37db42ad451a
 #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.std_string());
+	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).std_string();
+{
-	else
+	for (int pos = 0; (pos = find (unwanted)) != -1;)
-		m_string = mid (n, -1).std_string();
+		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.remove_at (pos--);
+		strip(character);
+}
-	return result;
-}
+/*!
+* \returns an upper-case version of this string.
-// -------------------------------------------------------------------------------------------------
+*/
-//
+String String::toUpperCase() const
-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.remove_at (pos--);
-	return result;
-}
-// -------------------------------------------------------------------------------------------------
-//
-String String::to_uppercase() const
 {
 	String result (m_string);
 	for (char &ch : result)
 	{
 	}
 	return result;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \returns a lower-case version of this string.
-String String::to_lowercase() const
+*/
+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::word_position (int n) const
+* \param subString Sub-string to search within this string.
-{
+* \param startingPosition Position to start looking for the sub-string from.
-	int count = 0;
+* \returns the position the first instance of sub-string found, or -1 if not found.
+*/
-	for (char ch : *this)
+int String::find (const char* subString, int startingPosition) const
-	{
+{
-		if (not isspace(ch) or ++count < n)
+	int position = m_string.find (subString, startingPosition);
-			continue;
+	if (position == int (std::string::npos))
+		return -1;
+	else
+		return position;
+}
+/*!
+* \brief Finds the first instance of a character.
+* \param character Character to search within this string.
+* \param startingPosition Position to start looking for the character from.
+* \returns the position of the first instance of the provided character found, or -1 if not found.
+*/
+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 position;
+}
+/*!
+* \brief Finds the last instance of a sub-string.
+* \param subString Sub-string to search within this string.
+* \param startingPosition Position to start looking for the sub-string from.
+* \returns the position the last instance of sub-string found, or -1 if not found.
+*/
+int String::findLast (const char* subString, int startingPosition) const
+{
+	modifyIndex(startingPosition);
+	for (; startingPosition > 0; startingPosition--)
+	{
+		if (strncmp (chars() + startingPosition, subString, strlen (subString)) == 0)
+			return startingPosition;
 	}
 	return -1;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Converts this string to an integer.
-int String::find (const char* c, int a) const
+* \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.
-	int pos = m_string.find (c, a);
+* \param base The base to interpret this string with.
+* \returns the resulting integer.
-	if (pos == int (std::string::npos))
+*/
-		return -1;
+long String::toInt (bool* ok, int base) const
-	return pos;
-}
-// -------------------------------------------------------------------------------------------------
-//
-int String::find (char ch, int a) const
-{
-	int pos = m_string.find (ch, a);
-	if (pos == int (std::string::npos))
-		return -1;
-	return pos;
-}
-// -------------------------------------------------------------------------------------------------
-//
-int String::find_last (const char* c, int a) const
-{
-	if (a == -1 or a >= length())
-		a = length() - 1;
-	for (; a > 0; a--)
-		if (m_string[a] == c[0] and strncmp (chars() + a, c, strlen (c)) == 0)
-			return a;
-	return -1;
-}
-// -------------------------------------------------------------------------------------------------
-//
-long String::to_int (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)
-		*ok = (errno == 0 and *endptr == '\0');
-	return i;
-}
-// -------------------------------------------------------------------------------------------------
-//
-float String::to_float (bool* ok) const
-{
-	errno = 0;
-	char* endptr;
-	float i = (float) strtod (chars(), &endptr);
 	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.
-double String::to_double (bool* ok) const
+* \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
+{
+	return static_cast<float>(toDouble(ok));
+}
+/*!
+* \brief Converts this string to a double-precision 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.
+*/
+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;
-//
+}
-bool String::is_numeric() const
-{
+/*!
-	char* endptr;
+* \returns whether or not this string represents a number.
-	strtol (chars(), &endptr, 10);
+*/
-	return not (endptr && *endptr);
+bool String::isNumeric() const
-}
+{
+	char* endPointer;
-// -------------------------------------------------------------------------------------------------
+	strtol (chars(), &endPointer, 10);
-//
+	return (endPointer != nullptr) and (*endPointer != '\0');
-bool String::ends_with (const String& other)
+}
+/*!
+* \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::starts_with (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.
-void String::vsprintf (const char* fmtstr, va_list args)
+* \param formatString Template string to use with formatting.
-{
+* \param args Variadic arguments to use with formatting.
-	char* buf = nullptr;
+*/
-	int bufsize = 256;
+void String::vsprintf (const char* formatString, va_list args)
+{
-	do
+	// Copy the argument list so that we have something to provide to vsnprintf in case we have to call it again.
-	{
+	va_list argsCopy;
-		bufsize *= 2;
+	va_copy(argsCopy, args);
-		delete[] buf;
-		buf = new char[bufsize];
+	// First, attempt to format using a fixed-size buffer.
-	}
+	static char buffer[1024];
-	while (vsnprintf (buf, bufsize, fmtstr, args) >= bufsize);
+	size_t length = vsnprintf(buffer, sizeof buffer, formatString, args);
-	m_string = buf;
+	if (length < sizeof buffer)
-	delete[] buf;
+	{
-}
+		// vsnprintf succeeded in fitting the formatted string into the buffer, so we're done.
+		m_string = buffer;
-// -------------------------------------------------------------------------------------------------
+	}
-//
+	else
-String StringList::join (const String& delim)
+	{
+		// vsnprintf needs more space, so we have to allocate a new buffer and try again.
+		Vector<char> newBuffer(length + 1);
+		vsnprintf(newBuffer.data(), length + 1, formatString, argsCopy);
+		m_string = newBuffer;
+	}
+}
+/*!
+* \brief Joins the elements of this string list into one longer string.
+* \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.is_empty() == false)
+		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
-bool String::mask_against (const String& pattern) const
+*        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.to_uppercase();
+	String pattern_upper = pattern.toUpperCase();
-	String this_upper = to_uppercase();
+	String this_upper = toUpperCase();
 	const char* maskstring = pattern_upper.chars();
 	const char* mptr = &maskstring[0];
 	for (const char* sptr = this_upper.chars(); *sptr != '\0'; sptr++)
 	{
 	}
 	return true;
 }
-// -------------------------------------------------------------------------------------------------
+/*!
-//
+* \brief Converts a short integer into a string.
-String String::from_number (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::from_number (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::from_number (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::from_number (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::from_number (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::from_number (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::from_number (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