Changed how the TryParse function works (and also did some general cleanup along the way)

dCommon/GeneralUtils.cpp

@@ -319,7 +319,3 @@ std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::stri
 
 	return sortedFiles;
 }
-
-bool GeneralUtils::TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst) {
-	return TryParse<float>(x.c_str(), dst.x) && TryParse<float>(y.c_str(), dst.y) && TryParse<float>(z.c_str(), dst.z);
-}

dCommon/GeneralUtils.h

@@ -1,11 +1,13 @@
 #pragma once
 
 // C++
+#include <charconv>
 #include <stdint.h>
 #include <random>
 #include <time.h>
 #include <string>
-#include <type_traits>
+#include <string_view>
+#include <optional>
 #include <functional>
 #include <type_traits>
 #include <stdexcept>
@@ -123,83 +125,105 @@ namespace GeneralUtils {
 
 	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string& folder);
 
+	// Concept constraining to enum types
 	template <typename T>
-	T Parse(const char* value);
+	concept Enum = std::is_enum_v<T>;
 
-	template <>
-	inline bool Parse(const char* value) {
-		return std::stoi(value);
+	// Concept constraining to numeric types
+	template <typename T>
+	concept Numeric = std::integral<T> || Enum<T> || std::floating_point<T>;
+
+	// Concept trickery to enable parsing underlying numeric types
+	template <Numeric T>
+	struct numeric_parse { using type = T; };
+
+	// If an enum, present an alias to its underlying type for parsing
+	template <Numeric T> requires Enum<T>
+	struct numeric_parse<T> { using type = std::underlying_type_t<T>; };
+
+	// If a boolean, present an alias to an integral type for parsing
+	template <Numeric T> requires std::same_as<T, bool>
+	struct numeric_parse<T> { using type = uint32_t; };
+
+	// Shorthand type alias
+	template <Numeric T>
+	using numeric_parse_t = numeric_parse<T>::type;
+
+	/**
+	 * For numeric values: Parses a C-style char range (string) and returns an optional variable depending on the result
+	 * @param str The pointer to the start of the char range (string)
+	 * @param strEnd The pointer to the end of the char range (string), defaults to NULL
+	 * @returns An std::optional containing the desired value if it exists in the string
+	*/
+	template <Numeric T>
+	[[nodiscard]] std::optional<T> TryParse(const char* const str, const char* const strEnd = NULL) {
+		numeric_parse_t<T> result;
+		const bool isParsed = std::from_chars(str, strEnd, result).ec == std::errc{};
+
+		return isParsed ? static_cast<T>(result) : std::optional<T>{};
 	}
 
-	template <>
-	inline int32_t Parse(const char* value) {
-		return std::stoi(value);
+	/**
+	 * For floating-point values: Parses a C-style char range (string) and returns an optional variable depending on the result
+	 * @param str The pointer to the start of the char range (string)
+	 * @param strEnd The pointer to the end of the char range (string), defaults to NULL
+	 * @returns An std::optional containing the desired value if it exists in the string
+	*/
+	/*template <std::floating_point T>
+	[[nodiscard]] std::optional<T> TryParse(const char* const str, const char* const strEnd = NULL) noexcept
+	try {
+		return std::make_optional<T>(std::stold(str));
+	} catch (...) {
+		return std::nullopt;
+	}*/
+
+	/**
+	 * The TryParse overload for std::string
+	 * @param str A constant reference to a std::string
+	 * @returns An std::optional containing the desired value if it exists in the string
+	*/
+	template <typename T>
+	[[nodiscard]] std::optional<T> TryParse(const std::string& str) {
+		return TryParse<T>(str.data(), str.data() + str.size());
 	}
 
-	template <>
-	inline int64_t Parse(const char* value) {
-		return std::stoll(value);
+	/**
+	 * The TryParse overload for std::string_view
+	 * @param str A constant value std::string_view passed by copy
+	 * @returns An std::optional containing the desired value if it exists in the string
+	*/
+	template <typename T>
+	[[nodiscard]] std::optional<T> TryParse(const std::string_view str) {
+		return TryParse<T>(str.data(), str.data() + str.size());
 	}
 
-	template <>
-	inline float Parse(const char* value) {
-		return std::stof(value);
+	/**
+	 * The TryParse overload for handling NiPoint3 by passing 3 seperate string references
+	 * @param strX The string representing the X coordinate
+	 * @param strY The string representing the Y coordinate
+	 * @param strZ The string representing the Z coordinate
+	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
+	*/
+	template <typename T>
+	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::string& strX, const std::string& strY, const std::string& strZ) {
+		const auto x = TryParse<float>(strX);
+		const auto y = TryParse<float>(strY);
+		const auto z = TryParse<float>(strZ);
+
+		return x && y && z ? std::make_optional<NiPoint3>(x.value(), y.value(), z.value()) : std::nullopt;
 	}
 
-	template <>
-	inline double Parse(const char* value) {
-		return std::stod(value);
-	}
-
-	template <>
-	inline uint16_t Parse(const char* value) {
-		return std::stoul(value);
-	}
-
-	template <>
-	inline uint32_t Parse(const char* value) {
-		return std::stoul(value);
-	}
-
-	template <>
-	inline uint64_t Parse(const char* value) {
-		return std::stoull(value);
-	}
-
-	template <>
-	inline eInventoryType Parse(const char* value) {
-		return static_cast<eInventoryType>(std::stoul(value));
-	}
-
-	template <>
-	inline eReplicaComponentType Parse(const char* value) {
-		return static_cast<eReplicaComponentType>(std::stoul(value));
+	/**
+	 * The TryParse overload for handling NiPoint3 by passingn a reference to a vector of three strings
+	 * @param str The string vector representing the X, Y, and Xcoordinates
+	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
+	*/
+	template <typename T>
+	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::vector<std::string>& str) {
+		return TryParse<NiPoint3>(str.at(0), str.at(1), str.at(2));
 	}
 
 	template <typename T>
-	bool TryParse(const char* value, T& dst) {
-		try {
-			dst = Parse<T>(value);
-
-			return true;
-		} catch (...) {
-			return false;
-		}
-	}
-
-	template <typename T>
-	T Parse(const std::string& value) {
-		return Parse<T>(value.c_str());
-	}
-
-	template <typename T>
-	bool TryParse(const std::string& value, T& dst) {
-		return TryParse<T>(value.c_str(), dst);
-	}
-
-	bool TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst);
-
-	template<typename T>
 	std::u16string to_u16string(T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));
 	}
@@ -239,10 +263,8 @@ namespace GeneralUtils {
 	 * @param entry Enum entry to cast
 	 * @returns The enum entry's value in its underlying type
 	*/
-	template <typename eType>
-	inline constexpr typename std::underlying_type_t<eType> CastUnderlyingType(const eType entry) {
-		static_assert(std::is_enum_v<eType>, "Not an enum");
-
+	template <Enum eType>
+	constexpr typename std::underlying_type_t<eType> CastUnderlyingType(const eType entry) {
 		return static_cast<typename std::underlying_type_t<eType>>(entry);
 	}
 

dCommon/LDFFormat.cpp

@@ -61,33 +61,33 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	}
 
 	case LDF_TYPE_S32: {
-		int32_t data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
+		const auto data = GeneralUtils::TryParse<int32_t>(ldfTypeAndValue.second);
+		if (!data) {
 			LOG("Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<int32_t>(key, data);
+		returnValue = new LDFData<int32_t>(key, data.value());
 
 		break;
 	}
 
 	case LDF_TYPE_FLOAT: {
-		float data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
+		const auto data = GeneralUtils::TryParse<float>(ldfTypeAndValue.second);
+		if (!data) {
 			LOG("Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<float>(key, data);
+		returnValue = new LDFData<float>(key, data.value());
 		break;
 	}
 
 	case LDF_TYPE_DOUBLE: {
-		double data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
+		const auto data = GeneralUtils::TryParse<double>(ldfTypeAndValue.second);
+		if (!data) {
 			LOG("Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<double>(key, data);
+		returnValue = new LDFData<double>(key, data.value());
 		break;
 	}
 
@@ -100,10 +100,12 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 		} else if (ldfTypeAndValue.second == "false") {
 			data = 0;
 		} else {
-			if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
+			const auto dataOptional = GeneralUtils::TryParse<uint32_t>(ldfTypeAndValue.second);
+			if (!dataOptional) {
 				LOG("Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 				return nullptr;
 			}
+			data = dataOptional.value();
 		}
 
 		returnValue = new LDFData<uint32_t>(key, data);
@@ -118,10 +120,12 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 		} else if (ldfTypeAndValue.second == "false") {
 			data = false;
 		} else {
-			if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
+			const auto dataOptional = GeneralUtils::TryParse<bool>(ldfTypeAndValue.second);
+			if (!dataOptional) {
 				LOG("Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 				return nullptr;
 			}
+			data = dataOptional.value();
 		}
 
 		returnValue = new LDFData<bool>(key, data);
@@ -129,22 +133,22 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	}
 
 	case LDF_TYPE_U64: {
-		uint64_t data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
+		const auto data = GeneralUtils::TryParse<uint64_t>(ldfTypeAndValue.second);
+		if (!data) {
 			LOG("Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<uint64_t>(key, data);
+		returnValue = new LDFData<uint64_t>(key, data.value());
 		break;
 	}
 
 	case LDF_TYPE_OBJID: {
-		LWOOBJID data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
+		const auto data = GeneralUtils::TryParse<LWOOBJID>(ldfTypeAndValue.second);
+		if (!data) {
 			LOG("Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<LWOOBJID>(key, data);
+		returnValue = new LDFData<LWOOBJID>(key, data.value());
 		break;
 	}
 

dCommon/LDFFormat.h

@@ -162,7 +162,7 @@ public:
 		return new LDFData<T>(key, value);
 	}
 
-	inline static T Default = {};
+	inline static const T Default = {};
 };
 
 // LDF Types

dCommon/dEnums/dCommonVars.h

@@ -39,49 +39,49 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 
 //=========== TYPEDEFS ==========
 
-typedef int32_t LOT;                        //!< A LOT
-typedef int64_t LWOOBJID;                   //!< An object ID (should be unsigned actually but ok)
-typedef int32_t TSkillID;                   //!< A skill ID
-typedef uint32_t LWOCLONEID;                 //!< Used for Clone IDs
-typedef uint16_t LWOMAPID;                   //!< Used for Map IDs
-typedef uint16_t LWOINSTANCEID;              //!< Used for Instance IDs
-typedef uint32_t PROPERTYCLONELIST;          //!< Used for Property Clone IDs
-typedef uint32_t StripId;
+using LOT = int32_t;                        //!< A LOT
+using LWOOBJID = int64_t;                   //!< An object ID (should be unsigned actually but ok)
+using TSkillID = int32_t;                   //!< A skill ID
+using LWOCLONEID = uint32_t;                 //!< Used for Clone IDs
+using LWOMAPID = uint16_t;                   //!< Used for Map IDs
+using LWOINSTANCEID = uint16_t;              //!< Used for Instance IDs
+using PROPERTYCLONELIST = uint32_t;          //!< Used for Property Clone IDs
+using StripId = uint32_t;
 
-const LWOOBJID LWOOBJID_EMPTY = 0;          //!< An empty object ID
-const LOT LOT_NULL = -1;                    //!< A null LOT
-const int32_t LOOTTYPE_NONE = 0;            //!< No loot type available
-const float SECONDARY_PRIORITY = 1.0f;      //!< Secondary Priority
-const uint32_t INVENTORY_MAX = 9999999;     //!< The Maximum Inventory Size
-const uint32_t LWOCLONEID_INVALID = -1;     //!< Invalid LWOCLONEID
-const uint16_t LWOINSTANCEID_INVALID = -1;  //!< Invalid LWOINSTANCEID
-const uint16_t LWOMAPID_INVALID = -1;       //!< Invalid LWOMAPID
-const uint64_t LWOZONEID_INVALID = 0;       //!< Invalid LWOZONEID
+constexpr LWOOBJID LWOOBJID_EMPTY = 0;          	//!< An empty object ID
+constexpr LOT LOT_NULL = -1;                    	//!< A null LOT
+constexpr int32_t LOOTTYPE_NONE = 0;            	//!< No loot type available
+constexpr float SECONDARY_PRIORITY = 1.0f;      	//!< Secondary Priority
+constexpr uint32_t INVENTORY_MAX = 9999999;     	//!< The Maximum Inventory Size
+constexpr LWOCLONEID LWOCLONEID_INVALID = -1;     	//!< Invalid LWOCLONEID
+constexpr LWOINSTANCEID LWOINSTANCEID_INVALID = -1; //!< Invalid LWOINSTANCEID
+constexpr LWOMAPID LWOMAPID_INVALID = -1;       	//!< Invalid LWOMAPID
+constexpr uint64_t LWOZONEID_INVALID = 0;       	//!< Invalid LWOZONEID
 
-const float PI = 3.14159f;
+constexpr float PI = 3.14159f;
 
 //============ STRUCTS ==============
 
 struct LWOSCENEID {
 public:
-	LWOSCENEID() { m_sceneID = -1; m_layerID = 0; }
-	LWOSCENEID(int sceneID) { m_sceneID = sceneID; m_layerID = 0; }
-	LWOSCENEID(int sceneID, unsigned int layerID) { m_sceneID = sceneID; m_layerID = layerID; }
+	constexpr LWOSCENEID() noexcept { m_sceneID = -1; m_layerID = 0; }
+	constexpr LWOSCENEID(int sceneID) noexcept { m_sceneID = sceneID; m_layerID = 0; }
+	constexpr LWOSCENEID(int sceneID, unsigned int layerID) noexcept { m_sceneID = sceneID; m_layerID = layerID; }
 
-	LWOSCENEID& operator=(const LWOSCENEID& rhs) { m_sceneID = rhs.m_sceneID; m_layerID = rhs.m_layerID; return *this; }
-	LWOSCENEID& operator=(const int rhs) { m_sceneID = rhs; m_layerID = 0; return *this; }
+	constexpr LWOSCENEID& operator=(const LWOSCENEID& rhs) noexcept { m_sceneID = rhs.m_sceneID; m_layerID = rhs.m_layerID; return *this; }
+	constexpr LWOSCENEID& operator=(const int rhs) noexcept { m_sceneID = rhs; m_layerID = 0; return *this; }
 
-	bool operator<(const LWOSCENEID& rhs) const { return (m_sceneID < rhs.m_sceneID || (m_sceneID == rhs.m_sceneID && m_layerID < rhs.m_layerID)); }
-	bool operator<(const int rhs) const { return m_sceneID < rhs; }
+	constexpr bool operator<(const LWOSCENEID& rhs) const noexcept { return (m_sceneID < rhs.m_sceneID || (m_sceneID == rhs.m_sceneID && m_layerID < rhs.m_layerID)); }
+	constexpr bool operator<(const int rhs) const noexcept { return m_sceneID < rhs; }
 
-	bool operator==(const LWOSCENEID& rhs) const { return (m_sceneID == rhs.m_sceneID && m_layerID == rhs.m_layerID); }
-	bool operator==(const int rhs) const { return m_sceneID == rhs; }
+	constexpr bool operator==(const LWOSCENEID& rhs) const noexcept { return (m_sceneID == rhs.m_sceneID && m_layerID == rhs.m_layerID); }
+	constexpr bool operator==(const int rhs) const noexcept { return m_sceneID == rhs; }
 
-	const int GetSceneID() const { return m_sceneID; }
-	const unsigned int GetLayerID() const { return m_layerID; }
+	constexpr int GetSceneID() const noexcept { return m_sceneID; }
+	constexpr unsigned int GetLayerID() const noexcept { return m_layerID; }
 
-	void SetSceneID(const int sceneID) { m_sceneID = sceneID; }
-	void SetLayerID(const unsigned int layerID) { m_layerID = layerID; }
+	constexpr void SetSceneID(const int sceneID) noexcept { m_sceneID = sceneID; }
+	constexpr void SetLayerID(const unsigned int layerID) noexcept { m_layerID = layerID; }
 
 private:
 	int m_sceneID;
@@ -90,14 +90,14 @@ private:
 
 struct LWOZONEID {
 public:
-	const LWOMAPID& GetMapID() const { return m_MapID; }
-	const LWOINSTANCEID& GetInstanceID() const { return m_InstanceID; }
-	const LWOCLONEID& GetCloneID() const { return m_CloneID; }
+	constexpr const LWOMAPID& GetMapID() const noexcept { return m_MapID; }
+	constexpr const LWOINSTANCEID& GetInstanceID() const noexcept { return m_InstanceID; }
+	constexpr const LWOCLONEID& GetCloneID() const noexcept { return m_CloneID; }
 
 	//In order: def constr, constr, assign op
-	LWOZONEID() { m_MapID = LWOMAPID_INVALID; m_InstanceID = LWOINSTANCEID_INVALID; m_CloneID = LWOCLONEID_INVALID; }
-	LWOZONEID(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) { m_MapID = mapID; m_InstanceID = instanceID; m_CloneID = cloneID; }
-	LWOZONEID(const LWOZONEID& replacement) { *this = replacement; }
+	constexpr LWOZONEID() noexcept { m_MapID = LWOMAPID_INVALID; m_InstanceID = LWOINSTANCEID_INVALID; m_CloneID = LWOCLONEID_INVALID; }
+	constexpr LWOZONEID(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) noexcept { m_MapID = mapID; m_InstanceID = instanceID; m_CloneID = cloneID; }
+	constexpr LWOZONEID(const LWOZONEID& replacement) noexcept { *this = replacement; }
 
 private:
 	LWOMAPID m_MapID; //1000 for VE, 1100 for AG, etc...
@@ -105,20 +105,20 @@ private:
 	LWOCLONEID m_CloneID; //To differentiate between "your property" and "my property". Always 0 for non-prop worlds.
 };
 
-const LWOSCENEID LWOSCENEID_INVALID = -1;
+constexpr LWOSCENEID LWOSCENEID_INVALID = -1;
 
 struct LWONameValue {
 	uint32_t length = 0;        //!< The length of the name
 	std::u16string name;			//!< The name
 
-	LWONameValue(void) {}
+	LWONameValue() = default;
 
 	LWONameValue(const std::u16string& name) {
 		this->name = name;
 		this->length = static_cast<uint32_t>(name.length());
 	}
 
-	~LWONameValue(void) {}
+	~LWONameValue() = default;
 };
 
 struct FriendData {