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

Various fixes

Browse Source 
Former-commit-id: 26dfbdb3388c845a6e3039f816f19ffbb462d7b8 [formerly a6437e0b6e48dbd630440f8d2629b32e4756b48e]
Former-commit-id: 8a1855fc1d4d7c343b7e1fdcd3c6a31f3134a59a
This commit is contained in:
Gawaboumga
2016-07-28 19:22:41 +02:00
parent 84c26ee77d
commit 96dc8c001e
26 changed files with 141 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/Nazara/Core/Algorithm.inl
View File

@@ -78,7 +78,7 @@ namespace Nz
* \param v Object to hash
*
* \remark a HashAppend specialization for type T is required
*
*
* \see ComputeHash
*/
template<typename T>
@@ -124,6 +124,7 @@ namespace Nz
template<typename T, std::size_t N>
constexpr std::size_t CountOf(T(&name)[N]) noexcept
{
NazaraUnused(name);
return N;
}

38
include/Nazara/Core/ByteArray.inl
View File

@@ -23,10 +23,10 @@ namespace Nz
/*!
* \brief Constructs a ByteArray object with a raw memory and a size
*
* \param ptr Pointer to raw memory
* \param buffer Pointer to raw memory
* \param n Size that can be accessed
*
* \remark If preallocated space of ptr is less than the size, the behaviour is undefined
* \remark If preallocated space of buffer is less than the size, the behaviour is undefined
*/
inline ByteArray::ByteArray(const void* buffer, size_type n) :
@@ -62,10 +62,10 @@ namespace Nz
/*!
* \brief Appends the content of raw memory
*
* \param ptr Constant pointer to raw memory
* \param buffer Constant pointer to raw memory
* \param n Size that can be read
*
* \remark If preallocated space of ptr is less than the size, the behaviour is undefined
* \remark If preallocated space of buffer is less than the size, the behaviour is undefined
*
* \see Insert
*/
@@ -298,11 +298,11 @@ namespace Nz
}
/*!
* \brief Inserts n times the same value at the iterator position
* \brief Inserts n times the same byte at the iterator position
*
* \param pos Iterator to the position
* \param n Number of repetitions
* \param value Value to repeat
* \param byte Value to repeat
*/
inline ByteArray::iterator ByteArray::Insert(const_iterator pos, size_type n, value_type byte)
@@ -359,10 +359,10 @@ namespace Nz
/*!
* \brief Prepends the content of raw memory
*
* \param ptr Constant pointer to raw memory
* \param buffer Constant pointer to raw memory
* \param n Size that can be read
*
* \remark If preallocated space of ptr is less than the size, the behaviour is undefined
* \remark If preallocated space of buffer is less than the size, the behaviour is undefined
*
* \see Insert
*/
@@ -682,8 +682,7 @@ namespace Nz
* \brief Checks whether the first byte array is equal to the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator==(const ByteArray& rhs) const
@@ -695,8 +694,7 @@ namespace Nz
* \brief Checks whether the first byte array is equal to the second byte array
* \return false if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator!=(const ByteArray& rhs) const
@@ -708,8 +706,7 @@ namespace Nz
* \brief Checks whether the first byte array is less than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator<(const ByteArray& rhs) const
@@ -721,8 +718,7 @@ namespace Nz
* \brief Checks whether the first byte array is less or equal than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator<=(const ByteArray& rhs) const
@@ -731,11 +727,10 @@ namespace Nz
}
/*!
* \brief Checks whether the first byte array is greather than the second byte array
* \brief Checks whether the first byte array is greater than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator>(const ByteArray& rhs) const
@@ -744,11 +739,10 @@ namespace Nz
}
/*!
* \brief Checks whether the first byte array is greather or equal than the second byte array
* \brief Checks whether the first byte array is greater or equal than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator>=(const ByteArray& rhs) const

75
include/Nazara/Core/ObjectHandle.inl
View File

@@ -291,15 +291,16 @@ namespace Nz
template<typename T>
std::ostream& operator<<(std::ostream& out, const ObjectHandle<T>& handle)
{
return handle.ToString();
out << handle.ToString();
return out;
}
/*!
* \brief Checks whether the first object handle is equal to the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@@ -311,8 +312,8 @@ namespace Nz
* \brief Checks whether the object is equal to the second object handle
* \return true if it is the case
*
* \param first Object to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs Object to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator==(const T& lhs, const ObjectHandle<T>& rhs)
@@ -324,8 +325,8 @@ namespace Nz
* \brief Checks whether the object handle is equal to the second object
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second Object to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectHandle<T>& lhs, const T& rhs)
@@ -337,8 +338,8 @@ namespace Nz
* \brief Checks whether the first object handle is equal to the second object handle
* \return false if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@@ -350,8 +351,8 @@ namespace Nz
* \brief Checks whether the object is equal to the second object handle
* \return false if it is the case
*
* \param first Object to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs Object to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator!=(const T& lhs, const ObjectHandle<T>& rhs)
@@ -363,8 +364,8 @@ namespace Nz
* \brief Checks whether the object handle is equal to the second object
* \return false if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second Object to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectHandle<T>& lhs, const T& rhs)
@@ -376,8 +377,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@@ -389,8 +390,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<(const T& lhs, const ObjectHandle<T>& rhs)
@@ -402,8 +403,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectHandle<T>& lhs, const T& rhs)
@@ -415,8 +416,8 @@ namespace Nz
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@@ -428,8 +429,8 @@ namespace Nz
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<=(const T& lhs, const ObjectHandle<T>& rhs)
@@ -441,8 +442,8 @@ namespace Nz
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectHandle<T>& lhs, const T& rhs)
@@ -454,8 +455,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@@ -467,8 +468,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>(const T& lhs, const ObjectHandle<T>& rhs)
@@ -480,8 +481,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectHandle<T>& lhs, const T& rhs)
@@ -493,8 +494,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@@ -506,8 +507,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>=(const T& lhs, const ObjectHandle<T>& rhs)
@@ -519,8 +520,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectHandle<T>& lhs, const T& rhs)

74
include/Nazara/Core/ObjectRef.inl
View File

@@ -184,7 +184,7 @@ namespace Nz
{
return m_object;
}
/*!
* \brief Assigns the object into this
* \return A reference to this
@@ -251,8 +251,8 @@ namespace Nz
* \brief Checks whether the first object handle is equal to the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@@ -264,8 +264,8 @@ namespace Nz
* \brief Checks whether the object is equal to the second object handle
* \return true if it is the case
*
* \param first Object to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs Object to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator==(const T& lhs, const ObjectRef<T>& rhs)
@@ -277,8 +277,8 @@ namespace Nz
* \brief Checks whether the object handle is equal to the second object
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second Object to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectRef<T>& lhs, const T& rhs)
@@ -290,8 +290,8 @@ namespace Nz
* \brief Checks whether the first object handle is equal to the second object handle
* \return false if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@@ -303,8 +303,8 @@ namespace Nz
* \brief Checks whether the object is equal to the second object handle
* \return false if it is the case
*
* \param first Object to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs Object to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator!=(const T& lhs, const ObjectRef<T>& rhs)
@@ -316,8 +316,8 @@ namespace Nz
* \brief Checks whether the object handle is equal to the second object
* \return false if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second Object to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectRef<T>& lhs, const T& rhs)
@@ -329,8 +329,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@@ -342,8 +342,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const T& lhs, const ObjectRef<T>& rhs)
@@ -355,8 +355,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectRef<T>& lhs, const T& rhs)
@@ -368,8 +368,8 @@ namespace Nz
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@@ -381,8 +381,8 @@ namespace Nz
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const T& lhs, const ObjectRef<T>& rhs)
@@ -394,8 +394,8 @@ namespace Nz
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectRef<T>& lhs, const T& rhs)
@@ -407,8 +407,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@@ -420,8 +420,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const T& lhs, const ObjectRef<T>& rhs)
@@ -433,8 +433,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectRef<T>& lhs, const T& rhs)
@@ -446,8 +446,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@@ -459,8 +459,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const T& lhs, const ObjectRef<T>& rhs)
@@ -472,8 +472,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectRef<T>& lhs, const T& rhs)

15
include/Nazara/Core/String.inl
View File

@@ -45,7 +45,7 @@ namespace Nz
*/
inline String::SharedString::SharedString(std::size_t strSize) :
capacity(strSize),
capacity(strSize),
size(strSize),
string(new char[strSize + 1])
{
@@ -84,16 +84,15 @@ namespace Nz
namespace std
{
/*!
* \brief Specialisation of std to hash
* \return Result of the hash
*
* \param str String to hash
*/
template<>
struct hash<Nz::String>
{
/*!
* \brief Specialisation of std to hash
* \return Result of the hash
*
* \param str String to hash
*/
size_t operator()(const Nz::String& str) const
{
// Algorithme DJB2