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

Remove Nz::String and Nz::StringStream

Browse Source
This commit is contained in:
Jérôme Leclercq
2020-09-25 19:31:01 +02:00
parent d665af1f9d
commit 2b6a463a45
212 changed files with 1877 additions and 8721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Nazara/Audio/Audio.cpp
View File

@@ -71,7 +71,7 @@ namespace Nz
return static_cast<AudioFormat>(channelCount);
default:
NazaraError("Invalid channel count: " + String::Number(channelCount));
NazaraError("Invalid channel count: " + NumberToString(channelCount));
return AudioFormat_Unknown;
}
}

4
src/Nazara/Audio/Formats/sndfileLoader.cpp
View File

@@ -141,7 +141,7 @@ namespace Nz
m_handle = sf_open_virtual(&callbacks, SFM_READ, &infos, &stream);
if (!m_handle)
{
NazaraError("Failed to open sound: " + String(sf_strerror(m_handle)));
NazaraError("Failed to open sound: " + std::string(sf_strerror(m_handle)));
return false;
}
@@ -315,7 +315,7 @@ namespace Nz
SNDFILE* file = sf_open_virtual(&callbacks, SFM_READ, &info, &stream);
if (!file)
{
NazaraError("Failed to load sound file: " + String(sf_strerror(file)));
NazaraError("Failed to load sound file: " + std::string(sf_strerror(file)));
return nullptr;
}

31
src/Nazara/Audio/OpenAL.cpp
View File

@@ -6,6 +6,7 @@
#include <Nazara/Core/DynLib.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Log.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <cstring>
#include <sstream>
#include <stdexcept>
@@ -16,9 +17,9 @@ namespace Nz
namespace
{
DynLib s_library;
String s_deviceName;
String s_rendererName;
String s_vendorName;
std::string s_deviceName;
std::string s_rendererName;
std::string s_vendorName;
ALCdevice* s_device = nullptr;
ALCcontext* s_context = nullptr;
unsigned int s_version;
@@ -31,7 +32,7 @@ namespace Nz
* \param devices List of names of the devices
*/
std::size_t ParseDevices(const char* deviceString, std::vector<String>& devices)
std::size_t ParseDevices(const char* deviceString, std::vector<std::string>& devices)
{
if (!deviceString)
return 0;
@@ -66,9 +67,9 @@ namespace Nz
* \remark This does not produces a NazaraError if entry does not exist
*/
OpenALFunc OpenAL::GetEntry(const String& entryPoint)
OpenALFunc OpenAL::GetEntry(const std::string& entryPoint)
{
return LoadEntry(entryPoint.GetConstBuffer(), false);
return LoadEntry(entryPoint.data(), false);
}
/*!
@@ -76,7 +77,7 @@ namespace Nz
* \return Name of the renderer
*/
String OpenAL::GetRendererName()
std::string OpenAL::GetRendererName()
{
return s_rendererName;
}
@@ -86,7 +87,7 @@ namespace Nz
* \return Name of the vendor
*/
String OpenAL::GetVendorName()
std::string OpenAL::GetVendorName()
{
return s_vendorName;
}
@@ -284,7 +285,7 @@ namespace Nz
* \param devices List of names of the input devices
*/
std::size_t OpenAL::QueryInputDevices(std::vector<String>& devices)
std::size_t OpenAL::QueryInputDevices(std::vector<std::string>& devices)
{
const char* deviceString = reinterpret_cast<const char*>(alcGetString(nullptr, ALC_CAPTURE_DEVICE_SPECIFIER));
if (!deviceString)
@@ -300,7 +301,7 @@ namespace Nz
* \param devices List of names of the output devices
*/
std::size_t OpenAL::QueryOutputDevices(std::vector<String>& devices)
std::size_t OpenAL::QueryOutputDevices(std::vector<std::string>& devices)
{
const char* deviceString = reinterpret_cast<const char*>(alcGetString(nullptr, ALC_ALL_DEVICES_SPECIFIER));
if (!deviceString)
@@ -316,7 +317,7 @@ namespace Nz
* \param deviceName Name of the device
*/
bool OpenAL::SetDevice(const String& deviceName)
bool OpenAL::SetDevice(const std::string& deviceName)
{
s_deviceName = deviceName;
if (IsInitialized())
@@ -337,8 +338,8 @@ namespace Nz
{
CloseDevice();
s_rendererName.Clear(false);
s_vendorName.Clear(false);
s_rendererName.clear();
s_vendorName.clear();
s_library.Unload();
}
@@ -380,7 +381,7 @@ namespace Nz
bool OpenAL::OpenDevice()
{
// Initialisation of the module
s_device = alcOpenDevice(s_deviceName.IsEmpty() ? nullptr : s_deviceName.GetConstBuffer()); // We choose the default device
s_device = alcOpenDevice(s_deviceName.empty() ? nullptr : s_deviceName.data()); // We choose the default device
if (!s_device)
{
NazaraError("Failed to open default device");
@@ -420,7 +421,7 @@ namespace Nz
s_version = major*100 + minor*10;
NazaraDebug("OpenAL version: " + String::Number(major) + '.' + String::Number(minor));
NazaraDebug("OpenAL version: " + NumberToString(major) + '.' + NumberToString(minor));
}
else
{

2
src/Nazara/Audio/Sound.cpp
View File

@@ -177,7 +177,7 @@ namespace Nz
SoundBufferRef buffer = SoundBuffer::LoadFromMemory(data, size, params);
if (!buffer)
{
NazaraError("Failed to load buffer from memory (" + String::Pointer(data) + ')');
NazaraError("Failed to load buffer from memory (" + PointerToString(data) + ')');
return false;
}

3
src/Nazara/Core/AbstractHash.cpp
View File

@@ -14,6 +14,7 @@
#include <Nazara/Core/Hash/SHA384.hpp>
#include <Nazara/Core/Hash/SHA512.hpp>
#include <Nazara/Core/Hash/Whirlpool.hpp>
#include <Nazara/Math/Algorithm.hpp>
#include <Nazara/Core/Debug.hpp>
namespace Nz
@@ -74,7 +75,7 @@ namespace Nz
return std::make_unique<HashWhirlpool>();
}
NazaraInternalError("Hash type not handled (0x" + String::Number(type, 16) + ')');
NazaraInternalError("Hash type not handled (0x" + NumberToString(type, 16) + ')');
return nullptr;
}
}

12
src/Nazara/Core/AbstractLogger.cpp
View File

@@ -3,7 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/AbstractLogger.hpp>
#include <Nazara/Core/StringStream.hpp>
#include <sstream>
#include <Nazara/Core/Debug.hpp>
namespace Nz
@@ -40,14 +40,14 @@ namespace Nz
* \param function Name of the function throwing the error
*/
void AbstractLogger::WriteError(ErrorType type, const String& error, unsigned int line, const char* file, const char* function)
void AbstractLogger::WriteError(ErrorType type, const std::string_view& error, unsigned int line, const char* file, const char* function)
{
StringStream stream;
stream << errorType[type] << error;
std::ostringstream ss;
ss << errorType[type] << error;
if (line != 0 && file && function)
stream << " (" << file << ':' << line << ": " << function << ')';
ss << " (" << file << ':' << line << ": " << function << ')';
Write(stream);
Write(ss.str());
}
}

5
src/Nazara/Core/ByteArray.cpp
View File

@@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/ByteArray.hpp>
#include <ostream>
#include <Nazara/Core/Debug.hpp>
namespace Nz
@@ -18,11 +19,11 @@ namespace Nz
* \return String in base 16
*/
String ByteArray::ToHex() const
std::string ByteArray::ToHex() const
{
std::size_t length = m_array.size() * 2;
String hexOutput(length, '\0');
std::string hexOutput(length, '\0');
for (std::size_t i = 0; i < m_array.size(); ++i)
std::sprintf(&hexOutput[i * 2], "%02x", m_array[i]);

18
src/Nazara/Core/Error.cpp
View File

@@ -45,7 +45,7 @@ namespace Nz
* \param function Optional argument to set last error function
*/
String Error::GetLastError(const char** file, unsigned int* line, const char** function)
std::string Error::GetLastError(const char** file, unsigned int* line, const char** function)
{
if (file)
*file = s_lastErrorFile;
@@ -103,7 +103,7 @@ namespace Nz
#else
#error GetLastSystemError is not implemented on this platform
return String("GetLastSystemError is not implemented on this platform");
return "GetLastSystemError is not implemented on this platform";
#endif
}
@@ -128,12 +128,12 @@ namespace Nz
* \remark Produces a std::runtime_error on AssertFailed or throwing exception
*/
void Error::Trigger(ErrorType type, const String& error)
void Error::Trigger(ErrorType type, std::string error)
{
if (type == ErrorType_AssertFailed || (s_flags & ErrorFlag_Silent) == 0 || (s_flags & ErrorFlag_SilentDisabled) != 0)
Log::WriteError(type, error);
s_lastError = error;
s_lastError = std::move(error);
s_lastErrorFile = "";
s_lastErrorFunction = "";
s_lastErrorLine = 0;
@@ -145,7 +145,7 @@ namespace Nz
if (type == ErrorType_AssertFailed || (type != ErrorType_Warning &&
(s_flags & ErrorFlag_ThrowException) != 0 && (s_flags & ErrorFlag_ThrowExceptionDisabled) == 0))
throw std::runtime_error(error.ToStdString());
throw std::runtime_error(s_lastError);
}
/*!
@@ -161,14 +161,14 @@ namespace Nz
* \remark Produces a std::runtime_error on AssertFailed or throwing exception
*/
void Error::Trigger(ErrorType type, const String& error, unsigned int line, const char* file, const char* function)
void Error::Trigger(ErrorType type, std::string error, unsigned int line, const char* file, const char* function)
{
file = GetCurrentFileRelativeToEngine(file);
if (type == ErrorType_AssertFailed || (s_flags & ErrorFlag_Silent) == 0 || (s_flags & ErrorFlag_SilentDisabled) != 0)
Log::WriteError(type, error, line, file, function);
s_lastError = error;
s_lastError = std::move(error);
s_lastErrorFile = file;
s_lastErrorFunction = function;
s_lastErrorLine = line;
@@ -180,7 +180,7 @@ namespace Nz
if (type == ErrorType_AssertFailed || (type != ErrorType_Warning &&
(s_flags & ErrorFlag_ThrowException) != 0 && (s_flags & ErrorFlag_ThrowExceptionDisabled) == 0))
throw std::runtime_error(error.ToStdString());
throw std::runtime_error(s_lastError);
}
const char* Error::GetCurrentFileRelativeToEngine(const char* file)
@@ -195,7 +195,7 @@ namespace Nz
}
UInt32 Error::s_flags = ErrorFlag_None;
String Error::s_lastError;
std::string Error::s_lastError;
const char* Error::s_lastErrorFunction = "";
const char* Error::s_lastErrorFile = "";
unsigned int Error::s_lastErrorLine = 0;

1
src/Nazara/Core/File.cpp
View File

@@ -7,7 +7,6 @@
#include <Nazara/Core/Config.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/ErrorFlags.hpp>
#include <Nazara/Core/StringStream.hpp>
#include <memory>
#if defined(NAZARA_PLATFORM_WINDOWS)

9
src/Nazara/Core/FileLogger.cpp
View File

@@ -5,7 +5,6 @@
#include <Nazara/Core/FileLogger.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringStream.hpp>
#include <array>
#include <ctime>
#include <filesystem>
@@ -26,8 +25,8 @@ namespace Nz
* \param logPath Path to log
*/
FileLogger::FileLogger(const String& logPath) :
m_outputPath(logPath.ToStdString()),
FileLogger::FileLogger(std::filesystem::path logPath) :
m_outputPath(std::move(logPath)),
m_forceStdOutput(false),
m_stdReplicationEnabled(true),
m_timeLoggingEnabled(true)
@@ -92,7 +91,7 @@ namespace Nz
* \see WriteError
*/
void FileLogger::Write(const String& string)
void FileLogger::Write(const std::string_view& string)
{
if (m_forceStdOutput || m_stdReplicationEnabled)
{
@@ -148,7 +147,7 @@ namespace Nz
* \see Write
*/
void FileLogger::WriteError(ErrorType type, const String& error, unsigned int line, const char* file, const char* function)
void FileLogger::WriteError(ErrorType type, const std::string_view& error, unsigned int line, const char* file, const char* function)
{
AbstractLogger::WriteError(type, error, line, file, function);
m_outputFile.flush();

4
src/Nazara/Core/GuillotineBinPack.cpp
View File

@@ -613,7 +613,7 @@ namespace Nz
break;
default:
NazaraError("Split heuristic out of enum (0x" + String::Number(method, 16) + ')');
NazaraError("Split heuristic out of enum (0x" + NumberToString(method, 16) + ')');
splitHorizontal = true;
}
@@ -656,7 +656,7 @@ namespace Nz
return ScoreWorstShortSideFit(width, height, freeRect);
}
NazaraError("Rect choice heuristic out of enum (0x" + String::Number(rectChoice, 16) + ')');
NazaraError("Rect choice heuristic out of enum (0x" + NumberToString(rectChoice, 16) + ')');
return std::numeric_limits<int>::max();
}
}

4
src/Nazara/Core/HardwareInfo.cpp
View File

@@ -107,7 +107,7 @@ namespace Nz
* \remark Produces a NazaraError if not Initialize
*/
String HardwareInfo::GetProcessorBrandString()
std::string_view HardwareInfo::GetProcessorBrandString()
{
if (!Initialize())
NazaraError("Failed to initialize HardwareInfo");
@@ -150,7 +150,7 @@ namespace Nz
* \remark Produces a NazaraError if not Initialize
*/
String HardwareInfo::GetProcessorVendorName()
std::string_view HardwareInfo::GetProcessorVendorName()
{
if (!Initialize())
NazaraError("Failed to initialize HardwareInfo");

4
src/Nazara/Core/Log.cpp
View File

@@ -76,7 +76,7 @@ namespace Nz
* \see WriteError
*/
void Log::Write(const String& string)
void Log::Write(const std::string_view& string)
{
if (s_enabled)
s_logger->Write(string);
@@ -96,7 +96,7 @@ namespace Nz
* \see Write
*/
void Log::WriteError(ErrorType type, const String& error, unsigned int line, const char* file, const char* function)
void Log::WriteError(ErrorType type, const std::string_view& error, unsigned int line, const char* file, const char* function)
{
if (s_enabled)
s_logger->WriteError(type, error, line, file, function);

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

@@ -6,6 +6,7 @@
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/ErrorFlags.hpp>
#include <Nazara/Core/MemoryHelper.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <cstring>
#include <Nazara/Core/Debug.hpp>
@@ -55,9 +56,9 @@ namespace Nz
* \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
String: Conversion obeys the rule as described by String::ToBool
std::string: Conversion obeys the rule as described by std::string::ToBool
*/
bool ParameterList::GetBooleanParameter(const String& name, bool* value) const
bool ParameterList::GetBooleanParameter(const std::string& name, bool* value) const
{
NazaraAssert(value, "Invalid pointer");
@@ -82,10 +83,14 @@ namespace Nz
case ParameterType_String:
{
bool converted;
if (it->second.value.stringVal.ToBool(&converted, String::CaseInsensitive))
if (it->second.value.stringVal == "1" || it->second.value.stringVal == "yes" || it->second.value.stringVal == "true")
{
*value = converted;
*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;
}
@@ -115,7 +120,7 @@ namespace Nz
* \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 String& name, Color* value) const
bool ParameterList::GetColorParameter(const std::string& name, Color* value) const
{
NazaraAssert(value, "Invalid pointer");
@@ -159,9 +164,9 @@ namespace Nz
* \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
String: Conversion obeys the rule as described by String::ToDouble
std::string: Conversion obeys the rule as described by std::string::ToDouble
*/
bool ParameterList::GetDoubleParameter(const String& name, double* value) const
bool ParameterList::GetDoubleParameter(const std::string& name, double* value) const
{
NazaraAssert(value, "Invalid pointer");
@@ -185,16 +190,21 @@ namespace Nz
return true;
case ParameterType_String:
{
double converted;
if (it->second.value.stringVal.ToDouble(&converted))
{
*value = converted;
return true;
}
{
const std::string& str = it->second.value.stringVal;
int& err = errno;
err = 0;
char* endStr;
double ret = std::strtod(str.data(), &endStr);
if (str.data() == endStr || err == ERANGE)
break;
}
*value = ret;
return true;
}
case ParameterType_Boolean:
case ParameterType_Color:
@@ -220,9 +230,9 @@ namespace Nz
* \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
String: Conversion obeys the rule as described by String::ToInteger
std::string: Conversion obeys the rule as described by std::string::ToInteger
*/
bool ParameterList::GetIntegerParameter(const String& name, long long* value) const
bool ParameterList::GetIntegerParameter(const std::string& name, long long* value) const
{
NazaraAssert(value, "Invalid pointer");
@@ -250,15 +260,21 @@ namespace Nz
return true;
case ParameterType_String:
{
long long converted;
if (it->second.value.stringVal.ToInteger(&converted))
{
*value = converted;
return true;
}
{
const std::string& str = it->second.value.stringVal;
int& err = errno;
err = 0;
char* endStr;
long long ret = std::strtoll(str.data(), &endStr, 0);
if (str.data() == endStr || err == ERANGE)
break;
}
*value = ret;
return true;
}
case ParameterType_Color:
case ParameterType_None:
@@ -280,7 +296,7 @@ namespace Nz
*
* \remark type must be a valid pointer to a ParameterType variable
*/
bool ParameterList::GetParameterType(const String& name, ParameterType* type) const
bool ParameterList::GetParameterType(const std::string& name, ParameterType* type) const
{
NazaraAssert(type, "Invalid pointer");
@@ -305,7 +321,7 @@ namespace Nz
* \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 std::string& name, void** value) const
{
NazaraAssert(value, "Invalid pointer");
@@ -351,15 +367,15 @@ namespace Nz
* \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 string, a conversion will be performed, all types are compatibles:
Boolean: Conversion obeys the rules of String::Boolean
Boolean: Conversion obeys the rules of std::string::Boolean
Color: Conversion obeys the rules of Color::ToString
Double: Conversion obeys the rules of String::Number
Integer: Conversion obeys the rules of String::Number
Double: Conversion obeys the rules of std::string::Number
Integer: Conversion obeys the rules of std::string::Number
None: An empty string is returned
Pointer: Conversion obeys the rules of String::Pointer
Userdata: Conversion obeys the rules of String::Pointer
Pointer: Conversion obeys the rules of PointerToString
Userdata: Conversion obeys the rules of PointerToString
*/
bool ParameterList::GetStringParameter(const String& name, String* value) const
bool ParameterList::GetStringParameter(const std::string& name, std::string* value) const
{
NazaraAssert(value, "Invalid pointer");
@@ -375,7 +391,7 @@ namespace Nz
switch (it->second.type)
{
case ParameterType_Boolean:
*value = String::Boolean(it->second.value.boolVal);
*value = (it->second.value.boolVal) ? "true" : "false";
return true;
case ParameterType_Color:
@@ -383,11 +399,11 @@ namespace Nz
return true;
case ParameterType_Double:
*value = String::Number(it->second.value.doubleVal);
*value = std::to_string(it->second.value.doubleVal);
return true;
case ParameterType_Integer:
*value = String::Number(it->second.value.intVal);
*value = std::to_string(it->second.value.intVal);
return true;
case ParameterType_String:
@@ -395,15 +411,15 @@ namespace Nz
return true;
case ParameterType_Pointer:
*value = String::Pointer(it->second.value.ptrVal);
*value = PointerToString(it->second.value.ptrVal);
return true;
case ParameterType_Userdata:
*value = String::Pointer(it->second.value.userdataVal->ptr);
*value = PointerToString(it->second.value.userdataVal->ptr);
return true;
case ParameterType_None:
*value = String();
*value = std::string();
return true;
}
@@ -424,7 +440,7 @@ namespace Nz
*
* \see GetPointerParameter
*/
bool ParameterList::GetUserdataParameter(const String& name, void** value) const
bool ParameterList::GetUserdataParameter(const std::string& name, void** value) const
{
NazaraAssert(value, "Invalid pointer");
@@ -437,9 +453,11 @@ namespace Nz
return false;
}
if (it->second.type == ParameterType_Userdata)
const auto& parameter = it->second;
if (parameter.type == ParameterType_Userdata)
{
*value = it->second.value.userdataVal->ptr;
*value = parameter.value.userdataVal->ptr;
return true;
}
else
@@ -455,7 +473,7 @@ namespace Nz
*
* \param name Name of the parameter
*/
bool ParameterList::HasParameter(const String& name) const
bool ParameterList::HasParameter(const std::string& name) const
{
return m_parameters.find(name) != m_parameters.end();
}
@@ -468,7 +486,7 @@ namespace Nz
*
* \param name Name of the parameter
*/
void ParameterList::RemoveParameter(const String& name)
void ParameterList::RemoveParameter(const std::string& name)
{
auto it = m_parameters.find(name);
if (it != m_parameters.end())
@@ -485,7 +503,7 @@ namespace Nz
*
* \param name Name of the parameter
*/
void ParameterList::SetParameter(const String& name)
void ParameterList::SetParameter(const std::string& name)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_None;
@@ -499,7 +517,7 @@ namespace Nz
* \param name Name of the parameter
* \param value The color value
*/
void ParameterList::SetParameter(const String& name, const Color& value)
void ParameterList::SetParameter(const std::string& name, const Color& value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Color;
@@ -515,7 +533,7 @@ namespace Nz
* \param name Name of the parameter
* \param value The string value
*/
void ParameterList::SetParameter(const String& name, const String& value)
void ParameterList::SetParameter(const std::string& name, const std::string& value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_String;
@@ -531,7 +549,7 @@ namespace Nz
* \param name Name of the parameter
* \param value The string value
*/
void ParameterList::SetParameter(const String& name, const char* value)
void ParameterList::SetParameter(const std::string& name, const char* value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_String;
@@ -547,7 +565,7 @@ namespace Nz
* \param name Name of the parameter
* \param value The boolean value
*/
void ParameterList::SetParameter(const String& name, bool value)
void ParameterList::SetParameter(const std::string& name, bool value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Boolean;
@@ -562,7 +580,7 @@ namespace Nz
* \param name Name of the parameter
* \param value The double value
*/
void ParameterList::SetParameter(const String& name, double value)
void ParameterList::SetParameter(const std::string& name, double value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Double;
@@ -577,7 +595,7 @@ namespace Nz
* \param name Name of the parameter
* \param value The integer value
*/
void ParameterList::SetParameter(const String& name, long long value)
void ParameterList::SetParameter(const std::string& name, long long value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Integer;
@@ -595,7 +613,7 @@ namespace Nz
* \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)
void ParameterList::SetParameter(const std::string& name, void* value)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Pointer;
@@ -606,36 +624,39 @@ namespace Nz
* \brief Gives a string representation
* \return A string representation of the object: "ParameterList(Name: Type(value), ...)"
*/
String ParameterList::ToString() const
std::string ParameterList::ToString() const
{
StringStream ss;
std::ostringstream ss;
ss << std::boolalpha;
ss << "ParameterList(";
for (auto it = m_parameters.cbegin(); it != m_parameters.cend();)
{
const auto& parameter = it->second;
ss << it->first << ": ";
switch (it->second.type)
{
case ParameterType_Boolean:
ss << "Boolean(" << String::Boolean(it->second.value.boolVal) << ")";
ss << "Boolean(" << parameter.value.boolVal << ")";
break;
case ParameterType_Color:
ss << "Color(" << it->second.value.colorVal.ToString() << ")";
ss << "Color(" << parameter.value.colorVal << ")";
break;
case ParameterType_Double:
ss << "Double(" << it->second.value.doubleVal << ")";
ss << "Double(" << parameter.value.doubleVal << ")";
break;
case ParameterType_Integer:
ss << "Integer(" << it->second.value.intVal << ")";
ss << "Integer(" << parameter.value.intVal << ")";
break;
case ParameterType_String:
ss << "String(" << it->second.value.stringVal << ")";
ss << "std::string(" << parameter.value.stringVal << ")";
break;
case ParameterType_Pointer:
ss << "Pointer(" << String::Pointer(it->second.value.ptrVal) << ")";
ss << "Pointer(" << parameter.value.ptrVal << ")";
break;
case ParameterType_Userdata:
ss << "Userdata(" << String::Pointer(it->second.value.userdataVal->ptr) << ")";
ss << "Userdata(" << parameter.value.userdataVal->ptr << ")";
break;
case ParameterType_None:
ss << "None";
@@ -647,7 +668,7 @@ namespace Nz
}
ss << ")";
return ss;
return ss.str();
}
/*!
@@ -662,7 +683,7 @@ namespace Nz
* \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)
void ParameterList::SetParameter(const std::string& name, void* value, Destructor destructor)
{
Parameter& parameter = CreateValue(name);
parameter.type = ParameterType_Userdata;
@@ -721,7 +742,7 @@ namespace Nz
*
* \remark The previous value if any gets destroyed
*/
ParameterList::Parameter& ParameterList::CreateValue(const String& name)
ParameterList::Parameter& ParameterList::CreateValue(const std::string& name)
{
std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
Parameter& parameter = pair.first->second;
@@ -742,7 +763,7 @@ namespace Nz
switch (parameter.type)
{
case ParameterType_String:
parameter.value.stringVal.~String();
PlacementDestroy(&parameter.value.stringVal);
break;
case ParameterType_Userdata:

1
src/Nazara/Core/Posix/DynLibImpl.cpp
View File

@@ -4,7 +4,6 @@
#include <Nazara/Core/Posix/DynLibImpl.hpp>
#include <Nazara/Core/DynLib.hpp>
#include <Nazara/Core/String.hpp>
#include <dlfcn.h>
#include <Nazara/Core/Debug.hpp>

3
src/Nazara/Core/Posix/FileImpl.cpp
View File

@@ -4,6 +4,7 @@
#include <Nazara/Core/Posix/FileImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
@@ -159,7 +160,7 @@ namespace Nz
break;
default:
NazaraInternalError("Cursor position not handled (0x" + String::Number(pos, 16) + ')');
NazaraInternalError("Cursor position not handled (0x" + NumberToString(pos, 16) + ')');
return false;
}

2
src/Nazara/Core/RefCounted.cpp
View File

@@ -37,7 +37,7 @@ namespace Nz
{
#if NAZARA_CORE_SAFE
if (m_referenceCount > 0)
NazaraWarning("Resource destroyed while still referenced " + String::Number(m_referenceCount) + " time(s)");
NazaraWarning("Resource destroyed while still referenced " + std::to_string(m_referenceCount) + " time(s)");
#endif
}

9
src/Nazara/Core/StdLogger.cpp
View File

@@ -60,9 +60,9 @@ namespace Nz
* \see WriteError
*/
void StdLogger::Write(const String& string)
void StdLogger::Write(const std::string_view& error)
{
fputs(string.GetConstBuffer(), stdout);
fwrite(error.data(), sizeof(char), error.size(), stdout);
fputc('\n', stdout);
}
@@ -78,9 +78,10 @@ namespace Nz
* \see Write
*/
void StdLogger::WriteError(ErrorType type, const String& error, unsigned int line, const char* file, const char* function)
void StdLogger::WriteError(ErrorType type, const std::string_view& error, unsigned int line, const char* file, const char* function)
{
fprintf(stderr, "%s: %s", errorType[type], error.GetConstBuffer());
fprintf(stderr, "%s: ", errorType[type]);
fwrite(error.data(), sizeof(char), error.size(), stdout);
if (line != 0 && file && function)
fprintf(stderr, " (in %s at %s:%d)", function, file, line);

28
src/Nazara/Core/Stream.cpp
View File

@@ -5,7 +5,7 @@
#include <Nazara/Core/Stream.hpp>
#include <Nazara/Core/ByteArray.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <cstring>
#include <Nazara/Core/Debug.hpp>
@@ -147,22 +147,24 @@ namespace Nz
* \param string String to write
*/
bool Stream::Write(const String& string)
bool Stream::Write(const std::string_view& string)
{
String temp(string);
if (m_streamOptions & StreamOption_Text)
{
#if defined(NAZARA_PLATFORM_WINDOWS)
temp.Replace("\n", "\r\n");
#elif defined(NAZARA_PLATFORM_LINUX)
#if defined(NAZARA_PLATFORM_WINDOWS)
std::string temp(string);
ReplaceStr(temp, "\n", "\r\n");
#elif defined(NAZARA_PLATFORM_LINUX)
std::string_view temp(string);
// Nothing to do
#elif defined(NAZARA_PLATFORM_MACOS)
temp.Replace('\n', '\r');
#endif
}
#elif defined(NAZARA_PLATFORM_MACOS)
std::string temp(string);
ReplaceStr(temp, "\n", "\r");
#endif
std::size_t size = temp.GetSize();
return Write(temp.GetConstBuffer(), size) == size;
return Write(temp.data(), temp.size()) == temp.size();
}
else
return Write(string.data(), string.size()) == string.size();
}
}

6024
src/Nazara/Core/String.cpp
View File

File diff suppressed because it is too large Load Diff

316
src/Nazara/Core/StringExt.cpp
View File

@@ -13,7 +13,18 @@ namespace Nz
{
bool IsSpace(char32_t character)
{
return character == '\t' || Unicode::GetCategory(character) & Unicode::Category_Separator;
switch (character)
{
case '\f':
case '\n':
case '\r':
case '\t':
case '\v':
return true;
default:
return Unicode::GetCategory(character) & Unicode::Category_Separator;
}
}
char ToLower(char character)
@@ -79,12 +90,6 @@ namespace Nz
};
}
std::string FromUtf16String(const char16_t* u16str)
{
std::size_t size = std::char_traits<char16_t>::length(u16str);
return FromUtf16String(std::u16string_view(u16str, size));
}
std::string FromUtf16String(const std::u16string_view& u16str)
{
std::string result;
@@ -93,12 +98,6 @@ namespace Nz
return result;
}
std::string FromUtf32String(const char32_t* u32str)
{
std::size_t size = std::char_traits<char32_t>::length(u32str);
return FromUtf32String(std::u32string_view(u32str, size));
}
std::string FromUtf32String(const std::u32string_view& u32str)
{
std::string result;
@@ -107,17 +106,56 @@ namespace Nz
return result;
}
std::string FromWideString(const wchar_t* wstr)
{
std::size_t size = std::char_traits<wchar_t>::length(wstr);
return WideConverter<sizeof(wchar_t)>::From(wstr, size);
}
std::string FromWideString(const std::wstring_view& wstr)
{
return WideConverter<sizeof(wchar_t)>::From(wstr.data(), wstr.size());
}
std::string_view GetWord(const std::string_view& str, std::size_t wordIndex)
{
std::size_t pos = 0;
std::size_t previousPos = 0;
while ((pos = str.find_first_of(" \f\n\r\t\v", previousPos)) != std::string::npos)
{
std::size_t splitPos = previousPos;
previousPos = pos + 1;
if (pos != splitPos && wordIndex-- == 0)
return str.substr(splitPos, pos - splitPos);
}
return {};
}
std::string_view GetWord(const std::string_view& str, std::size_t wordIndex, UnicodeAware)
{
utf8::unchecked::iterator<const char*> it(str.data());
utf8::unchecked::iterator<const char*> end(str.data() + str.size());
auto FindNextSeparator = [&]() -> std::size_t
{
for (; it != end; ++it)
{
if (IsSpace(*it))
return true;
}
return false;
};
utf8::unchecked::iterator<const char*> lastSplit = it;
while (FindNextSeparator())
{
if (it != lastSplit && wordIndex-- == 0)
return std::string_view(lastSplit.base(), it.base() - lastSplit.base());
++it;
lastSplit = it;
}
return {};
}
bool MatchPattern(const std::string_view& str, const std::string_view& pattern)
{
if (str.empty() || pattern.empty())
@@ -169,27 +207,60 @@ namespace Nz
return patternPtr >= patternPtrEnd;
}
bool StartsWith(const std::string_view& str, const std::string_view& s, CaseIndependent)
std::string PointerToString(const void* ptr)
{
if (s.size() > str.size())
constexpr std::size_t capacity = sizeof(void*) * 2 + 2;
std::string str(capacity, '\0');
str.resize(std::sprintf(str.data(), "0x%p", ptr));
return str;
}
bool StartsWith(const std::string_view& lhs, const std::string_view& rhs, CaseIndependent)
{
if (rhs.size() > lhs.size())
return false;
return std::equal(str.begin(), str.begin() + s.size(), s.begin(), s.end(), [](char c1, char c2)
return std::equal(lhs.begin(), lhs.begin() + rhs.size(), rhs.begin(), rhs.end(), [](char c1, char c2)
{
return ToLower(c1) == ToLower(c2);
});
}
bool StartsWith(const std::string_view& str, const std::string_view& s, CaseIndependent, UnicodeAware)
bool StartsWith(const std::string_view& lhs, const std::string_view& rhs, UnicodeAware)
{
if (str.empty() || s.empty())
return str == s;
if (lhs.empty() || rhs.empty())
return lhs == rhs;
utf8::iterator<const char*> it(str.data(), str.data(), str.data() + str.size());
utf8::iterator<const char*> it2(s.data(), s.data(), s.data() + s.size());
utf8::iterator<const char*> it(lhs.data(), lhs.data(), lhs.data() + lhs.size());
utf8::iterator<const char*> it2(rhs.data(), rhs.data(), rhs.data() + rhs.size());
do
{
if (it2.base() >= s.data() + s.size())
if (it2.base() >= rhs.data() + rhs.size())
return true;
if (*it != *it2)
return false;
++it2;
}
while (*it++);
return true;
}
bool StartsWith(const std::string_view& lhs, const std::string_view& rhs, CaseIndependent, UnicodeAware)
{
if (lhs.empty() || rhs.empty())
return lhs == rhs;
utf8::iterator<const char*> it(lhs.data(), lhs.data(), lhs.data() + lhs.size());
utf8::iterator<const char*> it2(rhs.data(), rhs.data(), rhs.data() + rhs.size());
do
{
if (it2.base() >= rhs.data() + rhs.size())
return true;
if (Unicode::GetLowercase(*it) != Unicode::GetLowercase(*it2))
@@ -202,6 +273,40 @@ namespace Nz
return true;
}
bool StringEqual(const std::string_view& lhs, const std::string_view& rhs, UnicodeAware)
{
if (lhs.empty() || rhs.empty())
return lhs == rhs;
utf8::iterator<const char*> it(lhs.data(), lhs.data(), lhs.data() + lhs.size());
utf8::iterator<const char*> it2(rhs.data(), rhs.data(), rhs.data() + rhs.size());
for (; it.base() < lhs.data() + lhs.size(); ++it, ++it2)
{
if (*it != *it2)
return false;
}
return true;
}
bool StringEqual(const std::string_view& lhs, const std::string_view& rhs, CaseIndependent, UnicodeAware)
{
if (lhs.empty() || rhs.empty())
return lhs == rhs;
utf8::iterator<const char*> it(lhs.data(), lhs.data(), lhs.data() + lhs.size());
utf8::iterator<const char*> it2(rhs.data(), rhs.data(), rhs.data() + rhs.size());
for (; it.base() < lhs.data() + lhs.size(); ++it, ++it2)
{
if (Unicode::GetLowercase(*it) != Unicode::GetLowercase(*it2))
return false;
}
return true;
}
std::string ToLower(const std::string_view& str)
{
std::string result;
@@ -220,9 +325,9 @@ namespace Nz
result.reserve(str.size());
utf8::unchecked::iterator<const char*> it(str.data());
do
utf8::unchecked::iterator<const char*> end(str.data() + str.size());
for (; it != end; ++it)
utf8::append(Unicode::GetLowercase(*it), std::back_inserter(result));
while (*++it);
return result;
}
@@ -244,10 +349,10 @@ namespace Nz
std::string result;
result.reserve(str.size());
utf8::iterator<const char*> it(str.data(), str.data(), str.data() + str.size());
do
utf8::unchecked::iterator<const char*> it(str.data());
utf8::unchecked::iterator<const char*> end(str.data() + str.size());
for (; it != end; ++it)
utf8::append(Unicode::GetUppercase(*it), std::back_inserter(result));
while (*++it);
return result;
}
@@ -272,6 +377,151 @@ namespace Nz
{
return WideConverter<sizeof(wchar_t)>::To(str);
}
std::string_view TrimLeft(std::string_view str)
{
while (!str.empty() && IsSpace(str.front()))
str.remove_prefix(1);
return str;
}
std::string_view TrimLeft(std::string_view str, UnicodeAware)
{
utf8::unchecked::iterator<const char*> it(str.data());
utf8::unchecked::iterator<const char*> end(str.data() + str.size());
while (it != end && IsSpace(*it))
++it;
return std::string_view(it.base(), end.base() - it.base());
}
std::string_view TrimLeft(std::string_view str, char32_t c, UnicodeAware)
{
utf8::unchecked::iterator<const char*> it(str.data());
utf8::unchecked::iterator<const char*> end(str.data() + str.size());
while (it != end && *it == c)
++it;
return std::string_view(it.base(), end.base() - it.base());
}
std::string_view TrimLeft(std::string_view str, char32_t c, CaseIndependent, UnicodeAware)
{
utf8::unchecked::iterator<const char*> it(str.data());
utf8::unchecked::iterator<const char*> end(str.data() + str.size());
c = Unicode::GetLowercase(c);
while (it != end && Unicode::GetLowercase(*it) == c)
++it;
return std::string_view(it.base(), end.base() - it.base());
}
std::string_view TrimLeft(std::string_view str, Unicode::Category category, UnicodeAware)
{
utf8::unchecked::iterator<const char*> it(str.data());
utf8::unchecked::iterator<const char*> end(str.data() + str.size());
while (it != end && (Unicode::GetCategory(*it) & category) == category)
++it;
return std::string_view(it.base(), end.base() - it.base());
}
std::string_view TrimRight(std::string_view str)
{
while (!str.empty() && IsSpace(str.back()))
str.remove_suffix(1);
return str;
}
std::string_view TrimRight(std::string_view str, UnicodeAware)
{
if (str.empty())
return str;
// Find last character head
const char* lastCharacter = str.data() + str.size() - 1;
while (utf8::internal::is_trail(*lastCharacter) && lastCharacter != str.data())
--lastCharacter;
utf8::unchecked::iterator<const char*> start(str.data());
utf8::unchecked::iterator<const char*> it(lastCharacter);
while (it != start && IsSpace(*it))
--it;
++it;
return std::string_view(start.base(), it.base() - start.base());
}
std::string_view TrimRight(std::string_view str, char32_t c, UnicodeAware)
{
if (str.empty())
return str;
// Find last character head
const char* lastCharacter = str.data() + str.size() - 1;
while (utf8::internal::is_trail(*lastCharacter) && lastCharacter != str.data())
--lastCharacter;
utf8::unchecked::iterator<const char*> start(str.data());
utf8::unchecked::iterator<const char*> it(lastCharacter);
while (it != start && *it == c)
--it;
++it;
return std::string_view(start.base(), it.base() - start.base());
}
std::string_view TrimRight(std::string_view str, char32_t c, CaseIndependent, UnicodeAware)
{
if (str.empty())
return str;
// Find last character head
const char* lastCharacter = str.data() + str.size() - 1;
while (utf8::internal::is_trail(*lastCharacter) && lastCharacter != str.data())
--lastCharacter;
utf8::unchecked::iterator<const char*> start(str.data());
utf8::unchecked::iterator<const char*> it(lastCharacter);
c = Unicode::GetLowercase(c);
while (it != start && Unicode::GetLowercase(*it) == c)
--it;
++it;
return std::string_view(start.base(), it.base() - start.base());
}
std::string_view TrimRight(std::string_view str, Unicode::Category category, UnicodeAware)
{
if (str.empty())
return str;
// Find last character head
const char* lastCharacter = str.data() + str.size() - 1;
while (utf8::internal::is_trail(*lastCharacter) && lastCharacter != str.data())
--lastCharacter;
utf8::unchecked::iterator<const char*> start(str.data());
utf8::unchecked::iterator<const char*> it(lastCharacter);
while (it != start && (Unicode::GetCategory(*it) & category) == category)
--it;
++it;
return std::string_view(start.base(), it.base() - start.base());
}
}
#include <Nazara/Core/DebugOff.hpp>

349
src/Nazara/Core/StringStream.cpp
View File

@@ -1,349 +0,0 @@
// Copyright (C) 2020 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
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Math/Algorithm.hpp>
#include <array>
#include <limits>
#include <Nazara/Core/Debug.hpp>
namespace Nz
{
/*!
* \ingroup core
* \class Nz::StringStream
* \brief Core class that represents a stream of strings
*/
/*!
* \brief Constructs a StringStream object with a string
*
* \param str First value of the stream
*/
StringStream::StringStream(String str) :
m_result(std::move(str))
{
}
/*!
* \brief Resets the state of the stream, erasing every contained text
*/
void StringStream::Clear()
{
m_result.Clear();
}
/*!
* \brief Get the current buffer size
* \return The internal accumulation buffer size, this is equivalent to the size of the final string
*/
std::size_t StringStream::GetBufferSize() const
{
return m_result.GetSize();
}
/*!
* \brief Gives a string representation
* \return A string representation of the object where every objects of the stream has been converted with Nz::String
*/
String StringStream::ToString() const
{
return m_result;
}
/*!
* \brief Adds the representation of the boolean
* \return A reference to this
*
* \param boolean Boolean value
*/
StringStream& StringStream::operator<<(bool boolean)
{
std::size_t size = (boolean) ? 4 : 5;
std::size_t start = m_result.GetSize();
m_result.Resize(start + size);
std::memcpy(&m_result[start], (boolean) ? "true" : "false", size);
return *this;
}
/*!
* \brief Adds the representation of the short
* \return A reference to this
*
* \param number Short value
*/
StringStream& StringStream::operator<<(short number)
{
constexpr std::size_t maxSize = std::numeric_limits<short>::digits10 + 2;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%hd", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the unsigned short
* \return A reference to this
*
* \param number Short value
*/
StringStream& StringStream::operator<<(unsigned short number)
{
constexpr std::size_t maxSize = std::numeric_limits<unsigned short>::digits10 + 1;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%hu", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the int
* \return A reference to this
*
* \param number Int value
*/
StringStream& StringStream::operator<<(int number)
{
constexpr std::size_t maxSize = std::numeric_limits<int>::digits10 + 2;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%d", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the unsigned int
* \return A reference to this
*
* \param number Int value
*/
StringStream& StringStream::operator<<(unsigned int number)
{
constexpr std::size_t maxSize = std::numeric_limits<unsigned int>::digits10 + 1;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%u", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the long
* \return A reference to this
*
* \param number Long value
*/
StringStream& StringStream::operator<<(long number)
{
constexpr std::size_t maxSize = std::numeric_limits<long>::digits10 + 2;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%ld", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the unsigned long
* \return A reference to this
*
* \param number Long value
*/
StringStream& StringStream::operator<<(unsigned long number)
{
constexpr std::size_t maxSize = std::numeric_limits<unsigned long>::digits10 + 1;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%lu", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the long long
* \return A reference to this
*
* \param number Long long value
*/
StringStream& StringStream::operator<<(long long number)
{
constexpr std::size_t maxSize = std::numeric_limits<long long>::digits10 + 2;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%lld", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the unsigned long long
* \return A reference to this
*
* \param number Long long value
*/
StringStream& StringStream::operator<<(unsigned long long number)
{
constexpr std::size_t maxSize = std::numeric_limits<unsigned long long>::digits10 + 1;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "%llu", number);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Adds the representation of the float
* \return A reference to this
*
* \param number Float value
*/
StringStream& StringStream::operator<<(float number)
{
return operator<<(double(number)); //< snprintf doesn't support float anyway
}
/*!
* \brief Adds the representation of the double
* \return A reference to this
*
* \param number Double value
*/
StringStream& StringStream::operator<<(double number)
{
// https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
const std::size_t maxSize = 3 + std::numeric_limits<double>::digits - std::numeric_limits<double>::min_exponent;
// Use a temporary buffer to prevent 1kb string capacity growth
std::array<char, maxSize + 1> buffer;
std::size_t written = std::snprintf(buffer.data(), buffer.size(), "%.6f", number);
std::size_t start = m_result.GetSize();
m_result.Resize(start + written);
std::memcpy(&m_result[start], buffer.data(), written);
return *this;
}
/*!
* \brief Adds the representation of the long double
* \return A reference to this
*
* \param number Long double value
*/
StringStream& StringStream::operator<<(long double number)
{
// https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value
const std::size_t maxSize = 3 + std::numeric_limits<long double>::digits - std::numeric_limits<long double>::min_exponent;
// Use a temporary buffer to prevent 1kb string capacity growth
std::array<char, maxSize + 1> buffer;
std::size_t written = std::snprintf(buffer.data(), buffer.size(), "%.6Lf", number);
std::size_t start = m_result.GetSize();
m_result.Resize(start + written);
std::memcpy(&m_result[start], buffer.data(), written);
return *this;
}
/*!
* \brief Adds the representation of the char
* \return A reference to this
*
* \param character Char value
*/
StringStream& StringStream::operator<<(char character)
{
m_result.Append(character);
return *this;
}
/*!
* \brief Adds the representation of the unsigned char
* \return A reference to this
*
* \param character Char value
*/
StringStream& StringStream::operator<<(unsigned char character)
{
m_result.Append(static_cast<unsigned char>(character));
return *this;
}
/*!
* \brief Adds the representation of the const char*
* \return A reference to this
*
* \param string String value
*/
StringStream& StringStream::operator<<(const char* string)
{
m_result.Append(string);
return *this;
}
/*!
* \brief Adds the representation of the std::string
* \return A reference to this
*
* \param string String value
*/
StringStream& StringStream::operator<<(const std::string& string)
{
m_result.Append(string.data(), string.size());
return *this;
}
/*!
* \brief Adds the representation of the Nz::String
* \return A reference to this
*
* \param string String value
*/
StringStream& StringStream::operator<<(const String& string)
{
m_result.Append(string);
return *this;
}
/*!
* \brief Adds the representation of the pointer
* \return A reference to this
*
* \param ptr Pointer value
*/
StringStream& StringStream::operator<<(const void* ptr)
{
constexpr std::size_t maxSize = sizeof(void*) * 2 + 2;
std::size_t start = m_result.GetSize();
m_result.Resize(start + maxSize);
std::size_t written = std::snprintf(&m_result[start], maxSize + 1, "0x%p", ptr);
m_result.Resize(start + written);
return *this;
}
/*!
* \brief Converts this to Nz::String
* \return The string representation of the stream
*/
StringStream::operator String() const
{
return ToString();
}
}

2
src/Nazara/Core/Win32/FileImpl.cpp
View File

@@ -149,7 +149,7 @@ namespace Nz
break;
default:
NazaraInternalError("Cursor position not handled (0x" + String::Number(pos, 16) + ')');
NazaraInternalError("Cursor position not handled (0x" + NumberToString(pos, 16) + ')');
return false;
}

5
src/Nazara/Network/AbstractSocket.cpp
View File

@@ -4,6 +4,7 @@
#include <Nazara/Network/AbstractSocket.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/Algorithm.hpp>
#if defined(NAZARA_PLATFORM_WINDOWS)
@@ -177,7 +178,7 @@ namespace Nz
{
SocketError errorCode;
if (!SocketImpl::SetBlocking(m_handle, m_isBlockingEnabled, &errorCode))
NazaraWarning("Failed to set socket blocking mode (0x" + String::Number(errorCode, 16) + ')');
NazaraWarning("Failed to set socket blocking mode (0x" + NumberToString(errorCode, 16) + ')');
}
/*!
@@ -199,7 +200,7 @@ namespace Nz
{
SocketImpl::Close(handle);
NazaraError("Failed to open a dual-stack socket: " + Nz::String(ErrorToString(m_lastError)));
NazaraError("Failed to open a dual-stack socket: " + std::string(ErrorToString(m_lastError)));
return false;
}

2
src/Nazara/Network/ENetHost.cpp
View File

@@ -153,7 +153,7 @@ namespace Nz
if (peerCount > ENetConstants::ENetProtocol_MaximumPeerId)
{
NazaraError("Peer count exceeds maximum peer count supported by protocol (" + String::Number(ENetConstants::ENetProtocol_MaximumPeerId) + ")");
NazaraError("Peer count exceeds maximum peer count supported by protocol (" + NumberToString(ENetConstants::ENetProtocol_MaximumPeerId) + ")");
return false;
}

5
src/Nazara/Network/IpAddress.cpp
View File

@@ -4,6 +4,7 @@
#include <Nazara/Network/IpAddress.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/Algorithm.hpp>
#include <algorithm>
#include <limits>
@@ -88,7 +89,7 @@ namespace Nz
return m_ipv6 == LoopbackIpV6.m_ipv6; // Only compare the ip value
}
NazaraInternalError("Invalid protocol for IpAddress (0x" + String::Number(m_protocol) + ')');
NazaraInternalError("Invalid protocol for IpAddress (0x" + NumberToString(m_protocol) + ')');
return false;
}
@@ -164,7 +165,7 @@ namespace Nz
else if (i != 0)
stream << ':';
stream << String::Number(m_ipv6[i], 16).ToLower();
stream << ToLower(NumberToString(m_ipv6[i], 16));
}
if (m_port != 0)

7
src/Nazara/Network/Linux/SocketPollerImpl.cpp
View File

@@ -4,6 +4,7 @@
#include <Nazara/Network/Linux/SocketPollerImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/Posix/SocketImpl.hpp>
#include <cstring>
#include <unistd.h>
@@ -60,7 +61,7 @@ namespace Nz
if (epoll_ctl(m_handle, EPOLL_CTL_ADD, socket, &entry) != 0)
{
NazaraError("Failed to add socket to epoll structure (errno " + String::Number(errno) + ": " + Error::GetLastSystemError() + ')');
NazaraError("Failed to add socket to epoll structure (errno " + NumberToString(errno) + ": " + Error::GetLastSystemError() + ')');
return false;
}
@@ -78,7 +79,7 @@ namespace Nz
m_sockets.erase(socket);
if (epoll_ctl(m_handle, EPOLL_CTL_DEL, socket, nullptr) != 0)
NazaraWarning("An error occured while removing socket from epoll structure (errno " + String::Number(errno) + ": " + Error::GetLastSystemError() + ')');
NazaraWarning("An error occured while removing socket from epoll structure (errno " + NumberToString(errno) + ": " + Error::GetLastSystemError() + ')');
}
unsigned int SocketPollerImpl::Wait(int msTimeout, SocketError* error)
@@ -115,7 +116,7 @@ namespace Nz
}
else
{
NazaraWarning("Descriptor " + String::Number(m_events[i].data.fd) + " was returned by epoll without EPOLLIN nor EPOLLOUT flags (events: 0x" + String::Number(m_events[i].events, 16) + ')');
NazaraWarning("Descriptor " + NumberToString(m_events[i].data.fd) + " was returned by epoll without EPOLLIN nor EPOLLOUT flags (events: 0x" + NumberToString(m_events[i].events, 16) + ')');
activeSockets--;
}
}

5
src/Nazara/Network/Posix/IpAddressImpl.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Network/Posix/IpAddressImpl.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/Posix/SocketImpl.hpp>
#include <cstring>
#include <Nazara/Network/Debug.hpp>
@@ -216,7 +217,7 @@ namespace Nz
}
default:
NazaraInternalError("Unhandled ip protocol (0x" + String::Number(ipAddress.GetProtocol()) + ')');
NazaraInternalError("Unhandled ip protocol (0x" + NumberToString(ipAddress.GetProtocol(), 16) + ')');
break;
}
}
@@ -292,7 +293,7 @@ namespace Nz
return ResolveError_TemporaryFailure;
}
NazaraWarning("Unhandled EAI error: " + Error::GetLastSystemError(error) + " (" + String::Number(error) + ") as " + gai_strerror(error));
NazaraWarning("Unhandled EAI error: " + Error::GetLastSystemError(error) + " (" + NumberToString(error) + ") as " + gai_strerror(error));
return ResolveError_Unknown;
}
}

5
src/Nazara/Network/Posix/SocketImpl.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Network/Posix/SocketImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StackArray.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/NetBuffer.hpp>
#include <Nazara/Network/Posix/IpAddressImpl.hpp>
#include <netinet/tcp.h>
@@ -955,7 +956,7 @@ namespace Nz
case EALREADY:
case EISCONN:
case EWOULDBLOCK:
NazaraWarning("Internal error occurred: " + Error::GetLastSystemError(error) + " (" + String::Number(error) + ')');
NazaraWarning("Internal error occurred: " + Error::GetLastSystemError(error) + " (" + NumberToString(error)+')');
return SocketError_Internal;
case EADDRNOTAVAIL:
@@ -1001,7 +1002,7 @@ namespace Nz
return SocketError_TimedOut;
}
NazaraWarning("Unhandled POSIX error: " + Error::GetLastSystemError(error) + " (" + String::Number(error) + ')');
NazaraWarning("Unhandled POSIX error: " + Error::GetLastSystemError(error) + " (" + NumberToString(error) + ')');
return SocketError_Unknown;
}

3
src/Nazara/Network/Posix/SocketPollerImpl.cpp
View File

@@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Network/Posix/SocketPollerImpl.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <poll.h>
#include <Nazara/Network/Debug.hpp>
@@ -103,7 +104,7 @@ namespace Nz
}
else
{
NazaraWarning("Socket " + String::Number(entry.fd) + " was returned by poll without POLLRDNORM nor POLLWRNORM events (events: 0x" + String::Number(entry.revents, 16) + ')');
NazaraWarning("Socket " + NumberToString(entry.fd) + " was returned by poll without POLLRDNORM nor POLLWRNORM events (events: 0x" + NumberToString(entry.revents, 16) + ')');
activeSockets--;
}

12
src/Nazara/Network/RUdpConnection.cpp
View File

@@ -421,7 +421,7 @@ namespace Nz
void RUdpConnection::OnPacketLost(PeerData& peer, PendingAckPacket&& packet)
{
//NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Lost packet " + String::Number(packet.sequenceId));
//NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Lost packet " + NumberToString(packet.sequenceId));
if (IsReliable(packet.reliability))
EnqueuePacketInternal(peer, packet.priority, packet.reliability, std::move(packet.data));
@@ -465,7 +465,7 @@ namespace Nz
UInt64 token;
packet >> token;
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_RequestConnection from " + peerIp.ToString() + ": " + String::Number(token));
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_RequestConnection from " + peerIp.ToString() + ": " + NumberToString(token));
if (!m_shouldAcceptConnections)
return; //< Ignore
@@ -487,7 +487,7 @@ namespace Nz
if (m_isSimulationEnabled && m_packetLossProbability(s_randomGenerator))
{
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Lost packet " + String::Number(sequenceId) + " from " + peerIp.ToString() + " for simulation purpose");
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Lost packet " + NumberToString(sequenceId) + " from " + peerIp.ToString() + " for simulation purpose");
return;
}
@@ -519,7 +519,7 @@ namespace Nz
UInt64 token;
packet /*>> externalAddress*/ >> token;
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_AcknowledgeConnection from " + peerIp.ToString() + ": " + String::Number(token));
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received NetCode_AcknowledgeConnection from " + peerIp.ToString() + ": " + NumberToString(token));
if (token == ~peer.stateData1)
{
peer.state = PeerState_Connected;
@@ -527,7 +527,7 @@ namespace Nz
}
else
{
NazaraNotice("Received wrong token (" + String::Number(token) + " instead of " + String::Number(~peer.stateData1) + ") from client " + peer.address.ToString());
NazaraNotice("Received wrong token (" + NumberToString(token) + " instead of " + NumberToString(~peer.stateData1) + ") from client " + peer.address.ToString());
return; //< Ignore
}
@@ -553,7 +553,7 @@ namespace Nz
default:
{
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received 0x" + String::Number(packet.GetNetCode(), 16) + " from " + peerIp.ToString());
NazaraNotice(m_socket.GetBoundAddress().ToString() + ": Received 0x" + NumberToString(packet.GetNetCode(), 16) + " from " + peerIp.ToString());
RUdpMessage receivedMessage;
receivedMessage.from = peerIp;
receivedMessage.data = std::move(packet);

4
src/Nazara/Network/SocketPoller.cpp
View File

@@ -3,6 +3,8 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Network/SocketPoller.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/Algorithm.hpp>
#if defined(NAZARA_PLATFORM_WINDOWS)
@@ -195,7 +197,7 @@ namespace Nz
if (waitError != SocketError_NoError)
{
if (waitError != SocketError_Interrupted) //< Do not log interrupted error
NazaraError("SocketPoller encountered an error (code: 0x" + String::Number(waitError, 16) + "): " + ErrorToString(waitError));
NazaraError("SocketPoller encountered an error (code: 0x" + NumberToString(waitError, 16) + "): " + ErrorToString(waitError));
return 0;
}

9
src/Nazara/Network/TcpClient.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Network/TcpClient.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <limits>
#include <Nazara/Network/NetPacket.hpp>
@@ -213,7 +214,7 @@ namespace Nz
break;
}
NazaraInternalError("Unexpected socket state (0x" + String::Number(m_state, 16) + ')');
NazaraInternalError("Unexpected socket state (0x" + NumberToString(m_state, 16) + ')');
return m_state;
}
@@ -520,7 +521,7 @@ namespace Nz
break;
}
NazaraInternalError("Unhandled socket state (0x" + String::Number(m_state, 16) + ')');
NazaraInternalError("Unhandled socket state (0x" + NumberToString(m_state, 16) + ')');
return m_state;
}
@@ -557,10 +558,10 @@ namespace Nz
SocketError errorCode;
if (!SocketImpl::SetNoDelay(m_handle, m_isLowDelayEnabled, &errorCode))
NazaraWarning("Failed to set socket no delay mode (0x" + String::Number(errorCode, 16) + ')');
NazaraWarning("Failed to set socket no delay mode (0x" + NumberToString(errorCode, 16) + ')');
if (!SocketImpl::SetKeepAlive(m_handle, m_isKeepAliveEnabled, m_keepAliveTime, m_keepAliveInterval, &errorCode))
NazaraWarning("Failed to set socket keep alive mode (0x" + String::Number(errorCode, 16) + ')');
NazaraWarning("Failed to set socket keep alive mode (0x" + NumberToString(errorCode, 16) + ')');
m_peerAddress = IpAddress::Invalid;
m_openMode = OpenMode_ReadWrite;

4
src/Nazara/Network/UdpSocket.cpp
View File

@@ -3,6 +3,8 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Network/UdpSocket.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/NetPacket.hpp>
#if defined(NAZARA_PLATFORM_WINDOWS)
@@ -193,7 +195,7 @@ namespace Nz
if (packetSize != received)
{
m_lastError = SocketError_Packet;
NazaraWarning("Invalid packet size (packet size is " + String::Number(packetSize) + " bytes, received " + Nz::String::Number(received) + " bytes)");
NazaraWarning("Invalid packet size (packet size is " + NumberToString(packetSize) + " bytes, received " + NumberToString(received) + " bytes)");
return false;
}

4
src/Nazara/Network/Win32/IpAddressImpl.cpp
View File

@@ -271,7 +271,7 @@ namespace Nz
}
default:
NazaraInternalError("Unhandled ip protocol (0x" + String::Number(ipAddress.GetProtocol()) + ')');
NazaraInternalError("Unhandled ip protocol (0x" + NumberToString(ipAddress.GetProtocol()) + ')');
break;
}
}
@@ -346,7 +346,7 @@ namespace Nz
return ResolveError_TemporaryFailure;
}
NazaraWarning("Unhandled WinSock error: " + Error::GetLastSystemError(error) + " (" + String::Number(error) + ')');
NazaraWarning("Unhandled WinSock error: " + Error::GetLastSystemError(error) + " (" + NumberToString(error) + ')');
return ResolveError_Unknown;
}
}

7
src/Nazara/Network/Win32/SocketImpl.cpp
View File

@@ -6,6 +6,7 @@
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Log.hpp>
#include <Nazara/Core/StackArray.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/Win32/IpAddressImpl.hpp>
// Some compilers (older versions of MinGW) lack Mstcpip.h which defines some structs/defines
@@ -163,7 +164,7 @@ namespace Nz
return false;
}
NazaraDebug("Initialized Windows Socket " + String::Number(LOBYTE(s_WSA.wVersion)) + '.' + String::Number(HIBYTE(s_WSA.wVersion)) + " (" + String(s_WSA.szDescription) + ')');
NazaraDebug("Initialized Windows Socket " + NumberToString(LOBYTE(s_WSA.wVersion)) + '.' + NumberToString(HIBYTE(s_WSA.wVersion)) + " (" + std::string(s_WSA.szDescription) + ')');
return true;
}
@@ -955,7 +956,7 @@ namespace Nz
case WSAEALREADY:
case WSAEISCONN:
case WSAEWOULDBLOCK:
NazaraWarning("Internal error occurred: " + Error::GetLastSystemError(error) + " (" + String::Number(error) + ')');
NazaraWarning("Internal error occurred: " + Error::GetLastSystemError(error) + " (" + NumberToString(error) + ')');
return SocketError_Internal;
case WSAEADDRNOTAVAIL:
@@ -1000,7 +1001,7 @@ namespace Nz
return SocketError_TimedOut;
}
NazaraWarning("Unhandled WinSock error: " + Error::GetLastSystemError(error) + " (" + String::Number(error) + ')');
NazaraWarning("Unhandled WinSock error: " + Error::GetLastSystemError(error) + " (" + NumberToString(error) + ')');
return SocketError_Unknown;
}

6
src/Nazara/Network/Win32/SocketPollerImpl.cpp
View File

@@ -3,6 +3,8 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Network/Win32/SocketPollerImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Network/Debug.hpp>
namespace Nz
@@ -89,7 +91,7 @@ namespace Nz
fd_set& targetSet = (i == 0) ? m_readSockets : m_writeSockets;
if (targetSet.fd_count > FD_SETSIZE)
{
NazaraError("Socket count exceeding hard-coded FD_SETSIZE (" + String::Number(FD_SETSIZE) + ")");
NazaraError("Socket count exceeding hard-coded FD_SETSIZE (" + NumberToString(FD_SETSIZE) + ")");
return false;
}
@@ -157,7 +159,7 @@ namespace Nz
}
else
{
NazaraWarning("Socket " + String::Number(entry.fd) + " was returned by WSAPoll without POLLRDNORM nor POLLWRNORM events (events: 0x" + String::Number(entry.revents, 16) + ')');
NazaraWarning("Socket " + NumberToString(entry.fd) + " was returned by WSAPoll without POLLRDNORM nor POLLWRNORM events (events: 0x" + NumberToString(entry.revents, 16) + ')');
activeSockets--;
}

3
src/Nazara/OpenGLRenderer/OpenGLBuffer.cpp
View File

@@ -4,7 +4,6 @@
#include <Nazara/OpenGLRenderer/OpenGLBuffer.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/String.hpp>
#include <stdexcept>
#include <Nazara/OpenGLRenderer/Debug.hpp>
@@ -37,7 +36,7 @@ namespace Nz
case BufferType_Vertex: target = GL::BufferTarget::Array; break;
default:
throw std::runtime_error("unknown buffer type 0x" + String::Number(UnderlyingCast(m_type), 16).ToStdString());
throw std::runtime_error("unknown buffer type 0x" + NumberToString(UnderlyingCast(m_type), 16));
}
GLenum hint = GL_STREAM_COPY;

2
src/Nazara/OpenGLRenderer/OpenGLCommandBuffer.cpp
View File

@@ -49,7 +49,7 @@ namespace Nz
break;
}
throw std::runtime_error(("component type 0x" + String::Number(component, 16) + " is not handled").ToStdString());
throw std::runtime_error("component type 0x" + NumberToString(component, 16) + " is not handled");
}
}

2
src/Nazara/OpenGLRenderer/OpenGLRenderPipelineLayout.cpp
View File

@@ -31,7 +31,7 @@ namespace Nz
break;
default:
throw std::runtime_error(("unknown binding type 0x" + String::Number(UnderlyingCast(bindingInfo.type), 16)).ToStdString());
throw std::runtime_error("unknown binding type 0x" + NumberToString(UnderlyingCast(bindingInfo.type), 16));
}
}
}

2
src/Nazara/OpenGLRenderer/Utils_OpenGLRenderer.cpp
View File

@@ -99,7 +99,7 @@ namespace Nz
break;
}
return "Unknown OpenGL error (0x" + String::Number(code, 16).ToStdString() + ')';
return "Unknown OpenGL error (0x" + NumberToString(code, 16) + ')';
}
}

2
src/Nazara/Physics3D/Collider3D.cpp
View File

@@ -30,7 +30,7 @@ namespace Nz
return SphereCollider3D::New(primitive.sphere.size, primitive.matrix.GetTranslation());
}
NazaraError("Primitive type not handled (0x" + String::Number(primitive.type, 16) + ')');
NazaraError("Primitive type not handled (0x" + NumberToString(primitive.type, 16) + ')');
return Collider3DRef();
}
}

6
src/Nazara/Physics3D/PhysWorld3D.cpp
View File

@@ -27,7 +27,7 @@ namespace Nz
NewtonDestroy(m_world);
}
int PhysWorld3D::CreateMaterial(String name)
int PhysWorld3D::CreateMaterial(std::string name)
{
NazaraAssert(m_materialIds.find(name) == m_materialIds.end(), "Material \"" + name + "\" already exists");
@@ -60,7 +60,7 @@ namespace Nz
return m_world;
}
int PhysWorld3D::GetMaterial(const String& name)
int PhysWorld3D::GetMaterial(const std::string& name)
{
auto it = m_materialIds.find(name);
NazaraAssert(it != m_materialIds.end(), "Material \"" + name + "\" does not exists");
@@ -159,7 +159,7 @@ namespace Nz
}
}
int PhysWorld3D::OnAABBOverlap(const NewtonJoint* const contactJoint, dFloat timestep, int threadIndex)
int PhysWorld3D::OnAABBOverlap(const NewtonJoint* const contactJoint, float timestep, int threadIndex)
{
RigidBody3D* bodyA = static_cast<RigidBody3D*>(NewtonBodyGetUserData(NewtonJointGetBody0(contactJoint)));
RigidBody3D* bodyB = static_cast<RigidBody3D*>(NewtonBodyGetUserData(NewtonJointGetBody1(contactJoint)));

2
src/Nazara/Physics3D/RigidBody3D.cpp
View File

@@ -345,7 +345,7 @@ namespace Nz
NewtonBodySetCentreOfMass(m_body, &center.x);
}
void RigidBody3D::SetMaterial(const String& materialName)
void RigidBody3D::SetMaterial(const std::string& materialName)
{
SetMaterial(m_world->GetMaterial(materialName));
}

4
src/Nazara/Platform/Keyboard.cpp
View File

@@ -8,12 +8,12 @@
namespace Nz
{
String Keyboard::GetKeyName(Scancode scancode)
std::string Keyboard::GetKeyName(Scancode scancode)
{
return EventImpl::GetKeyName(scancode);
}
String Keyboard::GetKeyName(VKey key)
std::string Keyboard::GetKeyName(VKey key)
{
return EventImpl::GetKeyName(key);
}

18
src/Nazara/Platform/SDL2/InputImpl.cpp
View File

@@ -2,9 +2,9 @@
// This file is part of the "Nazara Engine - Platform module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Platform/SDL2/InputImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Platform/Debug.hpp>
#include <Nazara/Platform/SDL2/InputImpl.hpp>
#include <Nazara/Platform/SDL2/SDLHelper.hpp>
#include <Nazara/Platform/SDL2/WindowImpl.hpp>
#include <Nazara/Platform/Window.hpp>
@@ -14,26 +14,30 @@
namespace Nz
{
String EventImpl::GetKeyName(Keyboard::Scancode key)
std::string EventImpl::GetKeyName(Keyboard::Scancode key)
{
SDL_Scancode scancode = SDLHelper::ToSDL(key);
String name;
std::string name;
if (scancode != SDL_SCANCODE_UNKNOWN)
name = SDL_GetScancodeName(scancode);
else
name = "Unknown";
return !name.IsEmpty() ? name : String::Unicode("Unknown");
return name;
}
String EventImpl::GetKeyName(Keyboard::VKey key)
std::string EventImpl::GetKeyName(Keyboard::VKey key)
{
SDL_Keycode vkey = SDLHelper::ToSDL(key);
String name;
std::string name;
if (vkey != SDLK_UNKNOWN)
name = SDL_GetKeyName(vkey);
else
name = "Unknown";
return !name.IsEmpty() ? name : String::Unicode("Unknown");
return name;
}
Vector2i EventImpl::GetMousePosition()

6
src/Nazara/Platform/SDL2/InputImpl.hpp
View File

@@ -7,18 +7,18 @@
#ifndef NAZARA_INPUTIMPL_HPP
#define NAZARA_INPUTIMPL_HPP
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Platform/Keyboard.hpp>
#include <Nazara/Platform/Mouse.hpp>
#include <string>
namespace Nz
{
class EventImpl
{
public:
static String GetKeyName(Keyboard::Scancode scancode);
static String GetKeyName(Keyboard::VKey key);
static std::string GetKeyName(Keyboard::Scancode scancode);
static std::string GetKeyName(Keyboard::VKey key);
static Vector2i GetMousePosition();
static Vector2i GetMousePosition(const Window& relativeTo);
static bool IsKeyPressed(Keyboard::Scancode key);

16
src/Nazara/Platform/SDL2/WindowImpl.cpp
View File

@@ -2,6 +2,7 @@
// This file is part of the "Nazara Engine - Platform module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Platform/SDL2/WindowImpl.hpp>
#include <cstdio>
#include <memory>
#include <Nazara/Core/Error.hpp>
@@ -12,7 +13,6 @@
#include <Nazara/Platform/SDL2/CursorImpl.hpp>
#include <Nazara/Platform/SDL2/IconImpl.hpp>
#include <Nazara/Platform/SDL2/SDLHelper.hpp>
#include <Nazara/Platform/SDL2/WindowImpl.hpp>
#include <Nazara/Utility/Image.hpp>
#include <SDL2/SDL.h>
#include <SDL2/SDL_syswm.h>
@@ -60,7 +60,7 @@ namespace Nz
m_cursor = SDL_GetDefaultCursor();
}
bool WindowImpl::Create(const VideoMode& mode, const String& title, WindowStyleFlags style)
bool WindowImpl::Create(const VideoMode& mode, const std::string& title, WindowStyleFlags style)
{
bool async = (style & WindowStyle_Threaded) != 0;
if (async)
@@ -108,7 +108,7 @@ namespace Nz
m_sizemove = false;
m_style = style;
m_handle = SDL_CreateWindow(title.GetConstBuffer(), x, y, width, height, winStyle);
m_handle = SDL_CreateWindow(title.c_str(), x, y, width, height, winStyle);
if (!m_handle)
{
@@ -240,9 +240,9 @@ namespace Nz
return handle;
}
String WindowImpl::GetTitle() const
std::string WindowImpl::GetTitle() const
{
return String::Unicode(SDL_GetWindowTitle(m_handle));
return SDL_GetWindowTitle(m_handle);
}
bool WindowImpl::HasFocus() const
@@ -491,7 +491,7 @@ namespace Nz
evt.type = WindowEventType_TextEntered;
evt.text.repeated = false;
for (decltype(evt.text.character) codepoint : String::Unicode(event->text.text).Simplify().GetUtf32String())
for (decltype(evt.text.character) codepoint : ToUtf32String(event->text.text))
{
evt.text.character = codepoint;
@@ -589,9 +589,9 @@ namespace Nz
NazaraDebug("Stay on top isn't supported by SDL2 backend for now");
}
void WindowImpl::SetTitle(const String& title)
void WindowImpl::SetTitle(const std::string& title)
{
SDL_SetWindowTitle(m_handle, title.GetConstBuffer());
SDL_SetWindowTitle(m_handle, title.c_str());
}
void WindowImpl::SetVisible(bool visible)

8
src/Nazara/Platform/SDL2/WindowImpl.hpp
View File

@@ -9,7 +9,6 @@
#ifndef NAZARA_WINDOWIMPL_HPP
#define NAZARA_WINDOWIMPL_HPP
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Rect.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Platform/Config.hpp>
@@ -21,6 +20,7 @@
#include <SDL2/SDL_events.h>
#include <SDL2/SDL_keyboard.h>
#include <SDL2/SDL_video.h>
#include <string>
namespace Nz
{
@@ -34,7 +34,7 @@ namespace Nz
WindowImpl(WindowImpl&&) = delete; ///TODO?
~WindowImpl() = default;
bool Create(const VideoMode& mode, const String& title, WindowStyleFlags style);
bool Create(const VideoMode& mode, const std::string& title, WindowStyleFlags style);
bool Create(void* handle);
void Destroy();
@@ -47,7 +47,7 @@ namespace Nz
Vector2ui GetSize() const;
WindowStyleFlags GetStyle() const;
WindowHandle GetSystemHandle() const;
String GetTitle() const;
std::string GetTitle() const;
bool HasFocus() const;
@@ -69,7 +69,7 @@ namespace Nz
void SetPosition(int x, int y);
void SetSize(unsigned int width, unsigned int height);
void SetStayOnTop(bool stayOnTop);
void SetTitle(const String& title);
void SetTitle(const std::string& title);
void SetVisible(bool visible);
WindowImpl& operator=(const WindowImpl&) = delete;

12
src/Nazara/Platform/Window.cpp
View File

@@ -7,7 +7,7 @@
#include <Nazara/Core/Error.hpp>
#include <Nazara/Platform/Cursor.hpp>
#include <Nazara/Platform/Icon.hpp>
#include <Nazara/Platform/SDL2/WindowImpl.hpp>
#include <Nazara/Platform/SDL2/WindowImpl.hpp>
#include <Nazara/Platform/Debug.hpp>
namespace Nz
@@ -50,7 +50,7 @@ namespace Nz
Destroy();
}
bool Window::Create(VideoMode mode, const String& title, WindowStyleFlags style)
bool Window::Create(VideoMode mode, const std::string& title, WindowStyleFlags style)
{
// If the window is already open, we keep its position
bool opened = IsOpen();
@@ -65,7 +65,7 @@ namespace Nz
{
if (fullscreenWindow)
{
NazaraError("Window " + String::Pointer(fullscreenWindow) + " already in fullscreen mode");
NazaraError("Window " + PointerToString(fullscreenWindow) + " already in fullscreen mode");
style &= ~WindowStyle_Fullscreen;
}
else
@@ -245,13 +245,13 @@ namespace Nz
return m_impl->GetSystemHandle();
}
String Window::GetTitle() const
std::string Window::GetTitle() const
{
#if NAZARA_PLATFORM_SAFE
if (!m_impl)
{
NazaraError("Window not created");
return String();
return {};
}
#endif
@@ -508,7 +508,7 @@ namespace Nz
m_impl->SetStayOnTop(stayOnTop);
}
void Window::SetTitle(const String& title)
void Window::SetTitle(const std::string& title)
{
#if NAZARA_PLATFORM_SAFE
if (!m_impl)

2
src/Nazara/Shader/GlslWriter.cpp
View File

@@ -253,7 +253,7 @@ namespace Nz
{
NazaraAssert(m_currentState, "This function should only be called while processing an AST");
String stars((section.size() < 33) ? (36 - section.size()) / 2 : 3, '*');
std::string stars((section.size() < 33) ? (36 - section.size()) / 2 : 3, '*');
m_currentState->stream << "/*" << stars << ' ' << section << ' ' << stars << "*/";
AppendLine();
}

14
src/Nazara/Utility/Animation.cpp
View File

@@ -16,7 +16,7 @@ namespace Nz
{
struct AnimationImpl
{
std::unordered_map<String, std::size_t> sequenceMap;
std::unordered_map<std::string, std::size_t> sequenceMap;
std::vector<Sequence> sequences;
std::vector<SequenceJoint> sequenceJoints; // Uniquement pour les animations squelettiques
AnimationType type;
@@ -58,7 +58,7 @@ namespace Nz
}
}
if (!sequence.name.IsEmpty())
if (!sequence.name.empty())
{
#if NAZARA_UTILITY_SAFE
auto it = m_impl->sequenceMap.find(sequence.name);
@@ -147,7 +147,7 @@ namespace Nz
return m_impl->jointCount;
}
Sequence* Animation::GetSequence(const String& sequenceName)
Sequence* Animation::GetSequence(const std::string& sequenceName)
{
NazaraAssert(m_impl, "Animation not created");
@@ -169,7 +169,7 @@ namespace Nz
return &m_impl->sequences[index];
}
const Sequence* Animation::GetSequence(const String& sequenceName) const
const Sequence* Animation::GetSequence(const std::string& sequenceName) const
{
NazaraAssert(m_impl, "Animation not created");
@@ -198,7 +198,7 @@ namespace Nz
return static_cast<std::size_t>(m_impl->sequences.size());
}
std::size_t Animation::GetSequenceIndex(const String& sequenceName) const
std::size_t Animation::GetSequenceIndex(const std::string& sequenceName) const
{
NazaraAssert(m_impl, "Animation not created");
@@ -235,7 +235,7 @@ namespace Nz
return m_impl->type;
}
bool Animation::HasSequence(const String& sequenceName) const
bool Animation::HasSequence(const std::string& sequenceName) const
{
NazaraAssert(m_impl, "Animation not created");
@@ -261,7 +261,7 @@ namespace Nz
return m_impl != nullptr;
}
void Animation::RemoveSequence(const String& identifier)
void Animation::RemoveSequence(const std::string& identifier)
{
NazaraAssert(m_impl, "Animation not created");

15
src/Nazara/Utility/Font.cpp
View File

@@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Utility/Font.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/FontData.hpp>
#include <Nazara/Utility/FontGlyph.hpp>
@@ -146,13 +147,13 @@ namespace Nz
return count;
}
String Font::GetFamilyName() const
std::string Font::GetFamilyName() const
{
#if NAZARA_UTILITY_SAFE
if (!IsValid())
{
NazaraError("Invalid font");
return String("Invalid font");
return std::string("Invalid font");
}
#endif
@@ -237,13 +238,13 @@ namespace Nz
return it->second;
}
String Font::GetStyleName() const
std::string Font::GetStyleName() const
{
#if NAZARA_UTILITY_SAFE
if (!IsValid())
{
NazaraError("Invalid font");
return String("Invalid font");
return std::string("Invalid font");
}
#endif
@@ -261,10 +262,10 @@ namespace Nz
return PrecacheGlyph(m_glyphes[key], characterSize, style, outlineThickness, character).valid;
}
bool Font::Precache(unsigned int characterSize, TextStyleFlags style, float outlineThickness, const String& characterSet) const
bool Font::Precache(unsigned int characterSize, TextStyleFlags style, float outlineThickness, const std::string& characterSet) const
{
///TODO: Itération UTF-8 => UTF-32 sans allocation de buffer (Exposer utf8cpp ?)
std::u32string set = characterSet.GetUtf32String();
std::u32string set = ToUtf32String(characterSet);
if (set.empty())
{
NazaraError("Invalid character set");
@@ -548,7 +549,7 @@ namespace Nz
glyph.valid = true;
}
else
NazaraWarning("Failed to extract glyph \"" + String::Unicode(character) + "\"");
NazaraWarning("Failed to extract glyph \"" + FromUtf32String(std::u32string_view(&character, 1)) + "\"");
}
else
{

4
src/Nazara/Utility/Formats/DDSLoader.cpp
View File

@@ -99,7 +99,7 @@ namespace Nz
if (byteStream.Read(ptr, byteCount) != byteCount)
{
NazaraError("Failed to read level #" + String::Number(i));
NazaraError("Failed to read level #" + NumberToString(i));
return nullptr;
}
@@ -245,7 +245,7 @@ namespace Nz
buf[3] = (header.format.fourCC >> 24) & 255;
buf[4] = '\0';
NazaraError("Unhandled format \"" + String(buf) + "\"");
NazaraError("Unhandled format \"" + std::string(buf) + "\"");
return false;
}
}

5
src/Nazara/Utility/Formats/FreeTypeLoader.cpp
View File

@@ -17,6 +17,7 @@
#include <Nazara/Utility/FontGlyph.hpp>
#include <memory>
#include <set>
#include <string>
#include <Nazara/Utility/Debug.hpp>
namespace Nz
@@ -243,12 +244,12 @@ namespace Nz
return true;
}
String GetFamilyName() const override
std::string GetFamilyName() const override
{
return m_face->family_name;
}
String GetStyleName() const override
std::string GetStyleName() const override
{
return m_face->style_name;
}

55
src/Nazara/Utility/Formats/MD5AnimParser.cpp
View File

@@ -4,6 +4,7 @@
#include <Nazara/Utility/Formats/MD5AnimParser.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Utility/Config.hpp>
#include <cstdio>
#include <Nazara/Utility/Debug.hpp>
@@ -81,13 +82,13 @@ namespace Nz
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
case 'M': // MD5Version
if (m_currentLine.GetWord(0) != "MD5Version")
if (GetWord(m_currentLine, 0) != "MD5Version")
UnrecognizedLine();
break;
#endif
case 'b': // baseframe/bounds
if (m_currentLine.StartsWith("baseframe {"))
if (StartsWith(m_currentLine, "baseframe {"))
{
if (!ParseBaseframe())
{
@@ -95,7 +96,7 @@ namespace Nz
return false;
}
}
else if (m_currentLine.StartsWith("bounds {"))
else if (StartsWith(m_currentLine, "bounds {"))
{
if (!ParseBounds())
{
@@ -111,7 +112,7 @@ namespace Nz
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
case 'c': // commandline
if (m_currentLine.GetWord(0) != "commandline")
if (GetWord(m_currentLine, 0) != "commandline")
UnrecognizedLine();
break;
#endif
@@ -123,7 +124,7 @@ namespace Nz
{
if (m_frameIndex != index)
{
Error("Unexpected frame index (expected " + String::Number(m_frameIndex) + ", got " + String::Number(index) + ')');
Error("Unexpected frame index (expected " + NumberToString(m_frameIndex) + ", got " + NumberToString(index) + ')');
return false;
}
@@ -145,7 +146,7 @@ namespace Nz
}
case 'h': // hierarchy
if (m_currentLine.StartsWith("hierarchy {"))
if (StartsWith(m_currentLine, "hierarchy {"))
{
if (!ParseHierarchy())
{
@@ -220,7 +221,7 @@ namespace Nz
if (m_frameIndex != frameCount)
{
NazaraError("Missing frame infos: [" + String::Number(m_frameIndex) + ',' + String::Number(frameCount) + ']');
NazaraError("Missing frame infos: [" + NumberToString(m_frameIndex) + ',' + NumberToString(frameCount) + ']');
return false;
}
@@ -250,13 +251,10 @@ namespace Nz
m_lineCount++;
m_currentLine = m_stream.ReadLine();
if (m_currentLine.IsEmpty())
continue;
m_currentLine = m_currentLine.SubStringTo("//"); // On ignore les commentaires
m_currentLine.Simplify(); // Pour un traitement plus simple
if (std::size_t pos = m_currentLine.find("//"); pos != std::string::npos)
m_currentLine.resize(pos);
}
while (m_currentLine.IsEmpty());
while (m_currentLine.empty());
}
else
m_keepLastLine = false;
@@ -264,9 +262,9 @@ namespace Nz
return true;
}
void MD5AnimParser::Error(const String& message)
void MD5AnimParser::Error(const std::string& message)
{
NazaraError(message + " at line #" + String::Number(m_lineCount));
NazaraError(message + " at line #" + NumberToString(m_lineCount));
}
bool MD5AnimParser::ParseBaseframe()
@@ -295,7 +293,7 @@ namespace Nz
if (!Advance())
return false;
if (m_currentLine != '}')
if (m_currentLine != "}")
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
Warning("Bounds braces closing not found");
@@ -336,7 +334,7 @@ namespace Nz
if (!Advance())
return false;
if (m_currentLine != '}')
if (m_currentLine != "}")
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
Warning("Bounds braces closing not found");
@@ -365,7 +363,7 @@ namespace Nz
return false;
}
String line;
std::string line;
std::size_t count = 0;
do
@@ -374,7 +372,7 @@ namespace Nz
return false;
std::size_t index = 0;
std::size_t size = m_currentLine.GetSize();
std::size_t size = m_currentLine.size();
do
{
float f;
@@ -430,7 +428,7 @@ namespace Nz
if (!Advance(false))
return true;
if (m_currentLine != '}')
if (m_currentLine != "}")
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
Warning("Hierarchy braces closing not found");
@@ -457,8 +455,8 @@ namespace Nz
if (!Advance())
return false;
std::size_t pos = m_currentLine.Find(' ');
if (pos == String::npos)
std::size_t pos = m_currentLine.find(' ');
if (pos == std::string::npos)
{
UnrecognizedLine(true);
return false;
@@ -477,15 +475,14 @@ namespace Nz
return false;
}
m_joints[i].name = name;
m_joints[i].name.Trim('"');
m_joints[i].name = Trim(name, '"');
Int32 parent = m_joints[i].parent;
if (parent >= 0)
{
if (static_cast<UInt32>(parent) >= jointCount)
{
Error("Joint's parent is out of bounds (" + String::Number(parent) + " >= " + String::Number(jointCount) + ')');
Error("Joint's parent is out of bounds (" + NumberToString(parent) + " >= " + NumberToString(jointCount) + ')');
return false;
}
}
@@ -494,7 +491,7 @@ namespace Nz
if (!Advance())
return false;
if (m_currentLine != '}')
if (m_currentLine != "}")
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
Warning("Hierarchy braces closing not found");
@@ -507,14 +504,14 @@ namespace Nz
return true;
}
void MD5AnimParser::Warning(const String& message)
void MD5AnimParser::Warning(const std::string& message)
{
NazaraWarning(message + " at line #" + String::Number(m_lineCount));
NazaraWarning(message + " at line #" + NumberToString(m_lineCount));
}
void MD5AnimParser::UnrecognizedLine(bool error)
{
String message = "Unrecognized \"" + m_currentLine + '"';
std::string message = "Unrecognized \"" + m_currentLine + '"';
if (error)
Error(message);

5
src/Nazara/Utility/Formats/MD5MeshParser.cpp
View File

@@ -229,7 +229,7 @@ namespace Nz
return false;
std::size_t pos = m_currentLine.find(' ');
if (pos == String::npos)
if (pos == std::string::npos)
{
UnrecognizedLine(true);
return false;
@@ -250,8 +250,7 @@ namespace Nz
return false;
}
m_joints[i].name = name;
m_joints[i].name.Trim('"');
m_joints[i].name = Trim(name, '"');
Int32 parent = m_joints[i].parent;
if (parent >= 0)

4
src/Nazara/Utility/Formats/MTLParser.cpp
View File

@@ -499,7 +499,7 @@ namespace Nz
});
}
m_outputStream.Clear();
m_outputStream.str({});
EmitLine("# Exported by Nazara Engine");
EmitLine();
@@ -510,7 +510,7 @@ namespace Nz
for (auto& pair : m_materials)
{
const String& matName = pair.first;
const std::string& matName = pair.first;
const Material& mat = pair.second;
Emit("newmtl ");

2
src/Nazara/Utility/Formats/OBJLoader.cpp
View File

@@ -58,7 +58,7 @@ namespace Nz
return false;
}
std::unordered_map<String, ParameterList> materialCache;
std::unordered_map<std::string, ParameterList> materialCache;
std::filesystem::path baseDir = file.GetDirectory();
for (std::size_t i = 0; i < meshCount; ++i)
{

2
src/Nazara/Utility/Formats/OBJParser.cpp
View File

@@ -503,7 +503,7 @@ namespace Nz
});
}
m_outputStream.Clear();
m_outputStream.str({});
EmitLine("# Exported by Nazara Engine");
EmitLine();

21
src/Nazara/Utility/Formats/OBJSaver.cpp
View File

@@ -101,11 +101,8 @@ namespace Nz
{
const ParameterList& matData = mesh.GetMaterialData(i);
String nzname;
std::string name;
if (matData.GetStringParameter(MaterialData::Name, &nzname))
name = nzname.ToStdString();
else
if (!matData.GetStringParameter(MaterialData::Name, &name))
name = "material_" + std::to_string(i);
// Makes sure we only have one material of that name
@@ -117,10 +114,7 @@ namespace Nz
MTLParser::Material* material = mtlFormat.AddMaterial(name);
String strVal;
if (matData.GetStringParameter(MaterialData::FilePath, &strVal))
material->diffuseMap = strVal.ToStdString();
else
if (!matData.GetStringParameter(MaterialData::FilePath, &material->diffuseMap))
{
Color colorVal;
double dValue;
@@ -137,14 +131,9 @@ namespace Nz
if (matData.GetDoubleParameter(MaterialData::Shininess, &dValue))
material->shininess = float(dValue);
if (matData.GetStringParameter(MaterialData::AlphaTexturePath, &strVal))
material->alphaMap = strVal.ToStdString();
if (matData.GetStringParameter(MaterialData::DiffuseTexturePath, &strVal))
material->diffuseMap = strVal.ToStdString();
if (matData.GetStringParameter(MaterialData::SpecularTexturePath, &strVal))
material->specularMap = strVal.ToStdString();
matData.GetStringParameter(MaterialData::AlphaTexturePath, &material->alphaMap);
matData.GetStringParameter(MaterialData::DiffuseTexturePath, &material->diffuseMap);
matData.GetStringParameter(MaterialData::SpecularTexturePath, &material->specularMap);
}
}

22
src/Nazara/Utility/Formats/PCXLoader.cpp
View File

@@ -119,7 +119,7 @@ namespace Nz
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
@@ -130,7 +130,7 @@ namespace Nz
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
}
@@ -174,7 +174,7 @@ namespace Nz
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
@@ -185,7 +185,7 @@ namespace Nz
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
}
@@ -225,14 +225,14 @@ namespace Nz
UInt8 magic;
if (!stream.Read(&magic, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
/* first byte must be equal to 0x0c (12) */
if (magic != 0x0c)
{
NazaraError("Colormap's first byte must be 0x0c (0x" + String::Number(magic, 16) + ')');
NazaraError("Colormap's first byte must be 0x0c (0x" + NumberToString(magic, 16) + ')');
return nullptr;
}
@@ -258,7 +258,7 @@ namespace Nz
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
@@ -269,7 +269,7 @@ namespace Nz
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
}
@@ -302,7 +302,7 @@ namespace Nz
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
@@ -313,7 +313,7 @@ namespace Nz
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + String::Number(stream.GetCursorPos()) + ')');
NazaraError("Failed to read stream (byte " + NumberToString(stream.GetCursorPos()) + ')');
return nullptr;
}
}
@@ -329,7 +329,7 @@ namespace Nz
}
default:
NazaraError("Unsupported " + String::Number(bitCount) + " bitcount for pcx files");
NazaraError("Unsupported " + NumberToString(bitCount) + " bitcount for pcx files");
return nullptr;
}

6
src/Nazara/Utility/Formats/STBLoader.cpp
View File

@@ -9,7 +9,7 @@
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Stream.hpp>
#include <Nazara/Utility/Image.hpp>
#include <set>
#include <unordered_set>
#include <Nazara/Utility/Debug.hpp>
namespace Nz
@@ -38,7 +38,7 @@ namespace Nz
bool IsSupported(const std::string& extension)
{
static std::set<String> supportedExtensions = {"bmp", "gif", "hdr", "jpg", "jpeg", "pic", "png", "ppm", "pgm", "psd", "tga"};
static std::unordered_set<std::string> supportedExtensions = {"bmp", "gif", "hdr", "jpg", "jpeg", "pic", "png", "ppm", "pgm", "psd", "tga"};
return supportedExtensions.find(extension) != supportedExtensions.end();
}
@@ -64,7 +64,7 @@ namespace Nz
UInt8* ptr = stbi_load_from_callbacks(&callbacks, &stream, &width, &height, &bpp, STBI_rgb_alpha);
if (!ptr)
{
NazaraError("Failed to load image: " + String(stbi_failure_reason()));
NazaraError("Failed to load image: " + std::string(stbi_failure_reason()));
return nullptr;
}

4
src/Nazara/Utility/Formats/STBSaver.cpp
View File

@@ -120,7 +120,7 @@ namespace Nz
ImageType type = image.GetType();
if (type != ImageType_1D && type != ImageType_2D)
{
NazaraError("Image type 0x" + String::Number(type, 16) + " is not in a supported format");
NazaraError("Image type 0x" + NumberToString(type, 16) + " is not in a supported format");
return false;
}
@@ -177,7 +177,7 @@ namespace Nz
{
if (imageQuality <= 0 || imageQuality > 100)
{
NazaraError("NativeJPEGSaver_Quality value (" + Nz::String::Number(imageQuality) + ") does not fit in bounds ]0, 100], clamping...");
NazaraError("NativeJPEGSaver_Quality value (" + Nz::NumberToString(imageQuality) + ") does not fit in bounds ]0, 100], clamping...");
imageQuality = Nz::Clamp(imageQuality, 1LL, 100LL);
}
}

4
src/Nazara/Utility/GuillotineImageAtlas.cpp
View File

@@ -32,7 +32,7 @@ namespace Nz
#ifdef NAZARA_DEBUG
if (layers[i] >= m_layers.size())
{
NazaraWarning("Rectangle #" + String::Number(i) + " belong to an out-of-bounds layer (" + String::Number(i) + " >= " + String::Number(m_layers.size()) + ")");
NazaraWarning("Rectangle #" + NumberToString(i) + " belong to an out-of-bounds layer (" + NumberToString(i) + " >= " + NumberToString(m_layers.size()) + ")");
continue;
}
#endif
@@ -57,7 +57,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (layerIndex >= m_layers.size())
{
NazaraError("Layer index out of range (" + String::Number(layerIndex) + " >= " + String::Number(m_layers.size()) + ')');
NazaraError("Layer index out of range (" + NumberToString(layerIndex) + " >= " + NumberToString(m_layers.size()) + ')');
return nullptr;
}
#endif

57
src/Nazara/Utility/Image.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Utility/Image.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/ErrorFlags.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/PixelFormat.hpp>
#include <memory>
@@ -268,7 +269,7 @@ namespace Nz
}
catch (const std::exception& e)
{
NazaraError("Failed to allocate image's level " + String::Number(i) + " (" + String(e.what()) + ')');
NazaraError("Failed to allocate image's level " + NumberToString(i) + " (" + std::string(e.what()) + ')');
return false;
}
}
@@ -448,7 +449,7 @@ namespace Nz
unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth;
if (z >= depth)
{
NazaraError("Z value exceeds depth (" + String::Number(z) + " >= " + String::Number(depth) + ')');
NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')');
return false;
}
#endif
@@ -574,7 +575,7 @@ namespace Nz
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return nullptr;
}
#endif
@@ -583,7 +584,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (x >= width)
{
NazaraError("X value exceeds width (" + String::Number(x) + " >= " + String::Number(width) + ')');
NazaraError("X value exceeds width (" + NumberToString(x) + " >= " + NumberToString(width) + ')');
return nullptr;
}
#endif
@@ -592,14 +593,14 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (y >= height)
{
NazaraError("Y value exceeds height (" + String::Number(y) + " >= " + String::Number(height) + ')');
NazaraError("Y value exceeds height (" + NumberToString(y) + " >= " + NumberToString(height) + ')');
return nullptr;
}
unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level);
if (z >= depth)
{
NazaraError("Z value exceeds depth (" + String::Number(z) + " >= " + String::Number(depth) + ')');
NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')');
return nullptr;
}
#endif
@@ -612,7 +613,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return 0;
}
#endif
@@ -630,7 +631,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return 0;
}
#endif
@@ -697,20 +698,20 @@ namespace Nz
if (x >= m_sharedImage->width)
{
NazaraError("X value exceeds width (" + String::Number(x) + " >= " + String::Number(m_sharedImage->width) + ')');
NazaraError("X value exceeds width (" + NumberToString(x) + " >= " + NumberToString(m_sharedImage->width) + ')');
return Color();
}
if (y >= m_sharedImage->height)
{
NazaraError("Y value exceeds height (" + String::Number(y) + " >= " + String::Number(m_sharedImage->height) + ')');
NazaraError("Y value exceeds height (" + NumberToString(y) + " >= " + NumberToString(m_sharedImage->height) + ')');
return Color();
}
unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth;
if (z >= depth)
{
NazaraError("Z value exceeds depth (" + String::Number(z) + " >= " + String::Number(depth) + ')');
NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')');
return Color();
}
#endif
@@ -735,7 +736,7 @@ namespace Nz
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return nullptr;
}
#endif
@@ -744,7 +745,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (x >= width)
{
NazaraError("X value exceeds width (" + String::Number(x) + " >= " + String::Number(width) + ')');
NazaraError("X value exceeds width (" + NumberToString(x) + " >= " + NumberToString(width) + ')');
return nullptr;
}
#endif
@@ -753,20 +754,20 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (y >= height)
{
NazaraError("Y value exceeds height (" + String::Number(y) + " >= " + String::Number(height) + ')');
NazaraError("Y value exceeds height (" + NumberToString(y) + " >= " + NumberToString(height) + ')');
return nullptr;
}
unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : GetLevelSize(m_sharedImage->depth, level);
if (z >= depth)
{
NazaraError("Z value exceeds depth (" + String::Number(z) + " >= " + String::Number(depth) + ')');
NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')');
return nullptr;
}
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return nullptr;
}
#endif
@@ -781,7 +782,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return Vector3ui::Zero();
}
#endif
@@ -799,7 +800,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return 0;
}
#endif
@@ -885,7 +886,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (type != ImageType_1D && type != ImageType_2D)
{
NazaraError("Image type not handled (0x" + String::Number(type, 16) + ')');
NazaraError("Image type not handled (0x" + NumberToString(type, 16) + ')');
return nullptr;
}
#endif
@@ -894,12 +895,12 @@ namespace Nz
if (imageSize.x % atlasSize.x != 0)
{
NazaraWarning("Image width is not divisible by atlas width (" + String::Number(imageSize.x) + " mod " + String::Number(atlasSize.x) + " != 0)");
NazaraWarning("Image width is not divisible by atlas width (" + NumberToString(imageSize.x) + " mod " + NumberToString(atlasSize.x) + " != 0)");
}
if (imageSize.y % atlasSize.y != 0)
{
NazaraWarning("Image height is not divisible by atlas height (" + String::Number(imageSize.y) + " mod " + String::Number(atlasSize.y) + " != 0)");
NazaraWarning("Image height is not divisible by atlas height (" + NumberToString(imageSize.y) + " mod " + NumberToString(atlasSize.y) + " != 0)");
}
Vector2ui faceSize = imageSize/atlasSize;
@@ -971,7 +972,7 @@ namespace Nz
ImageType type = image->GetType();
if (type != ImageType_2D)
{
NazaraError("Image type not handled (0x" + String::Number(type, 16) + ')');
NazaraError("Image type not handled (0x" + NumberToString(type, 16) + ')');
return nullptr;
}
#endif
@@ -1216,20 +1217,20 @@ namespace Nz
if (x >= m_sharedImage->width)
{
NazaraError("X value exceeds width (" + String::Number(x) + " >= " + String::Number(m_sharedImage->width) + ')');
NazaraError("X value exceeds width (" + NumberToString(x) + " >= " + NumberToString(m_sharedImage->width) + ')');
return false;
}
if (y >= m_sharedImage->height)
{
NazaraError("Y value exceeds height (" + String::Number(y) + " >= " + String::Number(m_sharedImage->height) + ')');
NazaraError("Y value exceeds height (" + NumberToString(y) + " >= " + NumberToString(m_sharedImage->height) + ')');
return false;
}
unsigned int depth = (m_sharedImage->type == ImageType_Cubemap) ? 6 : m_sharedImage->depth;
if (z >= depth)
{
NazaraError("Z value exceeds depth (" + String::Number(z) + " >= " + String::Number(depth) + ')');
NazaraError("Z value exceeds depth (" + NumberToString(z) + " >= " + NumberToString(depth) + ')');
return false;
}
#endif
@@ -1262,7 +1263,7 @@ namespace Nz
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return false;
}
#endif
@@ -1296,7 +1297,7 @@ namespace Nz
if (level >= m_sharedImage->levels.size())
{
NazaraError("Level out of bounds (" + String::Number(level) + " >= " + String::Number(m_sharedImage->levels.size()) + ')');
NazaraError("Level out of bounds (" + NumberToString(level) + " >= " + NumberToString(m_sharedImage->levels.size()) + ')');
return false;
}
#endif
@@ -1425,7 +1426,7 @@ namespace Nz
return GetMaxLevel(width, height, depth);
}
NazaraError("Image type not handled (0x" + String::Number(type, 16) + ')');
NazaraError("Image type not handled (0x" + NumberToString(type, 16) + ')');
return 0;
}

6
src/Nazara/Utility/Joint.cpp
View File

@@ -34,7 +34,7 @@ namespace Nz
return m_inverseBindMatrix;
}
String Joint::GetName() const
const std::string& Joint::GetName() const
{
return m_name;
}
@@ -63,9 +63,9 @@ namespace Nz
m_skinningMatrixUpdated = false;
}
void Joint::SetName(const String& name)
void Joint::SetName(std::string name)
{
m_name = name;
m_name = std::move(name);
m_skeleton->InvalidateJointMap();
}

3
src/Nazara/Utility/Mesh.cpp
View File

@@ -6,6 +6,7 @@
#include <Nazara/Core/Enums.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/PrimitiveList.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Utility/Algorithm.hpp>
#include <Nazara/Utility/Buffer.hpp>
#include <Nazara/Utility/Config.hpp>
@@ -613,7 +614,7 @@ namespace Nz
if (matIndex >= matCount)
{
data.subMesh->SetMaterialIndex(0); // To prevent a crash
NazaraWarning("SubMesh " + String::Pointer(data.subMesh) + " material index is over mesh new material count (" + String::Number(matIndex) + " >= " + String::Number(matCount) + "), setting it to first material");
NazaraWarning("SubMesh " + PointerToString(data.subMesh) + " material index is over mesh new material count (" + NumberToString(matIndex) + " >= " + NumberToString(matCount) + "), setting it to first material");
}
}
#endif

6
src/Nazara/Utility/Node.cpp
View File

@@ -158,7 +158,7 @@ namespace Nz
return m_position;
}
NazaraError("Coordinate system out of enum (0x" + String::Number(coordSys, 16) + ')');
NazaraError("Coordinate system out of enum (0x" + NumberToString(coordSys, 16) + ')');
return Vector3f();
}
@@ -184,7 +184,7 @@ namespace Nz
return m_rotation;
}
NazaraError("Coordinate system out of enum (0x" + String::Number(coordSys, 16) + ')');
NazaraError("Coordinate system out of enum (0x" + NumberToString(coordSys, 16) + ')');
return Quaternionf();
}
@@ -202,7 +202,7 @@ namespace Nz
return m_scale;
}
NazaraError("Coordinate system out of enum (0x" + String::Number(coordSys, 16) + ')');
NazaraError("Coordinate system out of enum (0x" + NumberToString(coordSys, 16) + ')');
return Vector3f();
}

2
src/Nazara/Utility/PixelFormat.cpp
View File

@@ -1440,7 +1440,7 @@ namespace Nz
for (unsigned int i = 0; i <= PixelFormat_Max; ++i)
{
if (!s_pixelFormatInfos[i].Validate())
NazaraWarning("Pixel format 0x" + String::Number(i, 16) + " (" + GetName(static_cast<Nz::PixelFormat>(i)) + ") failed validation tests");
NazaraWarning("Pixel format 0x" + NumberToString(i, 16) + " (" + GetName(static_cast<Nz::PixelFormat>(i)) + ") failed validation tests");
}
// Reset functions

20
src/Nazara/Utility/RichTextDrawer.cpp
View File

@@ -55,9 +55,9 @@ namespace Nz
RichTextDrawer::~RichTextDrawer() = default;
auto RichTextDrawer::AppendText(const String& str, bool forceNewBlock) -> BlockRef
auto RichTextDrawer::AppendText(const std::string& str, bool forceNewBlock) -> BlockRef
{
NazaraAssert(!str.IsEmpty(), "String cannot be empty");
NazaraAssert(!str.empty(), "String cannot be empty");
std::size_t defaultFontIndex = HandleFontAddition(m_defaultFont);
@@ -80,7 +80,7 @@ namespace Nz
if (!m_blocks.empty())
{
Block& lastBlock = m_blocks.back();
glyphIndex = lastBlock.glyphIndex + lastBlock.text.GetLength();
glyphIndex = lastBlock.glyphIndex + lastBlock.text.size();
}
else
glyphIndex = 0;
@@ -209,7 +209,7 @@ namespace Nz
{
NazaraAssert(index < m_blocks.size(), "Invalid block index");
std::size_t textLength = m_blocks[index].text.GetLength();
std::size_t textLength = m_blocks[index].text.size();
ReleaseFont(m_blocks[index].fontIndex);
m_blocks.erase(m_blocks.begin() + index);
@@ -376,13 +376,13 @@ namespace Nz
return false;
};
void RichTextDrawer::GenerateGlyphs(const Font* font, const Color& color, TextStyleFlags style, unsigned int characterSize, const Color& outlineColor, float characterSpacingOffset, float lineSpacingOffset, float outlineThickness, const String& text) const
void RichTextDrawer::GenerateGlyphs(const Font* font, const Color& color, TextStyleFlags style, unsigned int characterSize, const Color& outlineColor, float characterSpacingOffset, float lineSpacingOffset, float outlineThickness, const std::string& text) const
{
if (text.IsEmpty())
if (text.empty())
return;
///TODO: Allow iteration on Unicode characters without allocating any buffer
std::u32string characters = text.GetUtf32String();
std::u32string characters = ToUtf32String(text);
if (characters.empty())
{
NazaraError("Invalid character set");
@@ -503,7 +503,7 @@ namespace Nz
auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font == font; });
if (it == m_fonts.end())
{
NazaraInternalError("Not listening to " + String::Pointer(font));
NazaraInternalError("Not listening to " + PointerToString(font));
return;
}
#endif
@@ -525,7 +525,7 @@ namespace Nz
auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font == font; });
if (it == m_fonts.end())
{
NazaraInternalError("Not listening to " + String::Pointer(font));
NazaraInternalError("Not listening to " + PointerToString(font));
return;
}
#endif
@@ -542,7 +542,7 @@ namespace Nz
auto it = std::find_if(m_fonts.begin(), m_fonts.end(), [font](const auto& fontData) { return fontData.font == font; });
if (it == m_fonts.end())
{
NazaraInternalError("Not listening to " + String::Pointer(font));
NazaraInternalError("Not listening to " + PointerToString(font));
return;
}
#endif

14
src/Nazara/Utility/SimpleTextDrawer.cpp
View File

@@ -11,7 +11,7 @@ namespace Nz
{
void SimpleTextDrawer::Clear()
{
m_text.Clear(true);
m_text.clear();
ClearGlyphs();
}
@@ -182,13 +182,13 @@ namespace Nz
return false;
};
void SimpleTextDrawer::GenerateGlyphs(const String& text) const
void SimpleTextDrawer::GenerateGlyphs(const std::string_view& text) const
{
if (text.IsEmpty())
if (text.empty())
return;
///TODO: Allow iteration on Unicode characters without allocating any buffer
std::u32string characters = text.GetUtf32String();
std::u32string characters = ToUtf32String(text);
if (characters.empty())
{
NazaraError("Invalid character set");
@@ -290,7 +290,7 @@ namespace Nz
#ifdef NAZARA_DEBUG
if (m_font != font)
{
NazaraInternalError("Not listening to " + String::Pointer(font));
NazaraInternalError("Not listening to " + PointerToString(font));
return;
}
#endif
@@ -311,7 +311,7 @@ namespace Nz
#ifdef NAZARA_DEBUG
if (m_font != font)
{
NazaraInternalError("Not listening to " + String::Pointer(font));
NazaraInternalError("Not listening to " + PointerToString(font));
return;
}
#endif
@@ -327,7 +327,7 @@ namespace Nz
#ifdef NAZARA_DEBUG
if (m_font != font)
{
NazaraInternalError("Not listening to " + String::Pointer(font));
NazaraInternalError("Not listening to " + PointerToString(font));
return;
}
#endif

18
src/Nazara/Utility/Skeleton.cpp
View File

@@ -11,7 +11,7 @@ namespace Nz
{
struct SkeletonImpl
{
std::unordered_map<String, std::size_t> jointMap;
std::unordered_map<std::string, std::size_t> jointMap;
std::vector<Joint> joints;
Boxf aabb;
bool aabbUpdated = false;
@@ -90,7 +90,7 @@ namespace Nz
return m_impl->aabb;
}
Joint* Skeleton::GetJoint(const String& jointName)
Joint* Skeleton::GetJoint(const std::string& jointName)
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
@@ -129,7 +129,7 @@ namespace Nz
if (index >= m_impl->joints.size())
{
NazaraError("Joint index out of range (" + String::Number(index) + " >= " + String::Number(m_impl->joints.size()) + ')');
NazaraError("Joint index out of range (" + NumberToString(index) + " >= " + NumberToString(m_impl->joints.size()) + ')');
return nullptr;
}
#endif
@@ -139,7 +139,7 @@ namespace Nz
return &m_impl->joints[index];
}
const Joint* Skeleton::GetJoint(const String& jointName) const
const Joint* Skeleton::GetJoint(const std::string& jointName) const
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
@@ -176,7 +176,7 @@ namespace Nz
if (index >= m_impl->joints.size())
{
NazaraError("Joint index out of range (" + String::Number(index) + " >= " + String::Number(m_impl->joints.size()) + ')');
NazaraError("Joint index out of range (" + NumberToString(index) + " >= " + NumberToString(m_impl->joints.size()) + ')');
return nullptr;
}
#endif
@@ -223,7 +223,7 @@ namespace Nz
return static_cast<std::size_t>(m_impl->joints.size());
}
int Skeleton::GetJointIndex(const String& jointName) const
int Skeleton::GetJointIndex(const std::string& jointName) const
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
@@ -322,7 +322,7 @@ namespace Nz
#if NAZARA_UTILITY_SAFE
if (index >= m_impl->joints.size())
{
NazaraError("Index #" + String::Number(i) + " out of range (" + String::Number(index) + " >= " + String::Number(m_impl->joints.size()) + ')');
NazaraError("Index #" + NumberToString(i) + " out of range (" + NumberToString(index) + " >= " + NumberToString(m_impl->joints.size()) + ')');
return;
}
#endif
@@ -409,8 +409,8 @@ namespace Nz
m_impl->jointMap.clear();
for (std::size_t i = 0; i < m_impl->joints.size(); ++i)
{
String name = m_impl->joints[i].GetName();
if (!name.IsEmpty())
const std::string& name = m_impl->joints[i].GetName();
if (!name.empty())
{
NazaraAssert(m_impl->jointMap.find(name) == m_impl->jointMap.end(), "Joint name \"" + name + "\" is already present in joint map");

2
src/Nazara/Utility/SoftwareBuffer.cpp
View File

@@ -31,7 +31,7 @@ namespace Nz
}
catch (const std::exception& e)
{
NazaraError("Failed to allocate software buffer (" + String(e.what()) + ')');
NazaraError("Failed to allocate software buffer (" + std::string(e.what()) + ')');
return false;
}

3
src/Nazara/Utility/SubMesh.cpp
View File

@@ -4,7 +4,6 @@
#include <Nazara/Utility/SubMesh.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/TriangleIterator.hpp>
#include <Nazara/Utility/VertexMapper.hpp>
@@ -195,7 +194,7 @@ namespace Nz
return indexCount - 2;
}
NazaraError("Primitive mode not handled (0x" + String::Number(m_primitiveMode, 16) + ')');
NazaraError("Primitive mode not handled (0x" + NumberToString(m_primitiveMode, 16) + ')');
return 0;
}

6
src/Nazara/Utility/VertexDeclaration.cpp
View File

@@ -43,7 +43,7 @@ namespace Nz
m_components.reserve(components.size());
for (const ComponentEntry& entry : components)
{
NazaraAssert(IsTypeSupported(entry.type), "Component type 0x" + String::Number(entry.type, 16) + " is not supported by vertex declarations");
NazaraAssert(IsTypeSupported(entry.type), "Component type 0x" + NumberToString(entry.type, 16) + " is not supported by vertex declarations");
NazaraAssert(entry.componentIndex == 0 || entry.component == VertexComponent_Userdata, "Only userdata components can have non-zero component indexes");
if (entry.component != VertexComponent_Unused)
@@ -91,7 +91,7 @@ namespace Nz
return false;
}
NazaraError("Component type not handled (0x" + String::Number(type, 16) + ')');
NazaraError("Component type not handled (0x" + NumberToString(type, 16) + ')');
return false;
}
@@ -350,7 +350,7 @@ namespace Nz
}
catch (const std::exception& e)
{
NazaraError("Failed to initialize vertex declaration: " + String(e.what()));
NazaraError("Failed to initialize vertex declaration: " + std::string(e.what()));
return false;
}

4
src/Nazara/Utility/VertexMapper.cpp
View File

@@ -36,7 +36,7 @@ namespace Nz
if (!buffer)
{
NazaraInternalError("Animation type not handled (0x" + String::Number(subMesh->GetAnimationType(), 16) + ')');
NazaraInternalError("Animation type not handled (0x" + NumberToString(subMesh->GetAnimationType(), 16) + ')');
}
m_mapper.Map(buffer, access);
@@ -72,7 +72,7 @@ namespace Nz
if (!buffer)
{
NazaraInternalError("Animation type not handled (0x" + String::Number(subMesh->GetAnimationType(), 16) + ')');
NazaraInternalError("Animation type not handled (0x" + NumberToString(subMesh->GetAnimationType(), 16) + ')');
}
m_mapper.Map(buffer, access);

3
src/Nazara/VulkanRenderer/Utils_VulkanRenderer.cpp
View File

@@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/VulkanRenderer/Utils.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/VulkanRenderer/Debug.hpp>
namespace Nz
@@ -97,7 +98,7 @@ namespace Nz
break;
}
return "Unknown Vulkan error (0x" + String::Number(code, 16).ToStdString() + ')';
return "Unknown Vulkan error (0x" + NumberToString(code, 16) + ')';
}
}

2
src/Nazara/VulkanRenderer/VkRenderWindow.cpp
View File

@@ -389,7 +389,7 @@ namespace Nz
if (!framebuffers[i].Create(*m_device, frameBufferCreate))
{
NazaraError("Failed to create framebuffer for image #" + String::Number(i) + ": " + TranslateVulkanError(framebuffers[i].GetLastErrorCode()));
NazaraError("Failed to create framebuffer for image #" + NumberToString(i) + ": " + TranslateVulkanError(framebuffers[i].GetLastErrorCode()));
return false;
}
}

48
src/Nazara/VulkanRenderer/Vulkan.cpp
View File

@@ -35,7 +35,7 @@ namespace Nz
}
// This cannot happen if physDevice is valid, as we retrieved every physical device
NazaraInternalError("Invalid physical device: " + String::Pointer(physDevice));
NazaraInternalError("Invalid physical device: " + PointerToString(physDevice));
static Vk::PhysicalDevice dummy;
return dummy;
@@ -54,8 +54,8 @@ namespace Nz
CallOnExit onExit(Vulkan::Uninitialize);
String appName = "Another application made with Nazara Engine";
String engineName = "Nazara Engine - Vulkan Renderer";
std::string appName = "Another application made with Nazara Engine";
std::string engineName = "Nazara Engine - Vulkan Renderer";
UInt32 appVersion = VK_MAKE_VERSION(1, 0, 0);
UInt32 engineVersion = VK_MAKE_VERSION(1, 0, 0);
@@ -89,9 +89,9 @@ namespace Nz
VkApplicationInfo appInfo = {
VK_STRUCTURE_TYPE_APPLICATION_INFO,
nullptr,
appName.GetConstBuffer(),
appName.c_str(),
appVersion,
engineName.GetConstBuffer(),
engineName.c_str(),
engineVersion,
targetApiVersion
};
@@ -126,18 +126,18 @@ namespace Nz
}
std::vector<const char*> enabledExtensions;
std::vector<String> additionalLayers; // Just to keep the String alive
std::vector<std::string> additionalLayers; // Just to keep the String alive
if (parameters.GetIntegerParameter("VkInstanceInfo_EnabledLayerCount", &iParam))
{
additionalLayers.reserve(iParam);
for (long long i = 0; i < iParam; ++i)
{
Nz::String parameterName = "VkInstanceInfo_EnabledLayer" + String::Number(i);
Nz::String layer;
std::string parameterName = "VkInstanceInfo_EnabledLayer" + NumberToString(i);
std::string layer;
if (parameters.GetStringParameter(parameterName, &layer))
{
additionalLayers.emplace_back(std::move(layer));
enabledLayers.push_back(additionalLayers.back().GetConstBuffer());
enabledLayers.push_back(additionalLayers.back().c_str());
}
else
NazaraWarning("Parameter " + parameterName + " expected");
@@ -184,18 +184,18 @@ namespace Nz
enabledExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
}
std::vector<String> additionalExtensions; // Just to keep the String alive
std::vector<std::string> additionalExtensions; // Just to keep the String alive
if (parameters.GetIntegerParameter("VkInstanceInfo_EnabledExtensionCount", &iParam))
{
additionalExtensions.reserve(iParam);
for (int i = 0; i < iParam; ++i)
{
Nz::String parameterName = "VkInstanceInfo_EnabledExtension" + String::Number(i);
Nz::String extension;
std::string parameterName = "VkInstanceInfo_EnabledExtension" + NumberToString(i);
std::string extension;
if (parameters.GetStringParameter(parameterName, &extension))
{
additionalExtensions.emplace_back(std::move(extension));
enabledExtensions.push_back(additionalExtensions.back().GetConstBuffer());
enabledExtensions.push_back(additionalExtensions.back().c_str());
}
else
NazaraWarning("Parameter " + parameterName + " expected");
@@ -232,7 +232,7 @@ namespace Nz
Vk::PhysicalDevice deviceInfo;
if (!s_instance.GetPhysicalDeviceQueueFamilyProperties(physDevice, &deviceInfo.queueFamilies))
{
NazaraWarning("Failed to query physical device queue family properties for " + String(deviceInfo.properties.deviceName) + " (0x" + String::Number(deviceInfo.properties.deviceID, 16) + ')');
NazaraWarning("Failed to query physical device queue family properties for " + std::string(deviceInfo.properties.deviceName) + " (0x" + NumberToString(deviceInfo.properties.deviceID, 16) + ')');
continue;
}
@@ -249,7 +249,7 @@ namespace Nz
deviceInfo.extensions.emplace(extProperty.extensionName);
}
else
NazaraWarning("Failed to query physical device extensions for " + String(deviceInfo.properties.deviceName) + " (0x" + String::Number(deviceInfo.properties.deviceID, 16) + ')');
NazaraWarning("Failed to query physical device extensions for " + std::string(deviceInfo.properties.deviceName) + " (0x" + NumberToString(deviceInfo.properties.deviceID, 16) + ')');
s_physDevices.emplace_back(std::move(deviceInfo));
}
@@ -322,7 +322,7 @@ namespace Nz
{
bool supportPresentation = false;
if (!surface.GetSupportPresentation(deviceInfo.physDevice, i, &supportPresentation))
NazaraWarning("Failed to get presentation support of queue family #" + String::Number(i));
NazaraWarning("Failed to get presentation support of queue family #" + NumberToString(i));
if (deviceInfo.queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
@@ -422,18 +422,18 @@ namespace Nz
//< Nazara default layers goes here
}
std::vector<String> additionalLayers; // Just to keep the String alive
std::vector<std::string> additionalLayers; // Just to keep the string alive
if (s_initializationParameters.GetIntegerParameter("VkDeviceInfo_EnabledLayerCount", &iParam))
{
additionalLayers.reserve(iParam);
for (long long i = 0; i < iParam; ++i)
{
Nz::String parameterName = "VkDeviceInfo_EnabledLayer" + String::Number(i);
Nz::String layer;
std::string parameterName = "VkDeviceInfo_EnabledLayer" + NumberToString(i);
std::string layer;
if (s_initializationParameters.GetStringParameter(parameterName, &layer))
{
additionalLayers.emplace_back(std::move(layer));
enabledLayers.push_back(additionalLayers.back().GetConstBuffer());
enabledLayers.push_back(additionalLayers.back().c_str());
}
else
NazaraWarning("Parameter " + parameterName + " expected");
@@ -457,17 +457,17 @@ namespace Nz
EnableIfSupported(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME);
}
std::vector<String> additionalExtensions; // Just to keep the String alive
std::vector<std::string> additionalExtensions; // Just to keep the String alive
if (s_initializationParameters.GetIntegerParameter("VkDeviceInfo_EnabledExtensionCount", &iParam))
{
for (long long i = 0; i < iParam; ++i)
{
Nz::String parameterName = "VkDeviceInfo_EnabledExtension" + String::Number(i);
Nz::String extension;
std::string parameterName = "VkDeviceInfo_EnabledExtension" + NumberToString(i);
std::string extension;
if (s_initializationParameters.GetStringParameter(parameterName, &extension))
{
additionalExtensions.emplace_back(std::move(extension));
enabledExtensions.push_back(additionalExtensions.back().GetConstBuffer());
enabledExtensions.push_back(additionalExtensions.back().c_str());
}
else
NazaraWarning("Parameter " + parameterName + " expected");

1
src/Nazara/VulkanRenderer/VulkanBuffer.cpp
View File

@@ -4,7 +4,6 @@
#include <Nazara/VulkanRenderer/VulkanBuffer.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/VulkanRenderer/Wrapper/CommandBuffer.hpp>
#include <Nazara/VulkanRenderer/Wrapper/QueueHandle.hpp>
#include <vma/vk_mem_alloc.h>

2
src/Nazara/VulkanRenderer/VulkanRenderer.cpp
View File

@@ -88,7 +88,7 @@ namespace Nz
break;
default:
NazaraWarning("Device " + device.name + " has handled device type (0x" + String::Number(physDevice.properties.deviceType, 16) + ')');
NazaraWarning("Device " + device.name + " has handled device type (0x" + NumberToString(physDevice.properties.deviceType, 16) + ')');
// fallthrough
case VK_PHYSICAL_DEVICE_TYPE_OTHER:
device.type = RenderDeviceType::Unknown;

2
src/Nazara/VulkanRenderer/VulkanTexture.cpp
View File

@@ -270,7 +270,7 @@ namespace Nz
}
default:
throw std::runtime_error(("Unsupported pixel format " + PixelFormatInfo::GetName(pixelFormat)).ToStdString());
throw std::runtime_error("Unsupported pixel format " + PixelFormatInfo::GetName(pixelFormat));
}
}
}

13
src/NazaraSDK/Application.cpp
View File

@@ -4,6 +4,7 @@
#include <NazaraSDK/Application.hpp>
#include <Nazara/Core/Log.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <regex>
#ifndef NDK_SERVER
@@ -43,21 +44,21 @@ namespace Ndk
std::string argument(argv[i]);
if (std::regex_match(argument, results, valueRegex))
{
Nz::String key(results[1].str());
Nz::String value(results[2].str());
std::string key = Nz::ToLower(results[1].str());
std::string value(results[2].str());
m_parameters[key.ToLower()] = value;
NazaraDebug("Registred parameter from command-line: " + key.ToLower() + "=" + value);
m_parameters[key] = value;
NazaraDebug("Registred parameter from command-line: " + key + "=" + value);
}
else if (std::regex_match(argument, results, optionRegex))
{
Nz::String option(results[1].str());
std::string option(results[1].str());
m_options.insert(option);
NazaraDebug("Registred option from command-line: " + option);
}
else
NazaraWarning("Ignored command-line argument #" + Nz::String::Number(i) + " \"" + argument + '"');
NazaraWarning("Ignored command-line argument #" + Nz::NumberToString(i) + " \"" + argument + '"');
}
}

2
src/NazaraSDK/Systems/ListenerSystem.cpp
View File

@@ -65,7 +65,7 @@ namespace Ndk
}
if (activeListenerCount > 1)
NazaraWarning(Nz::String::Number(activeListenerCount) + " listeners were active in the same update loop");
NazaraWarning(Nz::NumberToString(activeListenerCount) + " listeners were active in the same update loop");
}
SystemIndex ListenerSystem::systemIndex;