sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Core/ParameterList: Make errors silent by default 

Former-commit-id: 38d1613681a65194cb7392903c9bc20f912561a3
This commit is contained in:
Lynix 2016-03-08 13:58:09 +01:00
parent d349b9583e
commit 1a95c314ff
2 changed files with 64 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/Nazara/Core/ParameterList.hpp
View File

@ -86,10 +86,10 @@ namespace Nz
Value value; Value value;
}; };
using ParameterMap = std::unordered_map<String, Parameter>; Parameter& CreateValue(const String& name);
void DestroyValue(Parameter& parameter); void DestroyValue(Parameter& parameter);
using ParameterMap = std::unordered_map<String, Parameter>;
ParameterMap m_parameters; ParameterMap m_parameters;
}; };
} }

135
src/Nazara/Core/ParameterList.cpp
View File

@ -4,6 +4,7 @@
#include <Nazara/Core/ParameterList.hpp> #include <Nazara/Core/ParameterList.hpp>
#include <Nazara/Core/Error.hpp> #include <Nazara/Core/Error.hpp>
#include <Nazara/Core/ErrorFlags.hpp>
#include <Nazara/Core/MemoryHelper.hpp> #include <Nazara/Core/MemoryHelper.hpp>
#include <cstring> #include <cstring>
#include <limits> #include <limits>
@ -49,21 +50,23 @@ namespace Nz
} }
/*! /*!
* \brief Gets the boolean parameter by name * \brief Gets a boolean parameter by name
* \return true if success * \return true if success
* *
* \param name Name of the variable * \param name Name of the variable
* \param value Value to set * \param value Value to set
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark Produces a NazaraAssert if pointer is invalid
* \remark Produces a NazaraError if name is not a variable * \remark Produces a silent NazaraError if name is not a variable
* \remark Produces a NazaraError if value could not be convertible * \remark Produces a silent NazaraError if value could not be convertible
*/ */
bool ParameterList::GetBooleanParameter(const String& name, bool* value) const bool ParameterList::GetBooleanParameter(const String& name, bool* value) const
{ {
NazaraAssert(value, "Invalid pointer"); NazaraAssert(value, "Invalid pointer");
ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
auto it = m_parameters.find(name); auto it = m_parameters.find(name);
if (it == m_parameters.end()) if (it == m_parameters.end())
{ {
@ -105,21 +108,23 @@ namespace Nz
} }
/*! /*!
* \brief Gets the float parameter by name * \brief Gets a float parameter by name
* \return true if success * \return true if success
* *
* \param name Name of the variable * \param name Name of the variable
* \param value Value to set * \param value Value to set
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark Produces a NazaraAssert if pointer is invalid
* \remark Produces a NazaraError if name is not a variable * \remark Produces a silent NazaraError if name is not a variable
* \remark Produces a NazaraError if value could not be convertible * \remark Produces a silent NazaraError if value could not be convertible
*/ */
bool ParameterList::GetFloatParameter(const String& name, float* value) const bool ParameterList::GetFloatParameter(const String& name, float* value) const
{ {
NazaraAssert(value, "Invalid pointer"); NazaraAssert(value, "Invalid pointer");
ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
auto it = m_parameters.find(name); auto it = m_parameters.find(name);
if (it == m_parameters.end()) if (it == m_parameters.end())
{ {
@ -161,21 +166,23 @@ namespace Nz
} }
/*! /*!
* \brief Gets the integer parameter by name * \brief Gets a integer parameter by name
* \return true if success * \return true if success
* *
* \param name Name of the variable * \param name Name of the variable
* \param value Value to set * \param value Value to set
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark Produces a NazaraAssert if pointer is invalid
* \remark Produces a NazaraError if name is not a variable * \remark Produces a silent NazaraError if name is not a variable
* \remark Produces a NazaraError if value could not be convertible * \remark Produces a silent NazaraError if value could not be convertible
*/ */
bool ParameterList::GetIntegerParameter(const String& name, int* value) const bool ParameterList::GetIntegerParameter(const String& name, int* value) const
{ {
NazaraAssert(value, "Invalid pointer"); NazaraAssert(value, "Invalid pointer");
ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
auto it = m_parameters.find(name); auto it = m_parameters.find(name);
if (it == m_parameters.end()) if (it == m_parameters.end())
{ {
@ -222,15 +229,13 @@ namespace Nz
} }
/*! /*!
* \brief Gets the parameter by name * \brief Gets a parameter type by name
* \return true if success * \return true if the parameter is present
* *
* \param name Name of the variable * \param name Name of the variable
* \param type Type to set * \param type Pointer to a variable to hold result
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark Produces a NazaraAssert if type is invalid
* \remark Produces a NazaraError if name is not a variable
* \remark Produces a NazaraError if value could not be convertible
*/ */
bool ParameterList::GetParameterType(const String& name, ParameterType* type) const bool ParameterList::GetParameterType(const String& name, ParameterType* type) const
@ -247,21 +252,23 @@ namespace Nz
} }
/*! /*!
* \brief Gets the pointer parameter by name * \brief Gets a pointer parameter by name
* \return true if success * \return true if success
* *
* \param name Name of the variable * \param name Name of the variable
* \param value Value to set * \param value Value to set
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark Produces a NazaraAssert if pointer is invalid
* \remark Produces a NazaraError if name is not a variable * \remark Produces a silent NazaraError if name is not a variable
* \remark Produces a NazaraError if value could not be convertible * \remark Produces a silent NazaraError if value could not be convertible
*/ */
bool ParameterList::GetPointerParameter(const String& name, void** value) const bool ParameterList::GetPointerParameter(const String& name, void** value) const
{ {
NazaraAssert(value, "Invalid pointer"); NazaraAssert(value, "Invalid pointer");
ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
auto it = m_parameters.find(name); auto it = m_parameters.find(name);
if (it == m_parameters.end()) if (it == m_parameters.end())
{ {
@ -292,21 +299,23 @@ namespace Nz
} }
/*! /*!
* \brief Gets the string parameter by name * \brief Gets a string parameter by name
* \return true if success * \return true if success
* *
* \param name Name of the variable * \param name Name of the variable
* \param value Value to set * \param value Value to set
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark Produces a NazaraAssert if pointer is invalid
* \remark Produces a NazaraError if name is not a variable * \remark Produces a silent NazaraError if name is not a variable
* \remark Produces a NazaraError if value could not be convertible * \remark Produces a silent NazaraError if value could not be convertible
*/ */
bool ParameterList::GetStringParameter(const String& name, String* value) const bool ParameterList::GetStringParameter(const String& name, String* value) const
{ {
NazaraAssert(value, "Invalid pointer"); NazaraAssert(value, "Invalid pointer");
ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
auto it = m_parameters.find(name); auto it = m_parameters.find(name);
if (it == m_parameters.end()) if (it == m_parameters.end())
{ {
@ -350,21 +359,23 @@ namespace Nz
} }
/*! /*!
* \brief Gets the user parameter by name * \brief Gets a user parameter by name
* \return true if success * \return true if success
* *
* \param name Name of the variable * \param name Name of the variable
* \param value Value to set * \param value Value to set
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark Produces a NazaraAssert if pointer is invalid
* \remark Produces a NazaraError if name is not a variable * \remark Produces a silent NazaraError if name is not a variable
* \remark Produces a NazaraError if value could not be convertible * \remark Produces a silent NazaraError if value could not be convertible
*/ */
bool ParameterList::GetUserdataParameter(const String& name, void** value) const bool ParameterList::GetUserdataParameter(const String& name, void** value) const
{ {
NazaraAssert(value, "Invalid pointer"); NazaraAssert(value, "Invalid pointer");
ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
auto it = m_parameters.find(name); auto it = m_parameters.find(name);
if (it == m_parameters.end()) if (it == m_parameters.end())
{ {
@ -422,12 +433,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name) void ParameterList::SetParameter(const String& name)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_None; parameter.type = ParameterType_None;
} }
@ -440,12 +446,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name, const String& value) void ParameterList::SetParameter(const String& name, const String& value)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_String; parameter.type = ParameterType_String;
PlacementNew<String>(&parameter.value.stringVal, value); PlacementNew<String>(&parameter.value.stringVal, value);
@ -460,12 +461,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name, const char* value) void ParameterList::SetParameter(const String& name, const char* value)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_String; parameter.type = ParameterType_String;
PlacementNew<String>(&parameter.value.stringVal, value); PlacementNew<String>(&parameter.value.stringVal, value);
@ -480,12 +476,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name, void* value) void ParameterList::SetParameter(const String& name, void* value)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_Pointer; parameter.type = ParameterType_Pointer;
parameter.value.ptrVal = value; parameter.value.ptrVal = value;
} }
@ -500,12 +491,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name, void* value, Destructor destructor) void ParameterList::SetParameter(const String& name, void* value, Destructor destructor)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_Userdata; parameter.type = ParameterType_Userdata;
parameter.value.userdataVal = new Parameter::UserdataValue(destructor, value); parameter.value.userdataVal = new Parameter::UserdataValue(destructor, value);
} }
@ -519,12 +505,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name, bool value) void ParameterList::SetParameter(const String& name, bool value)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_Boolean; parameter.type = ParameterType_Boolean;
parameter.value.boolVal = value; parameter.value.boolVal = value;
} }
@ -538,12 +519,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name, float value) void ParameterList::SetParameter(const String& name, float value)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_Float; parameter.type = ParameterType_Float;
parameter.value.floatVal = value; parameter.value.floatVal = value;
} }
@ -557,12 +533,7 @@ namespace Nz
void ParameterList::SetParameter(const String& name, int value) void ParameterList::SetParameter(const String& name, int value)
{ {
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter())); Parameter& parameter = CreateValue(name);
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
parameter.type = ParameterType_Integer; parameter.type = ParameterType_Integer;
parameter.value.intVal = value; parameter.value.intVal = value;
} }
@ -612,12 +583,30 @@ namespace Nz
return *this; return *this;
} }
/*!
* \brief Create an uninitialized value of a set name
*
* \param name Name of the parameter
* \param value Value of the parameter
*
* \remark The previous value if any gets destroyed
*/
ParameterList::Parameter& ParameterList::CreateValue(const String& name)
{
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
Parameter& parameter = pair.first->second;
if (!pair.second)
DestroyValue(parameter);
return parameter;
}
/*! /*!
* \brief Destroys the value for the parameter * \brief Destroys the value for the parameter
* *
* \param parameter Parameter to destroy * \param parameter Parameter to destroy
*/ */
void ParameterList::DestroyValue(Parameter& parameter) void ParameterList::DestroyValue(Parameter& parameter)
{ {
switch (parameter.type) switch (parameter.type)