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

Merge branch 'NDK' into NDK-ShadowMapping

Browse Source 
Conflicts:
	include/Nazara/Math/Matrix4.inl

Former-commit-id: e4b7d178a7acba17c03de2b585af86324b8d75a6
This commit is contained in:
Lynix
2015-09-13 12:10:30 +02:00
parent 0bdfa995b0 9f1c190985
commit aa303f9028
100 changed files with 3553 additions and 1359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/Nazara/Core/Algorithm.hpp
View File

@@ -11,8 +11,12 @@
#include <functional>
#include <tuple>
template<typename F, typename Tuple> auto NzApply(F&& fn, Tuple&& t);
template<typename O, typename F, typename Tuple> auto NzApply(O& object, F&& fn, Tuple&& t);
template<typename T> void NzHashCombine(std::size_t& seed, const T& v);
template<typename F, typename... ArgsT> void NzUnpackTuple(F func, const std::tuple<ArgsT...>& t);
template<typename T>
struct NzTypeTag {};
#include <Nazara/Core/Algorithm.inl>

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

@@ -8,28 +8,34 @@
#include <Nazara/Core/Debug.hpp>
///TODO: Améliorer l'implémentation de UnpackTuple
template<unsigned int N>
struct NzImplTupleUnpack
// http://www.cppsamples.com/common-tasks/apply-tuple-to-function.html
template<typename F, typename Tuple, size_t... S>
auto NzApplyImplFunc(F&& fn, Tuple&& t, std::index_sequence<S...>)
{
template <typename F, typename... ArgsT, typename... Args>
void operator()(F func, const std::tuple<ArgsT...>& t, Args&... args)
{
NzImplTupleUnpack<N-1>()(func, t, std::get<N-1>(t), args...);
}
};
return std::forward<F>(fn)(std::get<S>(std::forward<Tuple>(t))...);
}
template<>
struct NzImplTupleUnpack<0>
template<typename F, typename Tuple>
auto NzApply(F&& fn, Tuple&& t)
{
template <typename F, typename... ArgsT, typename... Args>
void operator()(F func, const std::tuple<ArgsT...>&, Args&... args)
{
func(args...);
}
};
constexpr std::size_t tSize = std::tuple_size<typename std::remove_reference<Tuple>::type>::value;
return NzApplyImplFunc(std::forward<F>(fn), std::forward<Tuple>(t), std::make_index_sequence<tSize>());
}
template<typename O, typename F, typename Tuple, size_t... S>
auto NzApplyImplMethod(O& object, F&& fn, Tuple&& t, std::index_sequence<S...>)
{
return (object .* std::forward<F>(fn))(std::get<S>(std::forward<Tuple>(t))...);
}
template<typename O, typename F, typename Tuple>
auto NzApply(O& object, F&& fn, Tuple&& t)
{
constexpr std::size_t tSize = std::tuple_size<typename std::remove_reference<Tuple>::type>::value;
return NzApplyImplMethod(object, std::forward<F>(fn), std::forward<Tuple>(t), std::make_index_sequence<tSize>());
}
// Algorithme venant de CityHash par Google
// http://stackoverflow.com/questions/8513911/how-to-create-a-good-hash-combine-with-64-bit-output-inspired-by-boosthash-co
template<typename T>
@@ -47,10 +53,4 @@ void NzHashCombine(std::size_t& seed, const T& v)
seed = static_cast<std::size_t>(b * kMul);
}
template<typename F, typename... ArgsT>
void NzUnpackTuple(F func, const std::tuple<ArgsT...>& t)
{
NzImplTupleUnpack<sizeof...(ArgsT)>()(func, t);
}
#include <Nazara/Core/DebugOff.hpp>

180
include/Nazara/Core/ByteArray.hpp
View File

@@ -8,120 +8,132 @@
#define NAZARA_BYTEARRAY_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Config.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Hashable.hpp>
#include <atomic>
#include <Nazara/Core/String.hpp>
#include <vector>
class NzAbstractHash;
class NzHashDigest;
class NAZARA_CORE_API NzByteArray : public NzHashable
{
using Container = std::vector<nzUInt8>;
public:
struct SharedArray;
// types:
using allocator_type = Container::allocator_type;
using const_iterator = Container::const_iterator;
using const_reference = Container::const_reference;
using const_pointer = Container::const_pointer;
using const_reverse_iterator = Container::const_reverse_iterator;
using difference_type = Container::difference_type;
using pointer = Container::pointer;
using iterator = Container::iterator;
using reference = Container::reference;
using reverse_iterator = Container::reverse_iterator;
using size_type = Container::size_type;
using value_type = Container::value_type;
NzByteArray();
explicit NzByteArray(unsigned int size);
NzByteArray(const void* buffer, unsigned int size);
NzByteArray(const NzByteArray& buffer);
NzByteArray(NzByteArray&& buffer) noexcept;
NzByteArray(SharedArray* sharedArray);
~NzByteArray();
// construct/destroy:
inline NzByteArray() = default;
inline explicit NzByteArray(size_type n);
inline NzByteArray(const void* buffer, size_type n);
inline NzByteArray(size_type n, value_type value);
template <class InputIterator> NzByteArray(InputIterator first, InputIterator last);
NzByteArray(const NzByteArray& other) = default;
NzByteArray(NzByteArray&& other) = default;
~NzByteArray() = default;
NzByteArray& Append(const void* buffer, unsigned int size);
NzByteArray& Append(const NzByteArray& array);
inline iterator Append(const void* buffer, size_type size);
inline iterator Append(const NzByteArray& other);
template <class InputIterator> void Assign(InputIterator first, InputIterator last);
inline void Assign(size_type n, value_type value);
void Clear(bool keepBuffer = false);
inline reference Back();
inline const_reference Back() const;
nzUInt8* GetBuffer();
unsigned int GetCapacity() const;
const nzUInt8* GetConstBuffer() const;
unsigned int GetSize() const;
inline void Clear(bool keepBuffer = false);
NzByteArray& Insert(int pos, const void* buffer, unsigned int size);
NzByteArray& Insert(int pos, const NzByteArray& array);
inline iterator Erase(const_iterator pos);
inline iterator Erase(const_iterator first, const_iterator last);
bool IsEmpty() const;
inline reference Front();
inline const_reference Front() const;
NzByteArray& Prepend(const void* buffer, unsigned int size);
NzByteArray& Prepend(const NzByteArray& array);
inline allocator_type GetAllocator() const;
inline pointer GetBuffer();
inline size_type GetCapacity() const noexcept;
inline const_pointer GetConstBuffer() const;
inline size_type GetMaxSize() const noexcept;
inline size_type GetSize() const noexcept;
inline NzByteArray GetSubArray(const_iterator startPos, const_iterator endPos) const;
void Reserve(unsigned int bufferSize);
inline iterator Insert(const_iterator pos, const void* buffer, size_type n);
inline iterator Insert(const_iterator pos, const NzByteArray& other);
inline iterator Insert(const_iterator pos, size_type n, value_type byte);
template <class InputIterator> iterator Insert(const_iterator pos, InputIterator first, InputIterator last);
inline bool IsEmpty() const noexcept;
NzByteArray& Resize(int size);
NzByteArray& Resize(int size, nzUInt8 byte);
NzByteArray Resized(int size) const;
NzByteArray Resized(int size, nzUInt8 byte) const;
inline void PopBack();
inline void PopFront();
inline iterator Prepend(const void* buffer, size_type size);
inline iterator Prepend(const NzByteArray& other);
inline void PushBack(value_type byte);
inline void PushFront(value_type byte);
NzByteArray SubArray(int startPos, int endPos = -1) const;
inline void Reserve(size_type bufferSize);
inline void Resize(size_type newSize);
inline void Resize(size_type newSize, value_type byte);
void Swap(NzByteArray& array);
inline void ShrinkToFit();
inline void Swap(NzByteArray& other);
// Méthodes compatibles STD
nzUInt8* begin();
const nzUInt8* begin() const;
nzUInt8* end();
const nzUInt8* end() const;
void push_front(nzUInt8 byte);
void push_back(nzUInt8 byte);
/*nzUInt8* rbegin();
const nzUInt8* rbegin() const;
nzUInt8* rend();
const nzUInt8* rend() const;*/
inline NzString ToString() const;
typedef const nzUInt8& const_reference;
typedef nzUInt8* iterator;
//typedef nzUInt8* reverse_iterator;
typedef nzUInt8 value_type;
// Méthodes compatibles STD
// STL interface
inline iterator begin() noexcept;
inline const_iterator begin() const noexcept;
inline bool empty() const noexcept;
inline iterator end() noexcept;
inline const_iterator end() const noexcept;
inline reverse_iterator rbegin() noexcept;
inline const_reverse_iterator rbegin() const noexcept;
inline reverse_iterator rend() noexcept;
inline const_reverse_iterator rend() const noexcept;
inline const_iterator cbegin() const noexcept;
inline const_iterator cend() const noexcept;
inline const_reverse_iterator crbegin() const noexcept;
inline const_reverse_iterator crend() const noexcept;
inline size_type size() const noexcept;
nzUInt8& operator[](unsigned int pos);
nzUInt8 operator[](unsigned int pos) const;
// Operators
inline reference operator[](size_type pos);
inline const_reference operator[](size_type pos) const;
inline NzByteArray& operator=(const NzByteArray& array) = default;
inline NzByteArray& operator=(NzByteArray&& array) = default;
inline NzByteArray operator+(const NzByteArray& array) const;
inline NzByteArray& operator+=(const NzByteArray& array);
NzByteArray& operator=(const NzByteArray& array);
NzByteArray& operator=(NzByteArray&& array) noexcept;
NzByteArray operator+(const NzByteArray& array) const;
NzByteArray& operator+=(const NzByteArray& array);
static int Compare(const NzByteArray& first, const NzByteArray& second);
struct NAZARA_CORE_API SharedArray
{
SharedArray() :
refCount(1)
{
}
SharedArray(unsigned short referenceCount, unsigned int bufferSize, unsigned int arraySize, nzUInt8* ptr) :
capacity(bufferSize),
size(arraySize),
buffer(ptr),
refCount(referenceCount)
{
}
unsigned int capacity;
unsigned int size;
nzUInt8* buffer;
std::atomic_ushort refCount;
};
static SharedArray emptyArray;
static unsigned int npos;
inline bool operator==(const NzByteArray& rhs) const;
inline bool operator!=(const NzByteArray& rhs) const;
inline bool operator<(const NzByteArray& rhs) const;
inline bool operator<=(const NzByteArray& rhs) const;
inline bool operator>(const NzByteArray& rhs) const;
inline bool operator>=(const NzByteArray& rhs) const;
private:
void EnsureOwnership();
bool FillHash(NzAbstractHash* hash) const;
void ReleaseArray();
SharedArray* m_sharedArray;
Container m_array;
};
NAZARA_CORE_API std::ostream& operator<<(std::ostream& out, const NzByteArray& byteArray);
namespace std
{
NAZARA_CORE_API void swap(NzByteArray& lhs, NzByteArray& rhs);
void swap(NzByteArray& lhs, NzByteArray& rhs);
}
#include <Nazara/Core/ByteArray.inl>
#endif // NAZARA_BYTEARRAY_HPP

319
include/Nazara/Core/ByteArray.inl Normal file
View File

@@ -0,0 +1,319 @@
// Copyright (C) 2015 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
inline NzByteArray::NzByteArray(size_type n) :
m_array()
{
m_array.reserve(n);
}
inline NzByteArray::NzByteArray(const void* buffer, size_type n) :
m_array(static_cast<const_pointer>(buffer), static_cast<const_pointer>(buffer) + n)
{
}
inline NzByteArray::NzByteArray(size_type n, const value_type value) :
m_array(n, value)
{
}
template <class InputIterator>
NzByteArray::NzByteArray(InputIterator first, InputIterator last) :
m_array(first, last)
{
}
inline NzByteArray::iterator NzByteArray::Append(const void* buffer, size_type n)
{
return Insert(end(), static_cast<const_pointer>(buffer), static_cast<const_pointer>(buffer) + n);
}
inline NzByteArray::iterator NzByteArray::Append(const NzByteArray& other)
{
return Insert(end(), other.begin(), other.end());
}
inline void NzByteArray::Assign(size_type n, value_type value)
{
m_array.assign(n, value);
}
template <class InputIterator>
void NzByteArray::Assign(InputIterator first, InputIterator last)
{
m_array.assign(first, last);
}
inline NzByteArray::reference NzByteArray::Back()
{
return m_array.back();
}
inline NzByteArray::const_reference NzByteArray::Back() const
{
return m_array.back();
}
inline NzByteArray::iterator NzByteArray::Erase(const_iterator pos)
{
return m_array.erase(pos);
}
inline NzByteArray::iterator NzByteArray::Erase(const_iterator first, const_iterator last)
{
return m_array.erase(first, last);
}
inline NzByteArray::allocator_type NzByteArray::GetAllocator() const
{
return m_array.get_allocator();
}
inline NzByteArray::pointer NzByteArray::GetBuffer()
{
return m_array.data();
}
inline NzByteArray::size_type NzByteArray::GetCapacity() const noexcept
{
return m_array.capacity();
}
inline NzByteArray::const_pointer NzByteArray::GetConstBuffer() const
{
return m_array.data();
}
inline NzByteArray::size_type NzByteArray::GetMaxSize() const noexcept
{
return m_array.max_size();
}
inline NzByteArray::size_type NzByteArray::GetSize() const noexcept
{
return m_array.size();
}
inline NzByteArray NzByteArray::GetSubArray(const_iterator startPos, const_iterator endPos) const
{
return NzByteArray(startPos, endPos);
}
inline NzByteArray::iterator NzByteArray::Insert(const_iterator pos, const void* buffer, size_type n)
{
return m_array.insert(pos, static_cast<const_pointer>(buffer), static_cast<const_pointer>(buffer) + n);
}
inline NzByteArray::iterator NzByteArray::Insert(const_iterator pos, const NzByteArray& other)
{
return m_array.insert(pos, other.begin(), other.end());
}
inline NzByteArray::iterator NzByteArray::Insert(const_iterator pos, size_type n, value_type byte)
{
return m_array.insert(pos, n, byte);
}
template <class InputIterator>
NzByteArray::iterator NzByteArray::Insert(const_iterator pos, InputIterator first, InputIterator last)
{
return m_array.insert(pos, first, last);
}
inline bool NzByteArray::IsEmpty() const noexcept
{
return m_array.empty();
}
inline void NzByteArray::PopBack()
{
Erase(end() - 1);
}
inline void NzByteArray::PopFront()
{
Erase(begin());
}
inline NzByteArray::iterator NzByteArray::Prepend(const void* buffer, size_type n)
{
return Insert(begin(), buffer, n);
}
inline NzByteArray::iterator NzByteArray::Prepend(const NzByteArray& other)
{
return Insert(begin(), other);
}
inline void NzByteArray::PushBack(const value_type byte)
{
m_array.push_back(byte);
}
inline void NzByteArray::PushFront(const value_type byte)
{
m_array.insert(begin(), 1, byte);
}
inline void NzByteArray::Reserve(size_type bufferSize)
{
m_array.reserve(bufferSize);
}
inline void NzByteArray::Resize(size_type newSize)
{
m_array.resize(newSize);
}
inline void NzByteArray::Resize(size_type newSize, const value_type byte)
{
m_array.resize(newSize, byte);
}
inline void NzByteArray::ShrinkToFit()
{
m_array.shrink_to_fit();
}
inline void NzByteArray::Swap(NzByteArray& other)
{
m_array.swap(other.m_array);
}
inline NzString NzByteArray::ToString() const
{
return NzString(reinterpret_cast<const char*>(GetConstBuffer()), GetSize());
}
inline NzByteArray::iterator NzByteArray::begin() noexcept
{
return m_array.begin();
}
inline NzByteArray::const_iterator NzByteArray::begin() const noexcept
{
return m_array.begin();
}
inline NzByteArray::const_iterator NzByteArray::cbegin() const noexcept
{
return m_array.cbegin();
}
inline NzByteArray::const_iterator NzByteArray::cend() const noexcept
{
return m_array.cend();
}
inline NzByteArray::const_reverse_iterator NzByteArray::crbegin() const noexcept
{
return m_array.crbegin();
}
inline NzByteArray::const_reverse_iterator NzByteArray::crend() const noexcept
{
return m_array.crend();
}
inline bool NzByteArray::empty() const noexcept
{
return m_array.empty();
}
inline NzByteArray::iterator NzByteArray::end() noexcept
{
return m_array.end();
}
inline NzByteArray::const_iterator NzByteArray::end() const noexcept
{
return m_array.end();
}
inline NzByteArray::reverse_iterator NzByteArray::rbegin() noexcept
{
return m_array.rbegin();
}
inline NzByteArray::const_reverse_iterator NzByteArray::rbegin() const noexcept
{
return m_array.rbegin();
}
inline NzByteArray::reverse_iterator NzByteArray::rend() noexcept
{
return m_array.rend();
}
inline NzByteArray::size_type NzByteArray::size() const noexcept
{
return GetSize();
}
inline NzByteArray::reference NzByteArray::operator[](size_type pos)
{
NazaraAssert(pos < GetSize(), "Index out of range");
return m_array[pos];
}
inline NzByteArray::const_reference NzByteArray::operator[](size_type pos) const
{
NazaraAssert(pos < GetSize(), "Index out of range");
return m_array[pos];
}
inline NzByteArray NzByteArray::operator+(const NzByteArray& other) const
{
NzByteArray tmp(*this);
tmp += other;
return tmp;
}
inline NzByteArray& NzByteArray::operator+=(const NzByteArray& other)
{
Append(other);
return *this;
}
inline bool NzByteArray::operator==(const NzByteArray& rhs) const
{
return m_array == rhs.m_array;
}
inline bool NzByteArray::operator!=(const NzByteArray& rhs) const
{
return !operator==(rhs);
}
inline bool NzByteArray::operator<(const NzByteArray& rhs) const
{
return m_array < rhs.m_array;
}
inline bool NzByteArray::operator<=(const NzByteArray& rhs) const
{
return m_array <= rhs.m_array;
}
inline bool NzByteArray::operator>(const NzByteArray& rhs) const
{
return m_array > rhs.m_array;
}
inline bool NzByteArray::operator>=(const NzByteArray& rhs) const
{
return m_array >= rhs.m_array;
}
namespace std
{
inline void swap(NzByteArray& lhs, NzByteArray& rhs)
{
lhs.Swap(rhs);
}
}

4
include/Nazara/Core/Color.inl
View File

@@ -317,8 +317,8 @@ inline void NzColor::ToHSV(const NzColor& color, float* hue, float* saturation,
float g = color.g / 255.f;
float b = color.b / 255.f;
float min = std::min(std::min(r, g), b); //Min. value of RGB
float max = std::max(std::max(r, g), b); //Max. value of RGB
float min = std::min({r, g, b}); //Min. value of RGB
float max = std::max({r, g, b}); //Max. value of RGB
float deltaMax = max - min; //Delta RGB value

3
include/Nazara/Core/ConditionVariable.hpp
View File

@@ -8,11 +8,12 @@
#define NAZARA_CONDITIONVARIABLE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/NonCopyable.hpp>
class NzConditionVariableImpl;
class NzMutex;
class NAZARA_CORE_API NzConditionVariable
class NAZARA_CORE_API NzConditionVariable : NzNonCopyable
{
public:
NzConditionVariable();

2
include/Nazara/Core/ConfigCheck.hpp
View File

@@ -15,7 +15,7 @@
// On force la valeur de MANAGE_MEMORY en mode debug
#if defined(NAZARA_DEBUG) && !NAZARA_CORE_MANAGE_MEMORY
#undef NAZARA_CORE_MANAGE_MEMORY
#define NAZARA_CORE_MANAGE_MEMORY 1
#define NAZARA_CORE_MANAGE_MEMORY 0
#endif
NazaraCheckTypeAndVal(NAZARA_CORE_DECIMAL_DIGITS, integral, >, 0, " shall be a strictly positive integer");

2
include/Nazara/Core/DynLib.hpp
View File

@@ -27,7 +27,7 @@
#include <Nazara/Core/ThreadSafetyOff.hpp>
#endif
using NzDynLibFunc = int (*)(); // Type "générique" de pointeur sur fonction
using NzDynLibFunc = int (*)(); // Type "générique" de pointeur sur fonction
class NzDynLibImpl;

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

@@ -15,6 +15,15 @@ enum nzCoordSys
nzCoordSys_Max = nzCoordSys_Local
};
enum nzCursorPosition
{
nzCursorPosition_AtBegin, // Début du fichier
nzCursorPosition_AtCurrent, // Position du pointeur
nzCursorPosition_AtEnd, // Fin du fichier
nzCursorPosition_Max = nzCursorPosition_AtEnd
};
enum nzEndianness
{
nzEndianness_Unknown = -1,
@@ -57,7 +66,24 @@ enum nzHash
nzHash_SHA256,
nzHash_SHA384,
nzHash_SHA512,
nzHash_Whirlpool
nzHash_Whirlpool,
nzHash_Max = nzHash_Whirlpool
};
enum nzOpenModeFlags
{
nzOpenMode_Current = 0x00, // Utilise le mode d'ouverture actuel
nzOpenMode_Append = 0x01, // Empêche l'écriture sur la partie déjà existante et met le curseur à la fin
nzOpenMode_Lock = 0x02, // Empêche le fichier d'être modifié tant qu'il est ouvert
nzOpenMode_ReadOnly = 0x04, // Ouvre uniquement en lecture
nzOpenMode_ReadWrite = 0x08, // Ouvre en lecture/écriture
nzOpenMode_Text = 0x10, // Ouvre en mode texte
nzOpenMode_Truncate = 0x20, // Créé le fichier s'il n'existe pas et le vide s'il existe
nzOpenMode_WriteOnly = 0x40, // Ouvre uniquement en écriture, créé le fichier s'il n'existe pas
nzOpenMode_Max = nzOpenMode_WriteOnly
};
enum nzParameterType

30
include/Nazara/Core/File.hpp
View File

@@ -23,34 +23,16 @@
#include <Nazara/Core/ThreadSafetyOff.hpp>
#endif
#include <ctime>
class NzFileImpl;
class NAZARA_CORE_API NzFile : public NzHashable, public NzInputStream, NzNonCopyable
{
public:
enum CursorPosition
{
AtBegin, // Début du fichier
AtCurrent, // Position du pointeur
AtEnd // Fin du fichier
};
enum OpenMode
{
Current = 0x00, // Utilise le mode d'ouverture actuel
Append = 0x01, // Empêche l'écriture sur la partie déjà existante et met le curseur à la fin
Lock = 0x02, // Empêche le fichier d'être modifié tant qu'il est ouvert
ReadOnly = 0x04, // Ouvre uniquement en lecture
ReadWrite = 0x08, // Ouvre en lecture/écriture
Text = 0x10, // Ouvre en mode texte
Truncate = 0x20, // Créé le fichier s'il n'existe pas et le vide s'il existe
WriteOnly = 0x40 // Ouvre uniquement en écriture, créé le fichier s'il n'existe pas
};
NzFile();
NzFile(const NzString& filePath);
NzFile(const NzString& filePath, unsigned long openMode);
NzFile(const NzString& filePath, unsigned int openMode);
NzFile(NzFile&& file) noexcept;
~NzFile();
@@ -77,14 +59,14 @@ class NAZARA_CORE_API NzFile : public NzHashable, public NzInputStream, NzNonCop
bool IsOpen() const;
bool Open(unsigned long openMode = Current);
bool Open(const NzString& filePath, unsigned long openMode = Current);
bool Open(unsigned int openMode = nzOpenMode_Current);
bool Open(const NzString& filePath, unsigned int openMode = nzOpenMode_Current);
std::size_t Read(void* buffer, std::size_t size);
std::size_t Read(void* buffer, std::size_t typeSize, unsigned int count);
bool Rename(const NzString& newFilePath);
bool SetCursorPos(CursorPosition pos, nzInt64 offset = 0);
bool SetCursorPos(nzCursorPosition pos, nzInt64 offset = 0);
bool SetCursorPos(nzUInt64 offset);
void SetEndianness(nzEndianness endianness);
bool SetFile(const NzString& filePath);

14
include/Nazara/Core/Format.hpp
View File

@@ -1,14 +0,0 @@
// Copyright (C) 2015 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_FORMAT_HPP
#define NAZARA_FORMAT_HPP
#include <Nazara/Core/String.hpp>
template<typename... Args> NzString NzFormat(const NzString& str, Args... args);
#endif // NAZARA_FORMAT_HPP

2
include/Nazara/Core/Functor.inl
View File

@@ -26,7 +26,7 @@ m_args(std::forward<Args>(args)...)
template<typename F, typename... Args>
void NzFunctorWithArgs<F, Args...>::Run()
{
NzUnpackTuple(m_func, m_args);
NzApply(m_func, m_args);
}

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

@@ -20,6 +20,7 @@ class NAZARA_CORE_API NzHardwareInfo
static unsigned int GetProcessorCount();
static nzProcessorVendor GetProcessorVendor();
static NzString GetProcessorVendorName();
static nzUInt64 GetTotalMemory();
static bool HasCapability(nzProcessorCap capability);

2
include/Nazara/Core/Mutex.hpp
View File

@@ -21,7 +21,9 @@ class NAZARA_CORE_API NzMutex : NzNonCopyable
~NzMutex();
void Lock();
bool TryLock();
void Unlock();
private:

2
include/Nazara/Core/ResourceLoader.inl
View File

@@ -57,7 +57,7 @@ bool NzResourceLoader<Type, Parameters>::LoadFromFile(Type* resource, const NzSt
if (checkFunc && !file.IsOpen())
{
if (!file.Open(NzFile::ReadOnly))
if (!file.Open(nzOpenMode_ReadOnly))
{
NazaraError("Failed to load file: unable to open \"" + filePath + '"');
return false;

2
include/Nazara/Core/Semaphore.hpp
View File

@@ -19,7 +19,9 @@ class NAZARA_CORE_API NzSemaphore : NzNonCopyable
~NzSemaphore();
unsigned int GetCount() const;
void Post();
void Wait();
bool Wait(nzUInt32 timeout);

60
include/Nazara/Core/String.hpp
View File

@@ -11,6 +11,7 @@
#include <Nazara/Core/Hashable.hpp>
#include <atomic>
#include <iosfwd>
#include <memory>
#include <string>
#include <vector>
@@ -22,15 +23,13 @@ class NAZARA_CORE_API NzString : public NzHashable
public:
enum Flags
{
None = 0x00, // Mode par défaut
CaseInsensitive = 0x01, // Insensible à la casse
HandleUtf8 = 0x02, // Traite les octets comme une suite de caractères UTF-8
None = 0x00, // Mode par défaut
CaseInsensitive = 0x01, // Insensible à la casse
HandleUtf8 = 0x02, // Traite les octets comme une suite de caractères UTF-8
TrimOnlyLeft = 0x04, // Trim(med), ne coupe que la partie gauche de la chaîne
TrimOnlyRight = 0x08 // Trim(med), ne coupe que la partie droite de la chaîne
};
struct SharedString;
NzString();
explicit NzString(char character);
NzString(unsigned int rep, char character);
@@ -40,10 +39,9 @@ class NAZARA_CORE_API NzString : public NzHashable
NzString(const char* string);
NzString(const char* string, unsigned int length);
NzString(const std::string& string);
NzString(const NzString& string);
NzString(NzString&& string) noexcept;
NzString(SharedString* sharedString);
~NzString();
NzString(const NzString& string) = default;
NzString(NzString&& string) noexcept = default;
~NzString() = default;
NzString& Append(char character);
NzString& Append(const char* string);
@@ -137,7 +135,6 @@ class NAZARA_CORE_API NzString : public NzHashable
NzString& Set(const std::string& string);
NzString& Set(const NzString& string);
NzString& Set(NzString&& string) noexcept;
NzString& Set(SharedString* sharedString);
NzString Simplified(nzUInt32 flags = None) const;
NzString& Simplify(nzUInt32 flags = None);
@@ -299,37 +296,30 @@ class NAZARA_CORE_API NzString : public NzHashable
NAZARA_CORE_API friend bool operator>=(const char* string, const NzString& nstring);
NAZARA_CORE_API friend bool operator>=(const std::string& string, const NzString& nstring);
struct NAZARA_CORE_API SharedString
{
SharedString() :
refCount(1)
{
}
SharedString(unsigned short referenceCount, unsigned int bufferSize, unsigned int stringSize, char* str) :
capacity(bufferSize),
size(stringSize),
string(str),
refCount(referenceCount)
{
}
unsigned int capacity;
unsigned int size;
char* string;
std::atomic_ushort refCount;
};
static SharedString emptyString;
static const unsigned int npos;
private:
struct SharedString;
NzString(std::shared_ptr<SharedString>&& sharedString);
void EnsureOwnership(bool discardContent = false);
bool FillHash(NzAbstractHash* hash) const;
void ReleaseString();
inline void ReleaseString();
SharedString* m_sharedString;
static std::shared_ptr<SharedString> GetEmptyString();
std::shared_ptr<SharedString> m_sharedString;
struct SharedString
{
inline SharedString();
inline SharedString(unsigned int strSize);
unsigned int capacity;
unsigned int size;
std::unique_ptr<char[]> string;
};
};
namespace std

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

@@ -4,11 +4,36 @@
#include <Nazara/Core/Debug.hpp>
inline NzString::NzString(std::shared_ptr<SharedString>&& sharedString) :
m_sharedString(std::move(sharedString))
{
}
inline void NzString::ReleaseString()
{
m_sharedString = std::move(GetEmptyString());
}
inline NzString::SharedString::SharedString() : // Special case: empty string
capacity(0),
size(0)
{
}
inline NzString::SharedString::SharedString(unsigned int strSize) :
capacity(strSize),
size(strSize),
string(new char[strSize + 1])
{
string[strSize] = '\0';
}
namespace std
{
template<>
struct hash<NzString>
{
template<>
struct hash<NzString>
{
size_t operator()(const NzString& str) const
{
// Algorithme DJB2
@@ -26,7 +51,7 @@ namespace std
return h;
}
};
};
}
#include <Nazara/Core/DebugOff.hpp>