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

Core/ParameterList: Add support for color values and updated documentation 

Former-commit-id: 87478d0e90a39ec24779ee9174e9f4e1a1f6d32b
This commit is contained in:
Lynix 2016-04-30 12:44:34 +02:00
parent d558ef6edc
commit 9aab369791
3 changed files with 209 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/Nazara/Core/Enums.hpp
View File

@ -93,6 +93,7 @@ namespace Nz
enum ParameterType enum ParameterType
{ {
ParameterType_Boolean, ParameterType_Boolean,
ParameterType_Color,
ParameterType_Float, ParameterType_Float,
ParameterType_Integer, ParameterType_Integer,
ParameterType_None, ParameterType_None,

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

@ -8,6 +8,7 @@
#define NAZARA_PARAMETERLIST_HPP #define NAZARA_PARAMETERLIST_HPP
#include <Nazara/Prerequesites.hpp> #include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Color.hpp>
#include <Nazara/Core/String.hpp> #include <Nazara/Core/String.hpp>
#include <atomic> #include <atomic>
#include <unordered_map> #include <unordered_map>
@ -27,6 +28,7 @@ namespace Nz
void Clear(); void Clear();
bool GetBooleanParameter(const String& name, bool* value) const; bool GetBooleanParameter(const String& name, bool* value) const;
bool GetColorParameter(const String& name, Color* value) const;
bool GetFloatParameter(const String& name, float* value) const; bool GetFloatParameter(const String& name, float* value) const;
bool GetIntegerParameter(const String& name, int* value) const; bool GetIntegerParameter(const String& name, int* value) const;
bool GetParameterType(const String& name, ParameterType* type) const; bool GetParameterType(const String& name, ParameterType* type) const;
@ -39,13 +41,14 @@ namespace Nz
void RemoveParameter(const String& name); void RemoveParameter(const String& name);
void SetParameter(const String& name); void SetParameter(const String& name);
void SetParameter(const String& name, const Color& value);
void SetParameter(const String& name, const String& value); void SetParameter(const String& name, const String& value);
void SetParameter(const String& name, const char* value); void SetParameter(const String& name, const char* value);
void SetParameter(const String& name, void* value);
void SetParameter(const String& name, void* value, Destructor destructor);
void SetParameter(const String& name, bool value); void SetParameter(const String& name, bool value);
void SetParameter(const String& name, float value); void SetParameter(const String& name, float value);
void SetParameter(const String& name, int value); void SetParameter(const String& name, int value);
void SetParameter(const String& name, void* value);
void SetParameter(const String& name, void* value, Destructor destructor);
ParameterList& operator=(const ParameterList& list); ParameterList& operator=(const ParameterList& list);
ParameterList& operator=(ParameterList&&) = default; ParameterList& operator=(ParameterList&&) = default;
@ -79,6 +82,7 @@ namespace Nz
float floatVal; float floatVal;
int intVal; int intVal;
void* ptrVal; void* ptrVal;
Color colorVal;
String stringVal; String stringVal;
UserdataValue* userdataVal; UserdataValue* userdataVal;
}; };

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

@ -22,7 +22,6 @@ namespace Nz
/*! /*!
* \brief Constructs a ParameterList object by copy * \brief Constructs a ParameterList object by copy
*/ */
ParameterList::ParameterList(const ParameterList& list) ParameterList::ParameterList(const ParameterList& list)
{ {
operator=(list); operator=(list);
@ -31,16 +30,14 @@ namespace Nz
/*! /*!
* \brief Destructs the object and clears * \brief Destructs the object and clears
*/ */
ParameterList::~ParameterList() ParameterList::~ParameterList()
{ {
Clear(); Clear();
} }
/*! /*!
* \brief Clears the list of parameters * \brief Clears all the parameters
*/ */
void ParameterList::Clear() void ParameterList::Clear()
{ {
for (auto it = m_parameters.begin(); it != m_parameters.end(); ++it) for (auto it = m_parameters.begin(); it != m_parameters.end(); ++it)
@ -50,17 +47,18 @@ namespace Nz
} }
/*! /*!
* \brief Gets a boolean parameter by name * \brief Gets a parameter as a boolean
* \return true if success * \return true if the parameter could be represented as a boolean
* *
* \param name Name of the variable * \param name Name of the parameter
* \param value Value to set * \param value Pointer to a boolean to hold the retrieved value
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark value must be a valid pointer
* \remark Produces a silent NazaraError if name is not a variable * \remark In case of failure, the variable pointed by value keep its value
* \remark Produces a silent NazaraError if value could not be convertible * \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
String: Conversion obeys the rule as described by String::ToBool
*/ */
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");
@ -85,17 +83,17 @@ namespace Nz
return true; return true;
case ParameterType_String: case ParameterType_String:
{
bool converted;
if (it->second.value.stringVal.ToBool(&converted, String::CaseInsensitive))
{ {
bool converted; *value = converted;
if (it->second.value.stringVal.ToBool(&converted, String::CaseInsensitive)) return true;
{
*value = converted;
return true;
}
break;
} }
break;
}
case ParameterType_Float: case ParameterType_Float:
case ParameterType_None: case ParameterType_None:
case ParameterType_Pointer: case ParameterType_Pointer:
@ -108,17 +106,62 @@ namespace Nz
} }
/*! /*!
* \brief Gets a float parameter by name * \brief Gets a parameter as a color
* \return true if success * \return true if the parameter could be represented as a color
* *
* \param name Name of the variable * \param name Name of the parameter
* \param value Value to set * \param value Pointer to a color to hold the retrieved value
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark value must be a valid pointer
* \remark Produces a silent NazaraError if name is not a variable * \remark In case of failure, the variable pointed by value keep its value
* \remark Produces a silent NazaraError if value could not be convertible * \remark If the parameter is not a color, the function fails
*/ */
bool ParameterList::GetColorParameter(const String& name, Color* value) const
{
NazaraAssert(value, "Invalid pointer");
ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
auto it = m_parameters.find(name);
if (it == m_parameters.end())
{
NazaraError("Parameter \"" + name + "\" is not present");
return false;
}
switch (it->second.type)
{
case ParameterType_Color:
*value = it->second.value.colorVal;
return true;
case ParameterType_Boolean:
case ParameterType_Integer:
case ParameterType_String:
case ParameterType_Float:
case ParameterType_None:
case ParameterType_Pointer:
case ParameterType_Userdata:
break;
}
NazaraError("Parameter value is not representable as a color");
return false;
}
/*!
* \brief Gets a parameter as a float
* \return true if the parameter could be represented as a float
*
* \param name Name of the parameter
* \param value Pointer to a float to hold the retrieved value
*
* \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 float, a conversion will be performed, compatibles types are:
Integer: The integer value is converted to its float representation
String: Conversion obeys the rule as described by String::ToDouble
*/
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");
@ -164,19 +207,21 @@ namespace Nz
NazaraError("Parameter value is not representable as a float"); NazaraError("Parameter value is not representable as a float");
return false; return false;
} }
/*! /*!
* \brief Gets a integer parameter by name * \brief Gets a parameter as an integer
* \return true if success * \return true if the parameter could be represented as an integer
* *
* \param name Name of the variable * \param name Name of the parameter
* \param value Value to set * \param value Pointer to an integer to hold the retrieved value
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark value must be a valid pointer
* \remark Produces a silent NazaraError if name is not a variable * \remark In case of failure, the variable pointed by value keep its value
* \remark Produces a silent NazaraError if value could not be convertible * \remark If the parameter is not a float, a conversion will be performed, compatibles types are:
Boolean: The boolean is represented as 1 if true and 0 if false
Float: The floating-point value is truncated and converted to a integer
String: Conversion obeys the rule as described by String::ToInteger but fails if the value could not be represented as a int
*/ */
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");
@ -229,15 +274,14 @@ namespace Nz
} }
/*! /*!
* \brief Gets a parameter type by name * \brief Gets a parameter type
* \return true if the parameter is present * \return true if the parameter is present, its type being written to type
* *
* \param name Name of the variable * \param name Name of the variable
* \param type Pointer to a variable to hold result * \param type Pointer to a variable to hold the result
* *
* \remark Produces a NazaraAssert if type is invalid * \remark type must be a valid pointer to a ParameterType variable
*/ */
bool ParameterList::GetParameterType(const String& name, ParameterType* type) const bool ParameterList::GetParameterType(const String& name, ParameterType* type) const
{ {
NazaraAssert(type, "Invalid pointer"); NazaraAssert(type, "Invalid pointer");
@ -252,17 +296,17 @@ namespace Nz
} }
/*! /*!
* \brief Gets a pointer parameter by name * \brief Gets a parameter as a pointer
* \return true if success * \return true if the parameter could be represented as a pointer
* *
* \param name Name of the variable * \param name Name of the parameter
* \param value Value to set * \param value Pointer to a pointer to hold the retrieved value
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark value must be a valid pointer
* \remark Produces a silent NazaraError if name is not a variable * \remark In case of failure, the variable pointed by value keep its value
* \remark Produces a silent NazaraError if value could not be convertible * \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 String& name, void** value) const bool ParameterList::GetPointerParameter(const String& name, void** value) const
{ {
NazaraAssert(value, "Invalid pointer"); NazaraAssert(value, "Invalid pointer");
@ -299,17 +343,23 @@ namespace Nz
} }
/*! /*!
* \brief Gets a string parameter by name * \brief Gets a parameter as a string
* \return true if success * \return true if the parameter could be represented as a string
* *
* \param name Name of the variable * \param name Name of the parameter
* \param value Value to set * \param value Pointer to a pointer to hold the retrieved value
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark value must be a valid pointer
* \remark Produces a silent NazaraError if name is not a variable * \remark In case of failure, the variable pointed by value keep its value
* \remark Produces a silent NazaraError if value could not be convertible * \remark If the parameter is not a string, a conversion will be performed, all types are compatibles:
Boolean: Conversion obeys the rules of String::Boolean
Color: Conversion obeys the rules of Color::ToString
Float: Conversion obeys the rules of String::Number
Integer: Conversion obeys the rules of String::Number
None: An empty string is returned
Pointer: Conversion obeys the rules of String::Pointer
Userdata: Conversion obeys the rules of String::Pointer
*/ */
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");
@ -329,6 +379,10 @@ namespace Nz
*value = String::Boolean(it->second.value.boolVal); *value = String::Boolean(it->second.value.boolVal);
return true; return true;
case ParameterType_Color:
*value = it->second.value.colorVal.ToString();
return true;
case ParameterType_Float: case ParameterType_Float:
*value = String::Number(it->second.value.floatVal); *value = String::Number(it->second.value.floatVal);
return true; return true;
@ -357,19 +411,20 @@ namespace Nz
NazaraInternalError("Parameter value is not valid"); NazaraInternalError("Parameter value is not valid");
return false; return false;
} }
/*! /*!
* \brief Gets a user parameter by name * \brief Gets a parameter as an userdata
* \return true if success * \return true if the parameter could be represented as a userdata
* *
* \param name Name of the variable * \param name Name of the parameter
* \param value Value to set * \param value Pointer to a pointer to hold the retrieved value
* *
* \remark Produces a NazaraAssert if pointer is invalid * \remark value must be a valid pointer
* \remark Produces a silent NazaraError if name is not a variable * \remark In case of failure, the variable pointed by value keep its value
* \remark Produces a silent NazaraError if value could not be convertible * \remark If the parameter is not an userdata, the function fails
*
* \see GetPointerParameter
*/ */
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");
@ -396,25 +451,24 @@ namespace Nz
} }
/*! /*!
* \brief Checks whether the parameter list has a parameter with that name * \brief Checks whether the parameter list contains a parameter named `name`
* \return true if found * \return true if found
* *
* \param name Name of the parameter * \param name Name of the parameter
*/ */
bool ParameterList::HasParameter(const String& name) const bool ParameterList::HasParameter(const String& name) const
{ {
return m_parameters.find(name) != m_parameters.end(); return m_parameters.find(name) != m_parameters.end();
} }
/*! /*!
* \brief Removes the parameter with that name * \brief Removes the parameter named `name`
* *
* Removes the parameter with that name, if not found, nothing is done * Search for a parameter named `name` and remove it from the parameter list, freeing up its memory
* Nothing is done if the parameter is not present in the parameter list
* *
* \param name Name of the parameter * \param name Name of the parameter
*/ */
void ParameterList::RemoveParameter(const String& name) void ParameterList::RemoveParameter(const String& name)
{ {
auto it = m_parameters.find(name); auto it = m_parameters.find(name);
@ -426,11 +480,12 @@ namespace Nz
} }
/*! /*!
* \brief Sets the parameter with the name to ParameterType_None * \brief Sets a null parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
* *
* \param name Name of the parameter * \param name Name of the parameter
*/ */
void ParameterList::SetParameter(const String& name) void ParameterList::SetParameter(const String& name)
{ {
Parameter& parameter = CreateValue(name); Parameter& parameter = CreateValue(name);
@ -438,12 +493,29 @@ namespace Nz
} }
/*! /*!
* \brief Sets the parameter with the name to the value * \brief Sets a color parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
* *
* \param name Name of the parameter * \param name Name of the parameter
* \param value Value of the parameter * \param value The color value
*/ */
void ParameterList::SetParameter(const String& name, const Color& value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Color;
PlacementNew(&parameter.value.colorVal, value);
}
/*!
* \brief Sets a string parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
*
* \param name Name of the parameter
* \param value The string value
*/
void ParameterList::SetParameter(const String& name, const String& value) void ParameterList::SetParameter(const String& name, const String& value)
{ {
Parameter& parameter = CreateValue(name); Parameter& parameter = CreateValue(name);
@ -453,12 +525,13 @@ namespace Nz
} }
/*! /*!
* \brief Sets the parameter with the name to the value * \brief Sets a string parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
* *
* \param name Name of the parameter * \param name Name of the parameter
* \param value Value of the parameter * \param value The string value
*/ */
void ParameterList::SetParameter(const String& name, const char* value) void ParameterList::SetParameter(const String& name, const char* value)
{ {
Parameter& parameter = CreateValue(name); Parameter& parameter = CreateValue(name);
@ -468,41 +541,13 @@ namespace Nz
} }
/*! /*!
* \brief Sets the parameter with the name to the value * \brief Sets a boolean parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
* *
* \param name Name of the parameter * \param name Name of the parameter
* \param value Value of the parameter * \param value The boolean value
*/ */
void ParameterList::SetParameter(const String& name, void* value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Pointer;
parameter.value.ptrVal = value;
}
/*!
* \brief Sets the parameter with the name to the value
*
* \param name Name of the parameter
* \param value Value of the parameter
* \param destructor Destructor for dynamic variable
*/
void ParameterList::SetParameter(const String& name, void* value, Destructor destructor)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Userdata;
parameter.value.userdataVal = new Parameter::UserdataValue(destructor, value);
}
/*!
* \brief Sets the parameter with the name to the value
*
* \param name Name of the parameter
* \param value Value of the parameter
*/
void ParameterList::SetParameter(const String& name, bool value) void ParameterList::SetParameter(const String& name, bool value)
{ {
Parameter& parameter = CreateValue(name); Parameter& parameter = CreateValue(name);
@ -511,12 +556,13 @@ namespace Nz
} }
/*! /*!
* \brief Sets the parameter with the name to the value * \brief Sets a float parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
* *
* \param name Name of the parameter * \param name Name of the parameter
* \param value Value of the parameter * \param value The float value
*/ */
void ParameterList::SetParameter(const String& name, float value) void ParameterList::SetParameter(const String& name, float value)
{ {
Parameter& parameter = CreateValue(name); Parameter& parameter = CreateValue(name);
@ -525,26 +571,63 @@ namespace Nz
} }
/*! /*!
* \brief Sets the parameter with the name to the value * \brief Sets an integer parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
* *
* \param name Name of the parameter * \param name Name of the parameter
* \param value Value of the parameter * \param value The integer value
*/ */
void ParameterList::SetParameter(const String& name, int value) void ParameterList::SetParameter(const String& name, int value)
{ {
Parameter& parameter = CreateValue(name); Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Integer; parameter.type = ParameterType_Integer;
parameter.value.intVal = value; parameter.value.intVal = value;
} }
/*!
* \brief Sets a pointer parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
*
* \param name Name of the parameter
* \param value The pointer value
*
* \remark This sets a raw pointer, this class takes no responsibility toward it,
if you wish to destroy the pointed variable along with the parameter list, you should set a userdata
*/
void ParameterList::SetParameter(const String& name, void* value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Pointer;
parameter.value.ptrVal = value;
}
/*! /*!
* \brief Assigns the content of the other parameter list to this * \brief Sets a userdata parameter named `name`
*
* If a parameter already exists with that name, it is destroyed and replaced by this call
*
* \param name Name of the parameter
* \param value The pointer value
* \param destructor The destructor function to be called upon parameter suppression
*
* \remark The destructor is called once when all copies of the userdata are destroyed, which means
you can safely copy the parameter list around.
*/
void ParameterList::SetParameter(const String& name, void* value, Destructor destructor)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Userdata;
parameter.value.userdataVal = new Parameter::UserdataValue(destructor, value);
}
/*!
* \brief Copies the content of the other parameter list to this
* \return A reference to this * \return A reference to this
* *
* \param list List to assign * \param list List to assign
*/ */
ParameterList& ParameterList::operator=(const ParameterList& list) ParameterList& ParameterList::operator=(const ParameterList& list)
{ {
Clear(); Clear();
@ -627,6 +710,7 @@ namespace Nz
} }
case ParameterType_Boolean: case ParameterType_Boolean:
case ParameterType_Color:
case ParameterType_Float: case ParameterType_Float:
case ParameterType_Integer: case ParameterType_Integer:
case ParameterType_None: case ParameterType_None: