Core/ParameterList: Rework Parameter getter using Result

examples/Showcase/main.cpp

@@ -115,9 +115,7 @@ int main()
 	std::vector<std::shared_ptr<Nz::Material>> materials(bobMesh->GetMaterialCount());
 	for (std::size_t i = 0; i < bobMesh->GetMaterialCount(); ++i)
 	{
-		std::string matPath;
+		std::string matPath = bobMesh->GetMaterialData(i).GetStringParameter(Nz::MaterialData::BaseColorTexturePath).GetValueOr("");
-		bobMesh->GetMaterialData(i).GetStringParameter(Nz::MaterialData::BaseColorTexturePath, &matPath);
-
 		if (!matPath.empty())
 			materials[i] = Nz::Material::LoadFromFile(matPath);
 	}

include/Nazara/Core/ParameterList.hpp

@@ -10,6 +10,7 @@
 #include <Nazara/Prerequisites.hpp>
 #include <Nazara/Core/Color.hpp>
 #include <Nazara/Utils/MovablePtr.hpp>
+#include <Nazara/Utils/Result.hpp>
 #include <atomic>
 #include <string>
 #include <unordered_map>
@@ -20,6 +21,7 @@ namespace Nz
 	{
 		public:
 			using Destructor = void (*)(void* value);
+			enum class Error;
 
 			ParameterList() = default;
 			ParameterList(const ParameterList& list);
@@ -31,14 +33,15 @@ namespace Nz
 			inline void ForEach(const std::function<bool(const ParameterList& list, const std::string& name)>& callback);
 			inline void ForEach(const std::function<void(const ParameterList& list, const std::string& name)>& callback) const;
 
-			bool GetBooleanParameter(const std::string& name, bool* value) const;
+			Result<bool, Error> GetBooleanParameter(const std::string& name, bool strict = true) const;
-			bool GetColorParameter(const std::string& name, Color* value) const;
+			Result<Color, Error> GetColorParameter(const std::string& name, bool strict = true) const;
-			bool GetDoubleParameter(const std::string& name, double* value) const;
+			Result<double, Error> GetDoubleParameter(const std::string& name, bool strict = true) const;
-			bool GetIntegerParameter(const std::string& name, long long* value) const;
+			Result<long long, Error> GetIntegerParameter(const std::string& name, bool strict = true) const;
-			bool GetParameterType(const std::string& name, ParameterType* type) const;
+			Result<ParameterType, Error> GetParameterType(const std::string& name) const;
-			bool GetPointerParameter(const std::string& name, void** value) const;
+			Result<void*, Error> GetPointerParameter(const std::string& name, bool strict = true) const;
-			bool GetStringParameter(const std::string& name, std::string* value) const;
+			Result<std::string, Error> GetStringParameter(const std::string& name, bool strict = true) const;
-			bool GetUserdataParameter(const std::string& name, void** value) const;
+			Result<std::string_view, Error> GetStringViewParameter(const std::string& name, bool strict = true) const;
+			Result<void*, Error> GetUserdataParameter(const std::string& name, bool strict = true) const;
 
 			bool HasParameter(const std::string& name) const;
 
@@ -59,6 +62,14 @@ namespace Nz
 			ParameterList& operator=(const ParameterList& list);
 			ParameterList& operator=(ParameterList&&) = default;
 
+			enum class Error
+			{
+				ConversionFailed,
+				MissingValue,
+				WouldRequireConversion,
+				WrongType
+			};
+
 		private:
 			struct Parameter
 			{

plugins/Assimp/Plugin.cpp

@@ -775,14 +775,9 @@ Nz::Result<std::shared_ptr<Nz::Mesh>, Nz::ResourceLoadingError> LoadMesh(Nz::Str
 	if (parameters.optimizeIndexBuffers)
 		postProcess |= aiProcess_ImproveCacheLocality;
 
-	double smoothingAngle = 80.f;
+	double smoothingAngle = parameters.custom.GetDoubleParameter("AssimpLoader_SmoothingAngle").GetValueOr(80.0);
-	parameters.custom.GetDoubleParameter("AssimpLoader_SmoothingAngle", &smoothingAngle);
+	long long triangleLimit = parameters.custom.GetIntegerParameter("AssimpLoader_TriangleLimit").GetValueOr(1'000'000);
-
+	long long vertexLimit = parameters.custom.GetIntegerParameter("AssimpLoader_VertexLimit").GetValueOr(1'000'000);
-	long long triangleLimit = 1'000'000;
-	parameters.custom.GetIntegerParameter("AssimpLoader_TriangleLimit", &triangleLimit);
-
-	long long vertexLimit   = 1'000'000;
-	parameters.custom.GetIntegerParameter("AssimpLoader_VertexLimit", &vertexLimit);
 
 	int excludedComponents = 0;
 
@@ -879,8 +874,7 @@ namespace
 				animationLoaderEntry.streamLoader = LoadAnimation;
 				animationLoaderEntry.parameterFilter = [](const Nz::AnimationParams& parameters)
 				{
-					bool skip;
+					if (auto result = parameters.custom.GetBooleanParameter("SkipAssimpLoader"); result.GetValueOr(false))
-					if (parameters.custom.GetBooleanParameter("SkipAssimpLoader", &skip) && skip)
 						return false;
 
 					return true;
@@ -894,8 +888,7 @@ namespace
 				meshLoaderEntry.streamLoader = LoadMesh;
 				meshLoaderEntry.parameterFilter = [](const Nz::MeshParams& parameters)
 				{
-					bool skip;
+					if (auto result = parameters.custom.GetBooleanParameter("SkipAssimpLoader"); result.GetValueOr(false))
-					if (parameters.custom.GetBooleanParameter("SkipAssimpLoader", &skip) && skip)
 						return false;
 
 					return true;
@@ -910,7 +903,7 @@ namespace
 			void Deactivate() override
 			{
 				Nz::Utility* utility = Nz::Utility::Instance();
-				NazaraAssert(utility, "utility module is not instancied");
+				NazaraAssert(utility, "utility module is not instanced");
 
 				Nz::AnimationLoader& animationLoader = utility->GetAnimationLoader();
 				animationLoader.UnregisterLoader(m_animationLoaderEntry);

plugins/FFmpeg/Plugin.cpp

@@ -443,8 +443,7 @@ namespace
 				loaderEntry.streamLoader = LoadStream;
 				loaderEntry.parameterFilter = [](const Nz::ImageStreamParams& parameters)
 				{
-					bool skip;
+					if (auto result = parameters.custom.GetBooleanParameter("SkipFFMpegLoader"); result.GetValueOr(false))
-					if (parameters.custom.GetBooleanParameter("SkipFFMpegLoader", &skip) && skip)
 						return false;
 
 					return true;
@@ -459,7 +458,7 @@ namespace
 			void Deactivate() override
 			{
 				Nz::Utility* utility = Nz::Utility::Instance();
-				NazaraAssert(utility, "utility module is not instancied");
+				NazaraAssert(utility, "utility module is not instanced");
 
 				Nz::ImageStreamLoader& imageStreamLoader = utility->GetImageStreamLoader();
 				imageStreamLoader.UnregisterLoader(m_ffmpegLoaderEntry);

src/Nazara/Audio/Formats/drwavLoader.cpp

@@ -271,8 +271,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadWavSoundBuffer;
 			loaderEntry.parameterFilter = [](const SoundBufferParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinWavLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinWavLoader", &skip) && skip)
 					return false;
 
 				return true;
@@ -290,8 +289,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadWavSoundStreamStream;
 			loaderEntry.parameterFilter = [](const SoundStreamParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinWavLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinWavLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Audio/Formats/libflacLoader.cpp

@@ -520,8 +520,7 @@ namespace Nz
 			loaderEntry.streamLoader     = LoadFlacSoundBuffer;
 			loaderEntry.parameterFilter  = [](const SoundBufferParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinFlacLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinFlacLoader", &skip) && skip)
 					return false;
 
 				return true;
@@ -539,8 +538,7 @@ namespace Nz
 			loaderEntry.streamLoader     = LoadFlacSoundStreamStream;
 			loaderEntry.parameterFilter  = [](const SoundStreamParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinFlacLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinFlacLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Audio/Formats/libvorbisLoader.cpp

@@ -360,8 +360,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadVorbisSoundBuffer;
 			loaderEntry.parameterFilter = [](const SoundBufferParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinVorbisLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinVorbisLoader", &skip) && skip)
 					return false;
 
 				return true;
@@ -379,8 +378,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadVorbisSoundStreamStream;
 			loaderEntry.parameterFilter = [](const SoundStreamParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinVorbisLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinVorbisLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Audio/Formats/minimp3Loader.cpp

@@ -316,8 +316,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadMP3SoundBuffer;
 			loaderEntry.parameterFilter = [](const SoundBufferParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinMP3Loader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinMP3Loader", &skip) && skip)
 					return false;
 
 				return true;
@@ -335,8 +334,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadMP3SoundStreamStream;
 			loaderEntry.parameterFilter = [](const SoundStreamParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinMP3Loader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinMP3Loader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Core/ParameterList.cpp

@@ -4,7 +4,6 @@
 
 #include <Nazara/Core/ParameterList.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/StringExt.hpp>
 #include <Nazara/Utils/MemoryHelper.hpp>
 #include <cstring>
@@ -47,54 +46,43 @@ namespace Nz
 
 	/*!
 	* \brief Gets a parameter as a boolean
-	* \return true if the parameter could be represented as a boolean
+	* \return result containing the value or an error
 	*
 	* \param name Name of the parameter
-	* \param value Pointer to a boolean to hold the retrieved value
+	* \param strict If true, prevent conversions from compatible types
 	*
-	* \remark value must be a valid pointer
+	* \remark If the parameter is not a boolean, a conversion may be performed if strict parameter is set to false, compatibles types are:
-	* \remark In case of failure, the variable pointed by value keep its value
-	* \remark If the parameter is not a boolean, a conversion will be performed, compatibles types are:
 	          Integer: 0 is interpreted as false, any other value is interpreted as true
 	          std::string:  Conversion obeys the rule as described by std::string::ToBool
 	*/
-	bool ParameterList::GetBooleanParameter(const std::string& name, bool* value) const
+	auto ParameterList::GetBooleanParameter(const std::string& name, bool strict) const -> Result<bool, Error>
 	{
-		NazaraAssert(value, "Invalid pointer");
-
-		ErrorFlags flags(ErrorMode::Silent | ErrorMode::ThrowExceptionDisabled);
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-		{
+			return Err(Error::MissingValue);
-			NazaraError("Parameter \"" + name + "\" is not present");
-			return false;
-		}
 
 		switch (it->second.type)
 		{
 			case ParameterType::Boolean:
-				*value = it->second.value.boolVal;
+				return it->second.value.boolVal;
-				return true;
 
 			case ParameterType::Integer:
-				*value = (it->second.value.intVal != 0);
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return (it->second.value.intVal != 0);
 
 			case ParameterType::String:
 			{
-				if (it->second.value.stringVal == "1" || it->second.value.stringVal == "yes" || it->second.value.stringVal == "true")
+				if (strict)
-				{
+					return Err(Error::WouldRequireConversion);
-					*value = true;
-					return true;
-				}
-				else if (it->second.value.stringVal == "0" || it->second.value.stringVal == "no" || it->second.value.stringVal == "false")
-				{
-					*value = false;
-					return true;
-				}
 
-				break;
+				if (it->second.value.stringVal == "1" || it->second.value.stringVal == "yes" || it->second.value.stringVal == "true")
+					return true;
+				else if (it->second.value.stringVal == "0" || it->second.value.stringVal == "no" || it->second.value.stringVal == "false")
+					return false;
+
+				return Err(Error::ConversionFailed);
 			}
 
 			case ParameterType::Color:
@@ -105,39 +93,28 @@ namespace Nz
 				break;
 		}
 
-		NazaraError("Parameter value is not representable as a boolean");
+		return Err(Error::WrongType);
-		return false;
 	}
 
 	/*!
 	* \brief Gets a parameter as a color
-	* \return true if the parameter could be represented as a color
+	* \return result containing the value or an error
 	*
 	* \param name Name of the parameter
-	* \param value Pointer to a color to hold the retrieved value
+	* \param strict If true, prevent conversions from compatible types
 	*
-	* \remark value must be a valid pointer
-	* \remark In case of failure, the variable pointed by value keep its value
 	* \remark If the parameter is not a color, the function fails
 	*/
-	bool ParameterList::GetColorParameter(const std::string& name, Color* value) const
+	auto ParameterList::GetColorParameter(const std::string& name, bool /*strict*/) const -> Result<Color, Error>
 	{
-		NazaraAssert(value, "Invalid pointer");
-
-		ErrorFlags flags(ErrorMode::Silent | ErrorMode::ThrowExceptionDisabled);
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-		{
+			return Err(Error::MissingValue);
-			NazaraError("Parameter \"" + name + "\" is not present");
-			return false;
-		}
 
 		switch (it->second.type)
 		{
 			case ParameterType::Color:
-				*value = it->second.value.colorVal;
+				return it->second.value.colorVal;
-				return true;
 
 			case ParameterType::Boolean:
 			case ParameterType::Double:
@@ -149,48 +126,42 @@ namespace Nz
 				break;
 		}
 
-		NazaraError("Parameter value is not representable as a color");
+		return Err(Error::WrongType);
-		return false;
 	}
 
 	/*!
 	* \brief Gets a parameter as a double
-	* \return true if the parameter could be represented as a double
+	* \return result containing the value or an error
 	*
 	* \param name Name of the parameter
-	* \param value Pointer to a double to hold the retrieved value
+	* \param strict If true, prevent conversions from compatible types
 	*
-	* \remark value must be a valid pointer
+	* \remark If the parameter is not a double, a conversion may be performed if strict parameter is set to false, compatibles types are:
-	* \remark In case of failure, the variable pointed by value keep its value
-	* \remark If the parameter is not a double, a conversion will be performed, compatibles types are:
 	          Integer: The integer value is converted to its double representation
 	          std::string:  Conversion obeys the rule as described by std::string::ToDouble
 	*/
-	bool ParameterList::GetDoubleParameter(const std::string& name, double* value) const
+	auto ParameterList::GetDoubleParameter(const std::string& name, bool strict) const -> Result<double, Error>
 	{
-		NazaraAssert(value, "Invalid pointer");
-
-		ErrorFlags flags(ErrorMode::Silent | ErrorMode::ThrowExceptionDisabled);
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-		{
+			return Err(Error::MissingValue);
-			NazaraError("Parameter \"" + name + "\" is not present");
-			return false;
-		}
 
 		switch (it->second.type)
 		{
 			case ParameterType::Double:
-				*value = it->second.value.doubleVal;
+				return it->second.value.doubleVal;
-				return true;
 
 			case ParameterType::Integer:
-				*value = static_cast<double>(it->second.value.intVal);
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return static_cast<double>(it->second.value.intVal);
 
 			case ParameterType::String:
 			{
+				if (strict)
+					return Err(Error::WouldRequireConversion);
+
 				const std::string& str = it->second.value.stringVal;
 
 				int& err = errno;
@@ -202,8 +173,7 @@ namespace Nz
 				if (str.data() == endStr || err == ERANGE)
 					break;
 
-				*value = ret;
+				return ret;
-				return true;
 			}
 
 			case ParameterType::Boolean:
@@ -214,53 +184,49 @@ namespace Nz
 				break;
 		}
 
-		NazaraError("Parameter value is not representable as a double");
+		return Err(Error::WrongType);
-		return false;
 	}
 
 	/*!
 	* \brief Gets a parameter as an integer
-	* \return true if the parameter could be represented as an integer
+	* \return result containing the value or an error
 	*
 	* \param name Name of the parameter
-	* \param value Pointer to an integer to hold the retrieved value
+	* \param strict If true, prevent conversions from compatible types
 	*
-	* \remark value must be a valid pointer
+	* \remark If the parameter is not an integer, a conversion may be performed if strict parameter is set to false, compatibles types are:
-	* \remark In case of failure, the variable pointed by value keep its value
-	* \remark If the parameter is not an integer, a conversion will be performed, compatibles types are:
 	          Boolean: The boolean is represented as 1 if true and 0 if false
 	          Double:  The floating-point value is truncated and converted to a integer
 	          std::string:  Conversion obeys the rule as described by std::string::ToInteger
 	*/
-	bool ParameterList::GetIntegerParameter(const std::string& name, long long* value) const
+	auto ParameterList::GetIntegerParameter(const std::string& name, bool strict) const -> Result<long long, Error>
 	{
-		NazaraAssert(value, "Invalid pointer");
-
-		ErrorFlags flags(ErrorMode::Silent | ErrorMode::ThrowExceptionDisabled);
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-		{
+			return Err(Error::MissingValue);
-			NazaraError("Parameter \"" + name + "\" is not present");
-			return false;
-		}
 
 		switch (it->second.type)
 		{
 			case ParameterType::Boolean:
-				*value = (it->second.value.boolVal) ? 1 : 0;
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return (it->second.value.boolVal) ? 1LL : 0LL;
 
 			case ParameterType::Double:
-				*value = static_cast<long long>(it->second.value.doubleVal);
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return static_cast<long long>(it->second.value.doubleVal);
 
 			case ParameterType::Integer:
-				*value = it->second.value.intVal;
+				return it->second.value.intVal;
-				return true;
 
 			case ParameterType::String:
 			{
+				if (strict)
+					return Err(Error::WouldRequireConversion);
+
 				const std::string& str = it->second.value.stringVal;
 
 				int& err = errno;
@@ -272,8 +238,7 @@ namespace Nz
 				if (str.data() == endStr || err == ERANGE)
 					break;
 
-				*value = ret;
+				return ret;
-				return true;
 			}
 
 			case ParameterType::Color:
@@ -283,66 +248,52 @@ namespace Nz
 				break;
 		}
 
-		NazaraError("Parameter value is not representable as a integer");
+		return Err(Error::WrongType);
-		return false;
 	}
 
 	/*!
 	* \brief Gets a parameter type
-	* \return true if the parameter is present, its type being written to type
+	* \return result containing the parameter type or an error
 	*
 	* \param name Name of the variable
-	* \param type Pointer to a variable to hold the result
 	*
 	* \remark type must be a valid pointer to a ParameterType variable
 	*/
-	bool ParameterList::GetParameterType(const std::string& name, ParameterType* type) const
+	auto ParameterList::GetParameterType(const std::string& name) const -> Result<ParameterType, Error>
 	{
-		NazaraAssert(type, "Invalid pointer");
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-			return false;
+			return Err(Error::MissingValue);
 
-		*type = it->second.type;
+		return it->second.type;
-
-		return true;
 	}
 
 	/*!
 	* \brief Gets a parameter as a pointer
-	* \return true if the parameter could be represented as a pointer
+	* \return result containing the value or an error
 	*
 	* \param name Name of the parameter
-	* \param value Pointer to a pointer to hold the retrieved value
+	* \param strict If true, prevent conversions from compatible types
 	*
-	* \remark value must be a valid pointer
+	* \remark If the parameter is not a pointer, a conversion may be performed if strict parameter is set to false, compatibles types are:
-	* \remark In case of failure, the variable pointed by value keep its value
-	* \remark If the parameter is not a pointer, a conversion will be performed, compatibles types are:
 	          Userdata: The pointer part of the userdata is returned
 	*/
-	bool ParameterList::GetPointerParameter(const std::string& name, void** value) const
+	auto ParameterList::GetPointerParameter(const std::string& name, bool strict) const -> Result<void*, Error>
 	{
-		NazaraAssert(value, "Invalid pointer");
-
-		ErrorFlags flags(ErrorMode::Silent | ErrorMode::ThrowExceptionDisabled);
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-		{
+			return Err(Error::MissingValue);
-			NazaraError("Parameter \"" + name + "\" is not present");
-			return false;
-		}
 
 		switch (it->second.type)
 		{
 			case ParameterType::Pointer:
-				*value = it->second.value.ptrVal;
+				return it->second.value.ptrVal;
-				return true;
 
 			case ParameterType::Userdata:
-				*value = it->second.value.userdataVal->ptr;
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return it->second.value.userdataVal->ptr.Get();
 
 			case ParameterType::Boolean:
 			case ParameterType::Color:
@@ -353,118 +304,150 @@ namespace Nz
 				break;
 		}
 
-		NazaraError("Parameter value is not a pointer");
+		return Err(Error::WrongType);
-		return false;
 	}
 
 	/*!
 	* \brief Gets a parameter as a string
-	* \return true if the parameter could be represented as a string
+	* \return result containing the value or an error
 	*
 	* \param name Name of the parameter
-	* \param value Pointer to a pointer to hold the retrieved value
+	* \param strict If true, prevent conversions from compatible types
 	*
-	* \remark value must be a valid pointer
+	* \remark If the parameter is not a string, a conversion may be performed if strict parameter is set to false, all types are compatibles:
-	* \remark In case of failure, the variable pointed by value keep its value
+	          Boolean:  Returns "true" or "false" as a string
-	* \remark If the parameter is not a string, a conversion will be performed, all types are compatibles:
-	          Boolean:  Conversion obeys the rules of std::string::Boolean
 	          Color:    Conversion obeys the rules of Color::ToString
-	          Double:   Conversion obeys the rules of std::string::Number
+	          Double:   Conversion obeys the rules of std::to_string
-	          Integer:  Conversion obeys the rules of std::string::Number
+	          Integer:  Conversion obeys the rules of std::to_string
 	          None:     An empty string is returned
 	          Pointer:  Conversion obeys the rules of PointerToString
 	          Userdata: Conversion obeys the rules of PointerToString
 	*/
-	bool ParameterList::GetStringParameter(const std::string& name, std::string* value) const
+	auto ParameterList::GetStringParameter(const std::string& name, bool strict) const -> Result<std::string, Error>
 	{
-		NazaraAssert(value, "Invalid pointer");
-
-		ErrorFlags flags(ErrorMode::Silent | ErrorMode::ThrowExceptionDisabled);
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-		{
+			return Err(Error::MissingValue);
-			NazaraError("Parameter \"" + name + "\" is not present");
-			return false;
-		}
 
 		switch (it->second.type)
 		{
 			case ParameterType::Boolean:
-				*value = (it->second.value.boolVal) ? "true" : "false";
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return std::string{ (it->second.value.boolVal) ? "true" : "false" };
 
 			case ParameterType::Color:
-				*value = it->second.value.colorVal.ToString();
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return it->second.value.colorVal.ToString();
 
 			case ParameterType::Double:
-				*value = std::to_string(it->second.value.doubleVal);
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return std::to_string(it->second.value.doubleVal);
 
 			case ParameterType::Integer:
-				*value = std::to_string(it->second.value.intVal);
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return std::to_string(it->second.value.intVal);
 
 			case ParameterType::String:
-				*value = it->second.value.stringVal;
+				return it->second.value.stringVal;
-				return true;
 
 			case ParameterType::Pointer:
-				*value = PointerToString(it->second.value.ptrVal);
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return PointerToString(it->second.value.ptrVal);
 
 			case ParameterType::Userdata:
-				*value = PointerToString(it->second.value.userdataVal->ptr);
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return PointerToString(it->second.value.userdataVal->ptr);
 
 			case ParameterType::None:
-				*value = std::string();
+				if (strict)
-				return true;
+					return Err(Error::WouldRequireConversion);
+
+				return std::string{};
 		}
 
-		NazaraInternalError("Parameter value is not valid");
+		return Err(Error::WrongType);
-		return false;
+	}
+
+	/*!
+	* \brief Gets a parameter as a string view
+	* \return result containing the value or an error
+	*
+	* \param name Name of the parameter
+	* \param strict If true, prevent conversions from compatible types
+	*
+	* \remark If the parameter is not a string, a conversion may be performed if strict parameter is set to false, the following types are compatibles:
+			  Boolean:  A string view containing true or false
+			  None:     An empty string view is returned
+	*/
+	auto ParameterList::GetStringViewParameter(const std::string& name, bool strict) const -> Result<std::string_view, Error>
+	{
+		auto it = m_parameters.find(name);
+		if (it == m_parameters.end())
+			return Err(Error::MissingValue);
+
+		switch (it->second.type)
+		{
+			case ParameterType::Boolean:
+				if (strict)
+					return Err(Error::WouldRequireConversion);
+
+				return std::string_view{ (it->second.value.boolVal) ? "true" : "false" };
+
+			case ParameterType::String:
+				return std::string_view{ it->second.value.stringVal };
+
+			case ParameterType::None:
+				if (strict)
+					return Err(Error::WouldRequireConversion);
+
+				return std::string_view{};
+
+			case ParameterType::Color:
+			case ParameterType::Double:
+			case ParameterType::Integer:
+			case ParameterType::Pointer:
+			case ParameterType::Userdata:
+				break;
+		}
+
+		return Err(Error::WrongType);
 	}
 
 	/*!
 	* \brief Gets a parameter as an userdata
-	* \return true if the parameter could be represented as a userdata
+	* \return result containing the value or an error
 	*
 	* \param name Name of the parameter
-	* \param value Pointer to a pointer to hold the retrieved value
+	* \param strict If true, prevent conversions from compatible types
 	*
-	* \remark value must be a valid pointer
-	* \remark In case of failure, the variable pointed by value keep its value
 	* \remark If the parameter is not an userdata, the function fails
 	*
 	* \see GetPointerParameter
 	*/
-	bool ParameterList::GetUserdataParameter(const std::string& name, void** value) const
+	auto ParameterList::GetUserdataParameter(const std::string& name, bool /*strict*/) const -> Result<void*, Error>
 	{
-		NazaraAssert(value, "Invalid pointer");
-
-		ErrorFlags flags(ErrorMode::Silent | ErrorMode::ThrowExceptionDisabled);
-
 		auto it = m_parameters.find(name);
 		if (it == m_parameters.end())
-		{
+			return Err(Error::MissingValue);
-			NazaraError("Parameter \"" + name + "\" is not present");
-			return false;
-		}
 
 		const auto& parameter = it->second;
 
-		if (parameter.type == ParameterType::Userdata)
+		if (parameter.type != ParameterType::Userdata)
-		{
+			return Err(Error::WrongType);
-			*value = parameter.value.userdataVal->ptr;
+
-			return true;
+		return parameter.value.userdataVal->ptr.Get();
-		}
-		else
-		{
-			NazaraError("Parameter value is not a userdata");
-			return false;
-		}
 	}
 
 	/*!

src/Nazara/Graphics/Formats/TextureLoader.cpp

@@ -35,8 +35,7 @@ namespace Nz
 
 				std::shared_ptr<Material> material = std::make_shared<Material>();
 
-				bool hasAlphaTest = false;
+				bool hasAlphaTest = parameters.custom.GetBooleanParameter("EnableAlphaTest").GetValueOr(false);
-				parameters.custom.GetBooleanParameter("EnableAlphaTest", &hasAlphaTest);
 
 				// ForwardPass
 				{
@@ -79,8 +78,7 @@ namespace Nz
 
 			loaderEntry.parameterFilter = [](const MaterialParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipNativeTextureLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipNativeTextureLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/DDSLoader.cpp

@@ -60,7 +60,7 @@ namespace Nz
 				if (header.flags & DDSD_DEPTH)
 					depth = std::max(header.depth, 1U);
 
-				unsigned int levelCount = (parameters.levelCount > 0) ? std::min(parameters.levelCount, static_cast<UInt8>(header.levelCount)) : header.levelCount;
+				unsigned int levelCount = (parameters.levelCount > 0) ? std::min(parameters.levelCount, SafeCast<UInt8>(header.levelCount)) : header.levelCount;
 
 				// First, identify the type
 				ImageType type;
@@ -258,8 +258,7 @@ namespace Nz
 			loaderEntry.streamLoader = DDSLoader::Load;
 			loaderEntry.parameterFilter = [](const ImageParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinDDSLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinDDSLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/FreeTypeLoader.cpp

@@ -467,8 +467,7 @@ namespace Nz
 			loader.streamLoader = LoadFreetypeStream;
 			loader.parameterFilter = [](const FontParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinFreeTypeLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinFreeTypeLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/GIFLoader.cpp

@@ -749,8 +749,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadGIFStream;
 			loaderEntry.parameterFilter = [](const ImageStreamParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinGIFLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinGIFLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/MD2Loader.cpp

@@ -259,8 +259,7 @@ namespace Nz
 			loader.streamLoader = LoadMD2;
 			loader.parameterFilter = [](const MeshParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinMD2Loader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinMD2Loader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/MD5AnimLoader.cpp

@@ -100,8 +100,7 @@ namespace Nz
 			loader.streamLoader = LoadMD5Anim;
 			loader.parameterFilter = [](const AnimationParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinMD5AnimLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinMD5AnimLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/MD5MeshLoader.cpp

@@ -43,10 +43,9 @@ namespace Nz
 			}
 
 			UInt32 maxWeightCount = 4;
-			long long customMaxWeightCount;
+			if (auto result = parameters.custom.GetIntegerParameter("MaxWeightCount"))
-			if (parameters.custom.GetIntegerParameter("MaxWeightCount", &customMaxWeightCount))
 			{
-				maxWeightCount = SafeCast<UInt32>(customMaxWeightCount);
+				maxWeightCount = SafeCast<UInt32>(result.GetValue());
 				if (maxWeightCount > 4)
 				{
 					NazaraWarning("MaxWeightCount cannot be over 4");
@@ -361,8 +360,7 @@ namespace Nz
 			loader.streamLoader = LoadMD5Mesh;
 			loader.parameterFilter = [](const MeshParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinMD5MeshLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinMD5MeshLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/OBJLoader.cpp

@@ -144,9 +144,7 @@ namespace Nz
 
 		Result<std::shared_ptr<Mesh>, ResourceLoadingError> LoadOBJ(Stream& stream, const MeshParams& parameters)
 		{
-			long long reservedVertexCount;
+			long long reservedVertexCount = parameters.custom.GetIntegerParameter("ReserveVertexCount").GetValueOr(1'000);
-			if (!parameters.custom.GetIntegerParameter("NativeOBJLoader_VertexCount", &reservedVertexCount))
-				reservedVertexCount = 100;
 
 			OBJParser parser;
 
@@ -360,8 +358,7 @@ namespace Nz
 			loader.streamLoader = LoadOBJ;
 			loader.parameterFilter = [](const MeshParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinOBJLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinOBJLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/OBJSaver.cpp

@@ -103,7 +103,9 @@ namespace Nz
 				const ParameterList& matData = mesh.GetMaterialData(i);
 
 				std::string name;
-				if (!matData.GetStringParameter(MaterialData::Name, &name))
+				if (auto result = matData.GetStringParameter(MaterialData::Name))
+					name = std::move(result).GetValue();
+				else
 					name = "material_" + std::to_string(i);
 
 				// Makes sure we only have one material of that name
@@ -115,27 +117,32 @@ namespace Nz
 
 				MTLParser::Material* material = mtlFormat.AddMaterial(name);
 
-				if (!matData.GetStringParameter(MaterialData::FilePath, &material->diffuseMap))
+				auto pathResult = matData.GetStringParameter(MaterialData::FilePath);
+				if (!pathResult)
 				{
-					Color colorVal;
+					if (auto result = matData.GetColorParameter(MaterialData::AmbientColor))
-					double dValue;
+						material->ambient = result.GetValue();
 
-					if (matData.GetColorParameter(MaterialData::AmbientColor, &colorVal))
+					if (auto result = matData.GetColorParameter(MaterialData::BaseColor))
-						material->ambient = colorVal;
+						material->diffuse = result.GetValue();
 
-					if (matData.GetColorParameter(MaterialData::BaseColor, &colorVal))
+					if (auto result = matData.GetColorParameter(MaterialData::SpecularColor))
-						material->diffuse = colorVal;
+						material->specular = result.GetValue();
 
-					if (matData.GetColorParameter(MaterialData::SpecularColor, &colorVal))
+					if (auto result = matData.GetDoubleParameter(MaterialData::Shininess))
-						material->specular = colorVal;
+						material->shininess = SafeCast<float>(result.GetValue());
 
-					if (matData.GetDoubleParameter(MaterialData::Shininess, &dValue))
+					if (auto result = matData.GetStringParameter(MaterialData::AlphaTexturePath))
-						material->shininess = float(dValue);
+						material->alphaMap = std::move(result).GetValue();
 
-					matData.GetStringParameter(MaterialData::AlphaTexturePath, &material->alphaMap);
+					if (auto result = matData.GetStringParameter(MaterialData::BaseColorTexturePath))
-					matData.GetStringParameter(MaterialData::BaseColorTexturePath, &material->diffuseMap);
+						material->diffuseMap = std::move(result).GetValue();
-					matData.GetStringParameter(MaterialData::SpecularTexturePath, &material->specularMap);
+
+					if (auto result = matData.GetStringParameter(MaterialData::SpecularTexturePath))
+						material->specularMap = std::move(result).GetValue();
 				}
+				else
+					material->diffuseMap = std::move(pathResult).GetValue();
 			}
 
 			// Meshes

src/Nazara/Utility/Formats/PCXLoader.cpp

@@ -331,8 +331,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadPCX;
 			loaderEntry.parameterFilter = [](const ImageParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinPCXLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinPCXLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/STBLoader.cpp

@@ -62,7 +62,7 @@ namespace Nz
 			if (!ptr)
 			{
 				NazaraError("Failed to load image: " + std::string(stbi_failure_reason()));
-				return Err(ResourceLoadingError::Unrecognized);
+				return Err(ResourceLoadingError::DecodingError);
 			}
 
 			CallOnExit freeStbiImage([ptr]()
@@ -103,8 +103,7 @@ namespace Nz
 			loaderEntry.streamLoader = LoadSTB;
 			loaderEntry.parameterFilter = [](const ImageParams& parameters)
 			{
-				bool skip;
+				if (auto result = parameters.custom.GetBooleanParameter("SkipBuiltinSTBLoader"); result.GetValueOr(false))
-				if (parameters.custom.GetBooleanParameter("SkipBuiltinSTBLoader", &skip) && skip)
 					return false;
 
 				return true;

src/Nazara/Utility/Formats/STBSaver.cpp

@@ -175,17 +175,12 @@ namespace Nz
 				return false;
 			}
 
-			long long imageQuality;
+			long long imageQuality = parameters.custom.GetIntegerParameter("JPEGQuality").GetValueOr(100);
-			if (parameters.custom.GetIntegerParameter("NativeJPEGSaver_Quality", &imageQuality))
+			if (imageQuality <= 0 || imageQuality > 100)
 			{
-				if (imageQuality <= 0 || imageQuality > 100)
+				NazaraError("NativeJPEGSaver_Quality value (" + Nz::NumberToString(imageQuality) + ") does not fit in bounds ]0, 100], clamping...");
-				{
+				imageQuality = Nz::Clamp(imageQuality, 1LL, 100LL);
-					NazaraError("NativeJPEGSaver_Quality value (" + Nz::NumberToString(imageQuality) + ") does not fit in bounds ]0, 100], clamping...");
-					imageQuality = Nz::Clamp(imageQuality, 1LL, 100LL);
-				}
 			}
-			else
-				imageQuality = 100;
 
 			if (!stbi_write_jpg_to_func(&WriteToStream, &stream, tempImage.GetWidth(), tempImage.GetHeight(), componentCount, tempImage.GetConstPixels(), int(imageQuality)))
 			{

src/Nazara/VulkanRenderer/Vulkan.cpp

@@ -129,26 +129,14 @@ namespace Nz
 
 		CallOnExit onExit(Vulkan::Uninitialize);
 
-		std::string appName = "Another application made with Nazara Engine";
+		std::string appName = parameters.GetStringParameter("VkAppInfo_OverrideApplicationName").GetValueOr("Another application made with Nazara Engine");
-		std::string engineName = "Nazara Engine - Vulkan Renderer";
+		std::string engineName = parameters.GetStringParameter("VkAppInfo_OverrideEngineName").GetValueOr("Nazara Engine - Vulkan Renderer");
 
-		UInt32 appVersion = VK_MAKE_API_VERSION(0, 1, 0, 0);
+		UInt32 appVersion = parameters.GetIntegerParameter("VkAppInfo_OverrideApplicationVersion").GetValueOr(VK_MAKE_API_VERSION(0, 1, 0, 0));
-		UInt32 engineVersion = VK_MAKE_API_VERSION(0, 1, 0, 0);
+		UInt32 engineVersion = parameters.GetIntegerParameter("VkAppInfo_OverrideEngineVersion").GetValueOr(VK_MAKE_API_VERSION(0, 1, 0, 0));
 
-		parameters.GetStringParameter("VkAppInfo_OverrideApplicationName", &appName);
+		if (auto result = parameters.GetIntegerParameter("VkAppInfo_OverrideAPIVersion"))
-		parameters.GetStringParameter("VkAppInfo_OverrideEngineName", &engineName);
+			targetApiVersion = SafeCast<UInt32>(result.GetValue());
-
-		bool bParam;
-		long long iParam;
-
-		if (parameters.GetIntegerParameter("VkAppInfo_OverrideAPIVersion", &iParam))
-			targetApiVersion = static_cast<UInt32>(iParam);
-
-		if (parameters.GetIntegerParameter("VkAppInfo_OverrideApplicationVersion", &iParam))
-			appVersion = static_cast<UInt32>(iParam);
-
-		if (parameters.GetIntegerParameter("VkAppInfo_OverrideEngineVersion", &iParam))
-			engineVersion = static_cast<UInt32>(iParam);
 
 		if (Vk::Loader::vkEnumerateInstanceVersion)
 		{
@@ -171,10 +159,7 @@ namespace Nz
 			targetApiVersion
 		};
 
-		VkInstanceCreateFlags createFlags = 0;
+		VkInstanceCreateFlags createFlags = parameters.GetIntegerParameter("VkInstanceInfo_OverrideCreateFlags").GetValueOr(0);
-
-		if (parameters.GetIntegerParameter("VkInstanceInfo_OverrideCreateFlags", &iParam))
-			createFlags = static_cast<VkInstanceCreateFlags>(iParam);
 
 		std::vector<const char*> enabledLayers;
 
@@ -182,7 +167,7 @@ namespace Nz
 		std::unordered_map<std::string, std::size_t> availableLayerByName;
 		EnumerateVulkanLayers(availableLayers, availableLayerByName);
 
-		if (!parameters.GetBooleanParameter("VkInstanceInfo_OverrideEnabledLayers", &bParam) || !bParam)
+		if (auto result = parameters.GetBooleanParameter("VkInstanceInfo_OverrideEnabledLayers"); !result.GetValueOr(false))
 		{
 			//< Nazara default layers goes here
 
@@ -198,16 +183,15 @@ namespace Nz
 
 		std::vector<const char*> enabledExtensions;
 		std::vector<std::string> additionalLayers; // Just to keep the String alive
-		if (parameters.GetIntegerParameter("VkInstanceInfo_EnabledLayerCount", &iParam))
+		if (long long customLayerCount = parameters.GetIntegerParameter("VkInstanceInfo_EnabledLayerCount").GetValueOr(0) > 0)
 		{
-			additionalLayers.reserve(iParam);
+			additionalLayers.reserve(customLayerCount);
-			for (long long i = 0; i < iParam; ++i)
+			for (long long i = 0; i < customLayerCount; ++i)
 			{
 				std::string parameterName = "VkInstanceInfo_EnabledLayer" + NumberToString(i);
-				std::string layer;
+				if (auto result = parameters.GetStringParameter(parameterName))
-				if (parameters.GetStringParameter(parameterName, &layer))
 				{
-					additionalLayers.emplace_back(std::move(layer));
+					additionalLayers.emplace_back(std::move(result).GetValue());
 					enabledLayers.push_back(additionalLayers.back().c_str());
 				}
 				else
@@ -224,7 +208,7 @@ namespace Nz
 				availableExtensions.insert(extProperty.extensionName);
 		}
 
-		if (!parameters.GetBooleanParameter("VkInstanceInfo_OverrideEnabledExtensions", &bParam) || !bParam)
+		if (auto result = parameters.GetBooleanParameter("VkInstanceInfo_OverrideEnabledExtensions"); !result.GetValueOr(false))
 		{
 			enabledExtensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
 
@@ -260,16 +244,15 @@ namespace Nz
 		}
 
 		std::vector<std::string> additionalExtensions; // Just to keep the String alive
-		if (parameters.GetIntegerParameter("VkInstanceInfo_EnabledExtensionCount", &iParam))
+		if (long long customLayerCount = parameters.GetIntegerParameter("VkInstanceInfo_EnabledExtensionCount").GetValueOr(0) > 0)
 		{
-			additionalExtensions.reserve(iParam);
+			additionalExtensions.reserve(customLayerCount);
-			for (int i = 0; i < iParam; ++i)
+			for (int i = 0; i < customLayerCount; ++i)
 			{
 				std::string parameterName = "VkInstanceInfo_EnabledExtension" + NumberToString(i);
-				std::string extension;
+				if (auto result = parameters.GetStringParameter(parameterName))
-				if (parameters.GetStringParameter(parameterName, &extension))
 				{
-					additionalExtensions.emplace_back(std::move(extension));
+					additionalLayers.emplace_back(std::move(result).GetValue());
 					enabledExtensions.push_back(additionalExtensions.back().c_str());
 				}
 				else
@@ -526,25 +509,21 @@ namespace Nz
 		std::vector<const char*> enabledLayers;
 		std::vector<const char*> enabledExtensions;
 
-		bool bParam;
+		if (auto result = s_initializationParameters.GetBooleanParameter("VkDeviceInfo_OverrideEnabledLayers"); !result.GetValueOr(false))
-		long long iParam;
-
-		if (!s_initializationParameters.GetBooleanParameter("VkDeviceInfo_OverrideEnabledLayers", &bParam) || !bParam)
 		{
 			//< Nazara default layers goes here
 		}
 
 		std::vector<std::string> additionalLayers; // Just to keep the string alive
-		if (s_initializationParameters.GetIntegerParameter("VkDeviceInfo_EnabledLayerCount", &iParam))
+		if (long long customLayerCount = s_initializationParameters.GetIntegerParameter("VkDeviceInfo_EnabledLayerCount").GetValueOr(0))
 		{
-			additionalLayers.reserve(iParam);
+			additionalLayers.reserve(customLayerCount);
-			for (long long i = 0; i < iParam; ++i)
+			for (long long i = 0; i < customLayerCount; ++i)
 			{
 				std::string parameterName = "VkDeviceInfo_EnabledLayer" + NumberToString(i);
-				std::string layer;
+				if (auto value = s_initializationParameters.GetStringViewParameter(parameterName))
-				if (s_initializationParameters.GetStringParameter(parameterName, &layer))
 				{
-					additionalLayers.emplace_back(std::move(layer));
+					additionalLayers.emplace_back(std::move(value).GetValue());
 					enabledLayers.push_back(additionalLayers.back().c_str());
 				}
 				else
@@ -552,7 +531,7 @@ namespace Nz
 			}
 		}
 
-		if (!s_initializationParameters.GetBooleanParameter("VkDeviceInfo_OverrideEnabledExtensions", &bParam) || !bParam)
+		if (auto result = s_initializationParameters.GetBooleanParameter("VkDeviceInfo_OverrideEnabledExtensions"); !result.GetValueOr(false))
 		{
 			// Swapchain extension is required for rendering
 			enabledExtensions.emplace_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
@@ -574,15 +553,14 @@ namespace Nz
 		}
 
 		std::vector<std::string> additionalExtensions; // Just to keep the String alive
-		if (s_initializationParameters.GetIntegerParameter("VkDeviceInfo_EnabledExtensionCount", &iParam))
+		if (long long customExtCount = s_initializationParameters.GetIntegerParameter("VkDeviceInfo_EnabledExtensionCount").GetValueOr(0))
 		{
-			for (long long i = 0; i < iParam; ++i)
+			for (long long i = 0; i < customExtCount; ++i)
 			{
 				std::string parameterName = "VkDeviceInfo_EnabledExtension" + NumberToString(i);
-				std::string extension;
+				if (auto value = s_initializationParameters.GetStringViewParameter(parameterName))
-				if (s_initializationParameters.GetStringParameter(parameterName, &extension))
 				{
-					additionalExtensions.emplace_back(std::move(extension));
+					additionalExtensions.emplace_back(std::move(value).GetValue());
 					enabledExtensions.push_back(additionalExtensions.back().c_str());
 				}
 				else

tests/Engine/Core/ParameterListTest.cpp

@@ -29,27 +29,19 @@ SCENARIO("ParameterList", "[CORE][PARAMETERLIST]")
 
 			THEN("We can get it back")
 			{
-				bool retrievedValue = false;
+				CHECK(parameterList.GetBooleanParameter("bool").GetValue() == true);
-				CHECK(parameterList.GetBooleanParameter("bool", &retrievedValue));
-				CHECK(retrievedValue == boolean);
 			}
 
-			THEN("Conversion from int to bool should also work")
+			THEN("Conversion from int to bool should also work if strict mode is disabled")
 			{
-				bool retrievedValue = false;
+				CHECK(parameterList.GetBooleanParameter("intTrue", false).GetValue() == true);
-				CHECK(parameterList.GetBooleanParameter("intTrue", &retrievedValue));
+				CHECK(parameterList.GetBooleanParameter("intFalse", false).GetValue() == false);
-				CHECK(retrievedValue);
-				CHECK(parameterList.GetBooleanParameter("intFalse", &retrievedValue));
-				CHECK(!retrievedValue);
 			}
 
-			THEN("Conversion from str to bool should also work")
+			THEN("Conversion from str to bool should also work if strict mode is disabled")
 			{
-				bool retrievedValue = false;
+				CHECK(parameterList.GetBooleanParameter("strTrue", false).GetValue() == true);
-				CHECK(parameterList.GetBooleanParameter("strTrue", &retrievedValue));
+				CHECK(parameterList.GetBooleanParameter("strFalse", false).GetValue() == false);
-				CHECK(retrievedValue);
-				CHECK(parameterList.GetBooleanParameter("strFalse", &retrievedValue));
-				CHECK(!retrievedValue);
 			}
 		}
 
@@ -60,9 +52,7 @@ SCENARIO("ParameterList", "[CORE][PARAMETERLIST]")
 
 			THEN("We can get it back")
 			{
-				Nz::Color retrievedColor;
+				CHECK(parameterList.GetColorParameter("color").GetValue() == rgb);
-				CHECK(parameterList.GetColorParameter("color", &retrievedColor));
-				CHECK(retrievedColor == rgb);
 			}
 		}
 
@@ -79,23 +69,17 @@ SCENARIO("ParameterList", "[CORE][PARAMETERLIST]")
 
 			THEN("We can get it back")
 			{
-				double retrievedValue;
+				CHECK(parameterList.GetDoubleParameter("double").GetValue() == fl);
-				CHECK(parameterList.GetDoubleParameter("double", &retrievedValue));
-				CHECK(retrievedValue == fl);
 			}
 
-			THEN("Conversion from int to double should also work")
+			THEN("Conversion from int to double should also work if strict mode is disabled")
 			{
-				double retrievedValue;
+				CHECK(parameterList.GetDoubleParameter("intDouble", false).GetValue() == fl);
-				CHECK(parameterList.GetDoubleParameter("intDouble", &retrievedValue));
-				CHECK(retrievedValue == fl);
 			}
 
-			THEN("Conversion from string to double should also work")
+			THEN("Conversion from string to double should also work if strict mode is disabled")
 			{
-				double retrievedValue;
+				CHECK(parameterList.GetDoubleParameter("strDouble", false).GetValue() == fl);
-				CHECK(parameterList.GetDoubleParameter("strDouble", &retrievedValue));
-				CHECK(retrievedValue == fl);
 			}
 		}
 
@@ -117,32 +101,23 @@ SCENARIO("ParameterList", "[CORE][PARAMETERLIST]")
 
 			THEN("We can get it back")
 			{
-				long long retrievedValue;
+				CHECK(parameterList.GetIntegerParameter("int").GetValue() == i);
-				CHECK(parameterList.GetIntegerParameter("int", &retrievedValue));
-				CHECK(retrievedValue == i);
 			}
 
-			THEN("Conversion from bool to int should also work")
+			THEN("Conversion from bool to int should also work if strict mode is disabled")
 			{
-				long long retrievedValue;
+				CHECK(parameterList.GetIntegerParameter("trueInt", false).GetValue() == trueInt);
-				CHECK(parameterList.GetIntegerParameter("trueInt", &retrievedValue));
+				CHECK(parameterList.GetIntegerParameter("falseInt", false).GetValue() == falseInt);
-				CHECK(retrievedValue == trueInt);
-				CHECK(parameterList.GetIntegerParameter("falseInt", &retrievedValue));
-				CHECK(retrievedValue == falseInt);
 			}
 
-			THEN("Conversion from double to int should also work")
+			THEN("Conversion from double to int should also work if strict mode is disabled")
 			{
-				long long retrievedValue;
+				CHECK(parameterList.GetIntegerParameter("doubleInt", false).GetValue() == i);
-				CHECK(parameterList.GetIntegerParameter("doubleInt", &retrievedValue));
-				CHECK(retrievedValue == i);
 			}
 
-			THEN("Conversion from string to int should also work")
+			THEN("Conversion from string to int should also work if strict mode is disabled")
 			{
-				long long retrievedValue;
+				CHECK(parameterList.GetIntegerParameter("strInt", false).GetValue() == i);
-				CHECK(parameterList.GetIntegerParameter("strInt", &retrievedValue));
-				CHECK(retrievedValue == i);
 			}
 		}
 
@@ -167,39 +142,31 @@ SCENARIO("ParameterList", "[CORE][PARAMETERLIST]")
 
 			THEN("We can get it back")
 			{
-				std::string newString;
+				CHECK(parameterList.GetStringParameter("string").GetValue() == string);
-				CHECK(parameterList.GetStringParameter("string", &newString));
+				CHECK(parameterList.GetStringViewParameter("string").GetValue() == string);
-				CHECK(newString == string);
 			}
 
-			THEN("Conversion from bool to str should also work")
+			THEN("Conversion from bool to str should also work if strict mode is disabled")
 			{
-				std::string retrievedValue;
+				CHECK(parameterList.GetStringParameter("trueString", false).GetValue() == "true");
-				CHECK(parameterList.GetStringParameter("trueString", &retrievedValue));
+				CHECK(parameterList.GetStringParameter("falseString", false).GetValue() == "false");
-				CHECK(retrievedValue == "true");
+				CHECK(parameterList.GetStringViewParameter("trueString", false).GetValue() == "true");
-				CHECK(parameterList.GetStringParameter("falseString", &retrievedValue));
+				CHECK(parameterList.GetStringViewParameter("falseString", false).GetValue() == "false");
-				CHECK(retrievedValue == "false");
 			}
 
-			THEN("Conversion from color to string should also work")
+			THEN("Conversion from color to string should also work if strict mode is disabled")
 			{
-				std::string retrievedValue;
+				CHECK(parameterList.GetStringParameter("colorString", false).GetValue() == colorString.ToString());
-				CHECK(parameterList.GetStringParameter("colorString", &retrievedValue));
-				CHECK(retrievedValue == colorString.ToString());
 			}
 
-			THEN("Conversion from string to double should also work")
+			THEN("Conversion from string to double should also work if strict mode is disabled")
 			{
-				std::string retrievedValue;
+				CHECK(parameterList.GetStringParameter("doubleString", false).GetValue() == "3.000000");
-				CHECK(parameterList.GetStringParameter("doubleString", &retrievedValue));
-				CHECK(retrievedValue == "3.000000");
 			}
 
-			THEN("Conversion from string to int should also work")
+			THEN("Conversion from string to int should also work if strict mode is disabled")
 			{
-				std::string retrievedValue;
+				CHECK(parameterList.GetStringParameter("intString", false).GetValue() == "3");
-				CHECK(parameterList.GetStringParameter("intString", &retrievedValue));
-				CHECK(retrievedValue == "3");
 			}
 		}
 
@@ -211,9 +178,7 @@ SCENARIO("ParameterList", "[CORE][PARAMETERLIST]")
 
 			THEN("We can get it back")
 			{
-				void* newPtrToStackValue = nullptr;
+				CHECK(parameterList.GetPointerParameter("ptr").GetValue() == ptrToStackValue);
-				CHECK(parameterList.GetPointerParameter("ptr", &newPtrToStackValue));
-				CHECK(newPtrToStackValue == ptrToStackValue);
 			}
 		}
 
@@ -229,11 +194,10 @@ SCENARIO("ParameterList", "[CORE][PARAMETERLIST]")
 
 			THEN("We can get it back")
 			{
-				Data retrievedValue;
+				void* ptrToData;
-				void* ptrToData = &retrievedValue;
 
-				CHECK(parameterList.GetUserdataParameter("userData", &ptrToData));
+				CHECK_NOTHROW(ptrToData = parameterList.GetUserdataParameter("userData").GetValue());
-				Data* dataPtr = reinterpret_cast<Data*>(ptrToData);
+				Data* dataPtr = static_cast<Data*>(ptrToData);
 				CHECK(dataPtr->i == data.i);
 				CHECK(dataPtr->f == data.f);
 			}