feat(sourcepp): add more string helpers

Author: craftablescience

include/sourcepp/parser/Text.h

@@ -23,20 +23,41 @@ extern const std::unordered_map<char, char> NO_ESCAPE_SEQUENCES;
  */
 [[nodiscard]] bool isNewLine(char c);
 
+/**
+ * If a string is entirely composed of newline characters.
+ * @param str The string.
+ * @return The string is entirely composed of newline characters.
+ */
+[[nodiscard]] bool isNewLine(std::string_view str);
+
 /**
  * If a char is a whitespace character.
  * @param c The char.
  * @return The char is a whitespace character.
  */
 [[nodiscard]] bool isWhitespace(char c);
 
+/**
+ * If a string is entirely composed of whitespace characters.
+ * @param str The string.
+ * @return The string is entirely composed of whitespace characters.
+ */
+[[nodiscard]] bool isWhitespace(std::string_view str);
+
 /**
  * If a char is a numerical character (0-9).
  * @param c The char.
  * @return The char is a numerical character.
  */
 [[nodiscard]] bool isNumber(char c);
 
+/**
+ * If a string is entirely composed of numerical characters (0-9).
+ * @param str The string.
+ * @return The string is entirely composed of numerical characters.
+ */
+[[nodiscard]] bool isNumber(std::string_view str);
+
 /**
  * Eat all whitespace after the current stream position.
  * @param stream The BufferStream to modify.

include/sourcepp/string/String.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <charconv>
+#include <concepts>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -14,22 +16,38 @@ namespace sourcepp::string {
 
 void ltrim(std::string& s);
 
+[[nodiscard]] std::string_view ltrim(std::string_view s);
+
 void rtrim(std::string& s);
 
+[[nodiscard]] std::string_view rtrim(std::string_view s);
+
 void trim(std::string& s);
 
-void ltrim(std::string& s, std::string_view c);
+[[nodiscard]] std::string_view trim(std::string_view s);
+
+void ltrim(std::string& s, std::string_view chars);
+
+[[nodiscard]] std::string_view ltrim(std::string_view s, std::string_view chars);
+
+void rtrim(std::string& s, std::string_view chars);
 
-void rtrim(std::string& s, std::string_view c);
+[[nodiscard]] std::string_view rtrim(std::string_view s, std::string_view chars);
 
-void trim(std::string& s, std::string_view c);
+void trim(std::string& s, std::string_view chars);
+
+[[nodiscard]] std::string_view trim(std::string_view s, std::string_view chars);
 
 [[nodiscard]] std::vector<std::string> split(std::string_view s, char delim);
 
 void toLower(std::string& input);
 
+[[nodiscard]] std::string toLower(std::string_view input);
+
 void toUpper(std::string& input);
 
+[[nodiscard]] std::string toUpper(std::string_view input);
+
 [[nodiscard]] std::string createRandom(uint16_t length = 32, std::string_view chars = "0123456789_abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
 [[nodiscard]] std::string generateUUIDv4();
@@ -40,4 +58,18 @@ void normalizeSlashes(std::string& path, bool stripSlashPrefix = false, bool str
 
 void denormalizeSlashes(std::string& path, bool stripSlashPrefix = false, bool stripSlashSuffix = true);
 
+std::from_chars_result toInt(std::string_view number, std::integral auto& out, int base = 10) {
+	return std::from_chars(number.data(), number.data() + number.size(), out, base);
+}
+
+std::from_chars_result toFloat(std::string_view number, std::floating_point auto& out) {
+#ifdef __APPLE__
+	// Piece of shit compiler
+	out = std::stof(std::string{number});
+	return {number.data(), {}};
+#else
+	return std::from_chars(number.data(), number.data() + number.size(), out);
+#endif
+}
+
 } // namespace sourcepp::string

src/fgdpp/fgdpp.cpp

@@ -1,10 +1,8 @@
 #include <fgdpp/fgdpp.h>
 
 #include <algorithm>
-#include <charconv>
 #include <filesystem>
 #include <initializer_list>
-#include <utility>
 
 #include <BufferStream.h>
 
@@ -88,7 +86,7 @@ void readVersion(BufferStreamReadOnly& stream, BufferStream& backing, int& versi
 	}
 	std::string versionString{parser::text::readStringToBuffer(stream, backing, "(", ")", parser::text::NO_ESCAPE_SEQUENCES)};
 	string::trim(versionString);
-	version = std::stoi(versionString);
+	string::toInt(versionString, version);
 }
 
 void readMapSize(BufferStreamReadOnly& stream, BufferStream& backing, math::Vec2i& mapSize) {
@@ -106,8 +104,8 @@ void readMapSize(BufferStreamReadOnly& stream, BufferStream& backing, math::Vec2
 
 	string::trim(mapSizes[0]);
 	string::trim(mapSizes[1]);
-	mapSize.x = std::stoi(mapSizes[0]);
-	mapSize.y = std::stoi(mapSizes[1]);
+	string::toInt(mapSizes[0], mapSize.x);
+	string::toInt(mapSizes[1], mapSize.y);
 }
 
 void readMaterialExclusionDirs(BufferStreamReadOnly& stream, BufferStream& backing, std::vector<std::string_view>& materialExclusionDirs) {
@@ -290,7 +288,7 @@ void readEntityKeyValue(BufferStreamReadOnly& stream, BufferStream& backing, FGD
 		while (stream.peek<char>() != ']') {
 			auto& flag = field.flags.emplace_back();
 			auto valueString = ::readFGDString(stream, backing);
-			if (std::from_chars(valueString.data(), valueString.data() + valueString.size(), flag.value).ec != std::errc{}) {
+			if (string::toInt(valueString, flag.value).ec != std::errc{}) {
 				flag.value = 0;
 			}
 
@@ -304,7 +302,7 @@ void readEntityKeyValue(BufferStreamReadOnly& stream, BufferStream& backing, FGD
 			}
 			auto enabledByDefaultString = ::readFGDString(stream, backing);
 			int enabledByDefault = 0;
-			if (std::from_chars(enabledByDefaultString.data(), enabledByDefaultString.data() + enabledByDefaultString.size(), enabledByDefault).ec != std::errc{}) {
+			if (string::toInt(enabledByDefaultString, enabledByDefault).ec != std::errc{}) {
 				flag.enabledByDefault = false;
 			} else {
 				flag.enabledByDefault = static_cast<bool>(enabledByDefault);

src/sourcepp/parser/Text.cpp

@@ -31,14 +31,26 @@ bool parser::text::isNewLine(char c) {
 	return c == '\n' || c == '\r';
 }
 
+bool parser::text::isNewLine(std::string_view str) {
+	return std::all_of(str.begin(), str.end(), [](char c) { return isNewLine(c); });
+}
+
 bool parser::text::isWhitespace(char c) {
 	return c == ' ' || c == '\a' || c == '\f' || c == '\t' || c == '\v' || isNewLine(c);
 }
 
+bool parser::text::isWhitespace(std::string_view str) {
+	return std::all_of(str.begin(), str.end(), [](char c) { return isWhitespace(c); });
+}
+
 bool parser::text::isNumber(char c) {
 	return std::isdigit(c);
 }
 
+bool parser::text::isNumber(std::string_view str) {
+	return std::all_of(str.begin(), str.end(), [](char c) { return isNumber(c); });
+}
+
 void parser::text::eatWhitespace(BufferStream& stream) {
 	while (isWhitespace(stream.read<char>())) {}
 	stream.seek(-1, std::ios::cur);

src/sourcepp/string/String.cpp

@@ -21,30 +21,66 @@ void string::ltrim(std::string& s) {
     s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](char c) { return !std::isspace(c); }));
 }
 
+std::string_view string::ltrim(std::string_view s) {
+	while (!s.empty() && std::isspace(s[0])) {
+		s.remove_prefix(1);
+	}
+	return s;
+}
+
 void string::rtrim(std::string& s) {
     s.erase(std::find_if(s.rbegin(), s.rend(), [](char c) { return !std::isspace(c); }).base(), s.end());
 }
 
+std::string_view string::rtrim(std::string_view s) {
+	while (!s.empty() && std::isspace(s[s.size() - 1])) {
+		s.remove_suffix(1);
+	}
+	return s;
+}
+
 void string::trim(std::string& s) {
     rtrim(s);
     ltrim(s);
 }
 
+std::string_view string::trim(std::string_view s) {
+	return ltrim(rtrim(s));
+}
+
 void string::ltrim(std::string& s, std::string_view chars) {
 	s.erase(s.begin(), std::find_if(s.begin(), s.end(), [chars](char c) {
 		return !contains(chars, c);
 	}));
 }
 
+std::string_view string::ltrim(std::string_view s, std::string_view chars) {
+	while (!s.empty() && contains(chars, s[0])) {
+		s.remove_prefix(1);
+	}
+	return s;
+}
+
 void string::rtrim(std::string& s, std::string_view chars) {
 	s.erase(std::find_if(s.rbegin(), s.rend(), [chars](char c) {
 		return !contains(chars, c);
 	}).base(), s.end());
 }
 
-void string::trim(std::string& s, std::string_view c) {
-    rtrim(s, c);
-    ltrim(s, c);
+std::string_view string::rtrim(std::string_view s, std::string_view chars) {
+	while (!s.empty() && contains(chars, s[s.size() - 1])) {
+		s.remove_suffix(1);
+	}
+	return s;
+}
+
+void string::trim(std::string& s, std::string_view chars) {
+    rtrim(s, chars);
+    ltrim(s, chars);
+}
+
+std::string_view string::trim(std::string_view s, std::string_view chars) {
+	return ltrim(rtrim(s, chars), chars);
 }
 
 // https://stackoverflow.com/a/46931770
@@ -63,10 +99,22 @@ void string::toLower(std::string& input) {
 	std::transform(input.begin(), input.end(), input.begin(), [](unsigned char c){ return std::tolower(c); });
 }
 
+std::string string::toLower(std::string_view input) {
+	std::string out{input};
+	toLower(out);
+	return out;
+}
+
 void string::toUpper(std::string& input) {
 	std::transform(input.begin(), input.end(), input.begin(), [](unsigned char c){ return std::toupper(c); });
 }
 
+std::string string::toUpper(std::string_view input) {
+	std::string out{input};
+	toUpper(out);
+	return out;
+}
+
 std::string string::createRandom(uint16_t length, std::string_view chars) {
 	std::random_device random_device{};
 	std::mt19937 generator{random_device()};