@@ -17,9 +17,6 @@

 #include "XSFCommon.h"

 #include "XSFFile.h"

 #include "convert.h"

-#if defined(_WIN32) && !defined(_MSC_VER)

-# include "fstream_wfopen.h"

-#endif

 #include "zlib.h"

 static inline void Set32BitsLE(std::uint32_t input, std::uint8_t *output)

@@ -61,65 +58,33 @@ static inline std::string TrimWhitespace(const std::string &orig)

 	return LeftTrimWhitespace(RightTrimWhitespace(orig));

 }

-XSFFile::XSFFile() : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName("")

+XSFFile::XSFFile() : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), filePath()

 {

 }

-XSFFile::XSFFile(const std::string &filename) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

+XSFFile::XSFFile(const std::filesystem::path &path) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), filePath(path)

 {

-	this->ReadXSF(filename, 0, 0, true);

+	this->ReadXSF(path, 0, 0, true);

 }

-XSFFile::XSFFile(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

+XSFFile::XSFFile(const std::filesystem::path &path, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), filePath(path)

 {

-	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

+	this->ReadXSF(path, programSizeOffset, programHeaderSize);

 }

-#ifdef _WIN32

-XSFFile::XSFFile(const std::wstring &filename) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

+void XSFFile::ReadXSF(const std::filesystem::path &path, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

 {

-	this->ReadXSF(filename, 0, 0, true);

-}

-

-XSFFile::XSFFile(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

-{

-	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

-}

-#endif

-

-void XSFFile::ReadXSF(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

-{

-	if (!std::filesystem::is_regular_file(filename))

-		throw std::logic_error("File " + filename + " does not exist.");

-

-	std::ifstream xSF;

-	xSF.exceptions(std::ifstream::failbit | std::ifstream::badbit);

-	xSF.open(filename.c_str(), std::ifstream::in | std::ifstream::binary);

-

-	this->ReadXSF(xSF, programSizeOffset, programHeaderSize, readTagsOnly);

-

-	xSF.close();

-}

-

-#ifdef _WIN32

-void XSFFile::ReadXSF(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

-{

-	if (!std::filesystem::is_regular_file(filename))

-		throw std::logic_error("File " + ConvertFuncs::WStringToString(filename) + " does not exist.");

+	if (!std::filesystem::is_regular_file(path))

+		throw std::logic_error("File " + path.string() + " does not exist.");

-#if defined(_WIN32) && !defined(_MSC_VER)

-	ifstream_wfopen xSF;

-#else

 	std::ifstream xSF;

-#endif

 	xSF.exceptions(std::ifstream::failbit | std::ifstream::badbit);

-	xSF.open(filename.c_str(), std::ifstream::in | std::ifstream::binary);

+	xSF.open(path, std::ifstream::in | std::ifstream::binary);

 	this->ReadXSF(xSF, programSizeOffset, programHeaderSize, readTagsOnly);

 	xSF.close();

 }

-#endif

 void XSFFile::ReadXSF(std::ifstream &xSF, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

 {

@@ -462,29 +427,21 @@ std::string XSFFile::GetFormattedTitle(const std::string &format) const

 	return formattedTitle;

 }

-std::string XSFFile::GetFilename() const

+std::filesystem::path XSFFile::GetFilepath() const

 {

-	return this->fileName;

+	return this->filePath;

 }

-std::string XSFFile::GetFilenameWithoutPath() const

+std::filesystem::path XSFFile::GetFilenameWithoutPath() const

 {

-	return std::filesystem::path(this->fileName).filename().string();

+	return this->filePath.filename();

 }

 void XSFFile::SaveFile() const

 {

-#if defined(_WIN32) && !defined(_MSC_VER)

-	ofstream_wfopen xSF;

-#else

 	std::ofstream xSF;

-#endif

 	xSF.exceptions(std::ofstream::failbit);

-#ifdef _WIN32

-	xSF.open(ConvertFuncs::StringToWString(this->fileName).c_str(), std::ofstream::out | std::ofstream::binary);

-#else

-	xSF.open(this->fileName.c_str(), std::ofstream::out | std::ofstream::binary);

-#endif

+	xSF.open(this->filePath, std::ofstream::out | std::ofstream::binary);

 	xSF.write(reinterpret_cast<const char *>(&this->rawData[0]), this->rawData.size());

@@ -7,17 +7,22 @@

 #include <algorithm>

 #include <filesystem>

-#include <functional>

+#include <fstream>

 #include <stdexcept>

+#include <string>

+#include <vector>

+#include <cmath>

+#include <cstddef>

+#include <cstdint>

+#include "XSFCommon.h"

+#include "XSFFile.h"

+#include "convert.h"

 #if defined(_WIN32) && !defined(_MSC_VER)

 # include "fstream_wfopen.h"

 #endif

 #include "zlib.h"

-#include "XSFFile.h"

-#include "XSFCommon.h"

-#include "convert.h"

-static inline void Set32BitsLE(uint32_t input, uint8_t *output)

+static inline void Set32BitsLE(std::uint32_t input, std::uint8_t *output)

 {

 	output[0] = input & 0xFF;

 	output[1] = (input >> 8) & 0xFF;

@@ -65,7 +70,7 @@ XSFFile::XSFFile(const std::string &filename) : xSFType(0), hasFile(false), rawD

 	this->ReadXSF(filename, 0, 0, true);

 }

-XSFFile::XSFFile(const std::string &filename, uint32_t programSizeOffset, uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

+XSFFile::XSFFile(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

 {

 	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

 }

@@ -76,13 +81,13 @@ XSFFile::XSFFile(const std::wstring &filename) : xSFType(0), hasFile(false), raw

 	this->ReadXSF(filename, 0, 0, true);

 }

-XSFFile::XSFFile(const std::wstring &filename, uint32_t programSizeOffset, uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

+XSFFile::XSFFile(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

 {

 	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

 }

 #endif

-void XSFFile::ReadXSF(const std::string &filename, uint32_t programSizeOffset, uint32_t programHeaderSize, bool readTagsOnly)

+void XSFFile::ReadXSF(const std::string &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

 {

 	if (!std::filesystem::is_regular_file(filename))

 		throw std::logic_error("File " + filename + " does not exist.");

@@ -97,7 +102,7 @@ void XSFFile::ReadXSF(const std::string &filename, uint32_t programSizeOffset, u

 }

 #ifdef _WIN32

-void XSFFile::ReadXSF(const std::wstring &filename, uint32_t programSizeOffset, uint32_t programHeaderSize, bool readTagsOnly)

+void XSFFile::ReadXSF(const std::wstring &filename, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

 {

 	if (!std::filesystem::is_regular_file(filename))

 		throw std::logic_error("File " + ConvertFuncs::WStringToString(filename) + " does not exist.");

@@ -116,7 +121,7 @@ void XSFFile::ReadXSF(const std::wstring &filename, uint32_t programSizeOffset,

 }

 #endif

-void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t programHeaderSize, bool readTagsOnly)

+void XSFFile::ReadXSF(std::ifstream &xSF, std::uint32_t programSizeOffset, std::uint32_t programHeaderSize, bool readTagsOnly)

 {

 	xSF.seekg(0, std::ifstream::end);

 	auto filesize = xSF.tellg();

@@ -139,7 +144,7 @@ void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t p

 	if (filesize < 16)

 		throw std::runtime_error("File is too small.");

-	uint32_t reservedSize = Get32BitsLE(xSF), programCompressedSize = Get32BitsLE(xSF);

+	std::uint32_t reservedSize = Get32BitsLE(xSF), programCompressedSize = Get32BitsLE(xSF);

 	this->rawData.resize(reservedSize + programCompressedSize + 16);

 	Set32BitsLE(reservedSize, &this->rawData[4]);

 	Set32BitsLE(programCompressedSize, &this->rawData[8]);

@@ -169,11 +174,11 @@ void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t p

 			xSF.read(reinterpret_cast<char *>(&this->rawData[reservedSize + 16]), programCompressedSize);

 		else

 		{

-			auto programSectionCompressed = std::vector<uint8_t>(programCompressedSize);

+			auto programSectionCompressed = std::vector<std::uint8_t>(programCompressedSize);

 			xSF.read(reinterpret_cast<char *>(&programSectionCompressed[0]), programCompressedSize);

 			std::copy_n(&programSectionCompressed[0], programCompressedSize, &this->rawData[reservedSize + 16]);

-			auto programSectionUncompressed = std::vector<uint8_t>(programHeaderSize);

+			auto programSectionUncompressed = std::vector<std::uint8_t>(programHeaderSize);

 			unsigned long programUncompressedSize = programHeaderSize;

 			uncompress(&programSectionUncompressed[0], &programUncompressedSize, &programSectionCompressed[0], programCompressedSize);

 			programUncompressedSize = Get32BitsLE(&programSectionUncompressed[programSizeOffset]) + programHeaderSize;

@@ -231,7 +236,7 @@ void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t p

 	this->hasFile = true;

 }

-bool XSFFile::IsValidType(uint8_t type) const

+bool XSFFile::IsValidType(std::uint8_t type) const

 {

 	return this->xSFType == type;

 }

@@ -250,22 +255,22 @@ bool XSFFile::HasFile() const

 	return this->hasFile;

 }

-std::vector<uint8_t> &XSFFile::GetReservedSection()

+std::vector<std::uint8_t> &XSFFile::GetReservedSection()

 {

 	return this->reservedSection;

 }

-std::vector<uint8_t> XSFFile::GetReservedSection() const

+std::vector<std::uint8_t> XSFFile::GetReservedSection() const

 {

 	return this->reservedSection;

 }

-std::vector<uint8_t> &XSFFile::GetProgramSection()

+std::vector<std::uint8_t> &XSFFile::GetProgramSection()

 {

 	return this->programSection;

 }

-std::vector<uint8_t> XSFFile::GetProgramSection() const

+std::vector<std::uint8_t> XSFFile::GetProgramSection() const

 {

 	return this->programSection;

 }

@@ -322,19 +327,19 @@ unsigned long XSFFile::GetFadeMS(unsigned long defaultFade) const

 double XSFFile::GetVolume(VolumeType preferredVolumeType, PeakType preferredPeakType) const

 {

-	if (preferredVolumeType == VOLUMETYPE_NONE)

+	if (preferredVolumeType == VolumeType::None)

 		return 1.0;

 	std::string replaygain_album_gain = this->GetTagValue("replaygain_album_gain"), replaygain_album_peak = this->GetTagValue("replaygain_album_peak");

 	std::string replaygain_track_gain = this->GetTagValue("replaygain_track_gain"), replaygain_track_peak = this->GetTagValue("replaygain_track_peak");

 	std::string volume = this->GetTagValue("volume");

 	double gain = 0.0;

 	bool hadReplayGain = false;

-	if (preferredVolumeType == VOLUMETYPE_REPLAYGAIN_ALBUM && !replaygain_album_gain.empty())

+	if (preferredVolumeType == VolumeType::ReplayGainAlbum && !replaygain_album_gain.empty())

 	{

 		gain = convertTo<double>(replaygain_album_gain);

 		hadReplayGain = true;

 	}

-	if (!hadReplayGain && preferredVolumeType != VOLUMETYPE_VOLUME && !replaygain_track_gain.empty())

+	if (!hadReplayGain && preferredVolumeType != VolumeType::Volume && !replaygain_track_gain.empty())

 	{

 		gain = convertTo<double>(replaygain_track_gain);

 		hadReplayGain = true;

@@ -342,9 +347,9 @@ double XSFFile::GetVolume(VolumeType preferredVolumeType, PeakType preferredPeak

 	if (hadReplayGain)

 	{

 		double vol = std::pow(10.0, gain / 20.0), peak = 1.0;

-		if (preferredPeakType == PEAKTYPE_REPLAYGAIN_ALBUM && !replaygain_album_peak.empty())

+		if (preferredPeakType == PeakType::ReplayGainAlbum && !replaygain_album_peak.empty())

 			peak = convertTo<double>(replaygain_album_peak);

-		else if (preferredPeakType != PEAKTYPE_NONE && !replaygain_track_peak.empty())

+		else if (preferredPeakType != PeakType::None && !replaygain_track_peak.empty())

 			peak = convertTo<double>(replaygain_track_peak);

 		return !fEqual(peak, 1.0) ? std::min(vol, 1.0 / peak) : vol;

 	}

@@ -354,12 +359,12 @@ double XSFFile::GetVolume(VolumeType preferredVolumeType, PeakType preferredPeak

 std::string XSFFile::FormattedTitleOptionalBlock(const std::string &block, bool &hadReplacement, unsigned level) const

 {

 	std::string formattedBlock;

-	for (size_t x = 0, len = block.length(); x < len; ++x)

+	for (std::size_t x = 0, len = block.length(); x < len; ++x)

 	{

 		char c = block[x];

 		if (c == '%')

 		{

-			size_t origX = x;

+			std::size_t origX = x;

 			for (++x; x < len; ++x)

 				if (block[x] == '%')

 					break;

@@ -377,7 +382,7 @@ std::string XSFFile::FormattedTitleOptionalBlock(const std::string &block, bool

 		}

 		if (c == '[' && level + 1 < 10)

 		{

-			size_t origX = x;

+			std::size_t origX = x;

 			unsigned nests = 0;

 			for (++x; x < len; ++x)

 			{

@@ -408,12 +413,12 @@ std::string XSFFile::FormattedTitleOptionalBlock(const std::string &block, bool

 std::string XSFFile::GetFormattedTitle(const std::string &format) const

 {

 	std::string formattedTitle;

-	for (size_t x = 0, len = format.length(); x < len; ++x)

+	for (std::size_t x = 0, len = format.length(); x < len; ++x)

 	{

 		char c = format[x];

 		if (c == '%')

 		{

-			size_t origX = x;

+			std::size_t origX = x;

 			for (++x; x < len; ++x)

 				if (format[x] == '%')

 					break;

@@ -429,7 +434,7 @@ std::string XSFFile::GetFormattedTitle(const std::string &format) const

 		}

 		else if (c == '[')

 		{

-			size_t origX = x;

+			std::size_t origX = x;

 			unsigned nests = 0;

 			for (++x; x < len; ++x)

 			{

@@ -6,8 +6,12 @@

  */

 #include <algorithm>

+#include <filesystem>

 #include <functional>

 #include <stdexcept>

+#if defined(_WIN32) && !defined(_MSC_VER)

+# include "fstream_wfopen.h"

+#endif

 #include "zlib.h"

 #include "XSFFile.h"

 #include "XSFCommon.h"

@@ -80,7 +84,7 @@ XSFFile::XSFFile(const std::wstring &filename, uint32_t programSizeOffset, uint3

 void XSFFile::ReadXSF(const std::string &filename, uint32_t programSizeOffset, uint32_t programHeaderSize, bool readTagsOnly)

 {

-	if (!FileExists(filename))

+	if (!std::filesystem::is_regular_file(filename))

 		throw std::logic_error("File " + filename + " does not exist.");

 	std::ifstream xSF;

@@ -95,7 +99,7 @@ void XSFFile::ReadXSF(const std::string &filename, uint32_t programSizeOffset, u

 #ifdef _WIN32

 void XSFFile::ReadXSF(const std::wstring &filename, uint32_t programSizeOffset, uint32_t programHeaderSize, bool readTagsOnly)

 {

-	if (!FileExists(filename))

+	if (!std::filesystem::is_regular_file(filename))

 		throw std::logic_error("File " + ConvertFuncs::WStringToString(filename) + " does not exist.");

 #if defined(_WIN32) && !defined(_MSC_VER)

@@ -460,7 +464,7 @@ std::string XSFFile::GetFilename() const

 std::string XSFFile::GetFilenameWithoutPath() const

 {

-	return ExtractFilenameFromPath(this->fileName);

+	return std::filesystem::path(this->fileName).filename().string();

 }

 void XSFFile::SaveFile() const

@@ -24,24 +24,26 @@ static inline void Set32BitsLE(uint32_t input, uint8_t *output)

 // The whitespace trimming was modified from the following answer on Stack Overflow:

 // http://stackoverflow.com/a/217605

-struct IsWhitespace

+bool IsWhitespace(const char &x)

 {

-  using argument_type = char;;

-	bool operator()(const char &x) const

-	{

-		return x >= 0x01 && x <= 0x20;

-	}

-};

+	return x >= 0x01 && x <= 0x20;

+}

 static inline std::string LeftTrimWhitespace(const std::string &orig)

 {

-	auto first_non_space = std::find_if(orig.begin(), orig.end(), std::not1(IsWhitespace()));

+	auto first_non_space = std::find_if(orig.begin(), orig.end(), [](const char &x)

+	{

+		return !IsWhitespace(x);

+	});

 	return std::string(first_non_space, orig.end());

 }

 static inline std::string RightTrimWhitespace(const std::string &orig)

 {

-	auto last_non_space = std::find_if(orig.rbegin(), orig.rend(), std::not1(IsWhitespace())).base();

+	auto last_non_space = std::find_if(orig.rbegin(), orig.rend(), [](const char &x)

+	{

+		return !IsWhitespace(x);

+	}).base();

 	return std::string(orig.begin(), last_non_space);

 }

@@ -128,7 +128,7 @@ void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t p

 	this->xSFType = PSFHeader[3];

 	this->rawData.resize(4);

-	memcpy(&this->rawData[0], PSFHeader, 4);

+	std::copy_n(PSFHeader, 4, &this->rawData[0]);

 	if (filesize < 16)

 		throw std::runtime_error("File is too small.");

@@ -150,7 +150,7 @@ void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t p

 		{

 			this->reservedSection.resize(reservedSize);

 			xSF.read(reinterpret_cast<char *>(&this->reservedSection[0]), reservedSize);

-			memcpy(&this->rawData[16], &this->reservedSection[0], reservedSize);

+			std::copy_n(&this->reservedSection[0], reservedSize, &this->rawData[16]);

 		}

 	}

@@ -165,7 +165,7 @@ void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t p

 		{

 			auto programSectionCompressed = std::vector<uint8_t>(programCompressedSize);

 			xSF.read(reinterpret_cast<char *>(&programSectionCompressed[0]), programCompressedSize);

-			memcpy(&this->rawData[reservedSize + 16], &programSectionCompressed[0], programCompressedSize);

+			std::copy_n(&programSectionCompressed[0], programCompressedSize, &this->rawData[reservedSize + 16]);

 			auto programSectionUncompressed = std::vector<uint8_t>(programHeaderSize);

 			unsigned long programUncompressedSize = programHeaderSize;

@@ -325,24 +325,24 @@ double XSFFile::GetVolume(VolumeType preferredVolumeType, PeakType preferredPeak

 	bool hadReplayGain = false;

 	if (preferredVolumeType == VOLUMETYPE_REPLAYGAIN_ALBUM && !replaygain_album_gain.empty())

 	{

-		gain = convertTo<double>(replaygain_album_gain, false);

+		gain = convertTo<double>(replaygain_album_gain);

 		hadReplayGain = true;

 	}

 	if (!hadReplayGain && preferredVolumeType != VOLUMETYPE_VOLUME && !replaygain_track_gain.empty())

 	{

-		gain = convertTo<double>(replaygain_track_gain, false);

+		gain = convertTo<double>(replaygain_track_gain);

 		hadReplayGain = true;

 	}

 	if (hadReplayGain)

 	{

 		double vol = std::pow(10.0, gain / 20.0), peak = 1.0;

 		if (preferredPeakType == PEAKTYPE_REPLAYGAIN_ALBUM && !replaygain_album_peak.empty())

-			peak = convertTo<double>(replaygain_album_peak, false);

+			peak = convertTo<double>(replaygain_album_peak);

 		else if (preferredPeakType != PEAKTYPE_NONE && !replaygain_track_peak.empty())

-			peak = convertTo<double>(replaygain_track_peak, false);

+			peak = convertTo<double>(replaygain_track_peak);

 		return !fEqual(peak, 1.0) ? std::min(vol, 1.0 / peak) : vol;

 	}

-	return volume.empty() ? 1.0 : convertTo<double>(volume, false);

+	return volume.empty() ? 1.0 : convertTo<double>(volume);

 }

 std::string XSFFile::FormattedTitleOptionalBlock(const std::string &block, bool &hadReplacement, unsigned level) const

@@ -1,7 +1,6 @@

 /*

  * xSF - File structure

  * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]

- * Last modification on 2014-09-24

  *

  * Partially based on the vio*sf framework

  */

@@ -9,7 +9,7 @@

 #include <algorithm>

 #include <functional>

 #include <stdexcept>

-#include <zlib.h>

+#include "zlib.h"

 #include "XSFFile.h"

 #include "XSFCommon.h"

 #include "convert.h"

@@ -25,8 +25,9 @@ static inline void Set32BitsLE(uint32_t input, uint8_t *output)

 // The whitespace trimming was modified from the following answer on Stack Overflow:

 // http://stackoverflow.com/a/217605

-struct IsWhitespace : std::unary_function<char, bool>

+struct IsWhitespace

 {

+  using argument_type = char;;

 	bool operator()(const char &x) const

 	{

 		return x >= 0x01 && x <= 0x20;

@@ -1,7 +1,7 @@

 /*

  * xSF - File structure

  * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]

- * Last modification on 2014-09-17

+ * Last modification on 2014-09-24

  *

  * Partially based on the vio*sf framework

  */

@@ -64,13 +64,13 @@ XSFFile::XSFFile(const std::string &filename, uint32_t programSizeOffset, uint32

 	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

 }

-#ifdef _MSC_VER

-XSFFile::XSFFile(const std::wstring &filename) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

+#ifdef _WIN32

+XSFFile::XSFFile(const std::wstring &filename) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

 {

 	this->ReadXSF(filename, 0, 0, true);

 }

-XSFFile::XSFFile(const std::wstring &filename, uint32_t programSizeOffset, uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

+XSFFile::XSFFile(const std::wstring &filename, uint32_t programSizeOffset, uint32_t programHeaderSize) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(ConvertFuncs::WStringToString(filename))

 {

 	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

 }

@@ -86,19 +86,27 @@ void XSFFile::ReadXSF(const std::string &filename, uint32_t programSizeOffset, u

 	xSF.open(filename.c_str(), std::ifstream::in | std::ifstream::binary);

 	this->ReadXSF(xSF, programSizeOffset, programHeaderSize, readTagsOnly);

+

+	xSF.close();

 }

-#ifdef _MSC_VER

+#ifdef _WIN32

 void XSFFile::ReadXSF(const std::wstring &filename, uint32_t programSizeOffset, uint32_t programHeaderSize, bool readTagsOnly)

 {

 	if (!FileExists(filename))

-		throw std::logic_error("File " + String(filename).GetAnsi() + " does not exist.");

+		throw std::logic_error("File " + ConvertFuncs::WStringToString(filename) + " does not exist.");

+#if defined(_WIN32) && !defined(_MSC_VER)

+	ifstream_wfopen xSF;

+#else

 	std::ifstream xSF;

+#endif

 	xSF.exceptions(std::ifstream::failbit | std::ifstream::badbit);

 	xSF.open(filename.c_str(), std::ifstream::in | std::ifstream::binary);

 	this->ReadXSF(xSF, programSizeOffset, programHeaderSize, readTagsOnly);

+

+	xSF.close();

 }

 #endif

@@ -214,8 +222,6 @@ void XSFFile::ReadXSF(std::ifstream &xSF, uint32_t programSizeOffset, uint32_t p

 		}

 	}

-	xSF.close();

-

 	this->hasFile = true;

 }

@@ -268,9 +274,14 @@ void XSFFile::SetAllTags(const TagList &newTags)

 	this->tags = newTags;

 }

-void XSFFile::SetTag(const std::string &name, const String &value)

+void XSFFile::SetTag(const std::string &name, const std::string &value)

+{

+	this->tags[name] = value;

+}

+

+void XSFFile::SetTag(const std::string &name, const std::wstring &value)

 {

-	this->tags[name] = value.GetStr();

+	this->tags[name] = ConvertFuncs::WStringToString(value);

 }

 bool XSFFile::GetTagExists(const std::string &name) const

@@ -278,17 +289,17 @@ bool XSFFile::GetTagExists(const std::string &name) const

 	return this->tags.Exists(name);

 }

-String XSFFile::GetTagValue(const std::string &name) const

+std::string XSFFile::GetTagValue(const std::string &name) const

 {

-	return String(this->GetTagExists(name) ? this->tags[name] : "", this->GetTagExists("utf8"));

+	return this->GetTagExists(name) ? this->tags[name] : "";

 }

 unsigned long XSFFile::GetLengthMS(unsigned long defaultLength) const

 {

 	unsigned long length = 0;

-	String value = this->GetTagValue("length");

+	std::string value = this->GetTagValue("length");

 	if (!value.empty())

-		length = ConvertFuncs::StringToMS(value.GetAnsi());

+		length = ConvertFuncs::StringToMS(value);

 	if (!length)

 		length = defaultLength;

 	return length;

@@ -297,9 +308,9 @@ unsigned long XSFFile::GetLengthMS(unsigned long defaultLength) const

 unsigned long XSFFile::GetFadeMS(unsigned long defaultFade) const

 {

 	unsigned long fade = defaultFade;

-	String value = this->GetTagValue("fade");

+	std::string value = this->GetTagValue("fade");

 	if (!value.empty())

-		fade = ConvertFuncs::StringToMS(value.GetAnsi());

+		fade = ConvertFuncs::StringToMS(value);

 	return fade;

 }

@@ -307,49 +318,49 @@ double XSFFile::GetVolume(VolumeType preferredVolumeType, PeakType preferredPeak

 {

 	if (preferredVolumeType == VOLUMETYPE_NONE)

 		return 1.0;

-	String replaygain_album_gain = this->GetTagValue("replaygain_album_gain"), replaygain_album_peak = this->GetTagValue("replaygain_album_peak");

-	String replaygain_track_gain = this->GetTagValue("replaygain_track_gain"), replaygain_track_peak = this->GetTagValue("replaygain_track_peak");

-	String volume = this->GetTagValue("volume");

+	std::string replaygain_album_gain = this->GetTagValue("replaygain_album_gain"), replaygain_album_peak = this->GetTagValue("replaygain_album_peak");

+	std::string replaygain_track_gain = this->GetTagValue("replaygain_track_gain"), replaygain_track_peak = this->GetTagValue("replaygain_track_peak");

+	std::string volume = this->GetTagValue("volume");

 	double gain = 0.0;

 	bool hadReplayGain = false;

 	if (preferredVolumeType == VOLUMETYPE_REPLAYGAIN_ALBUM && !replaygain_album_gain.empty())

 	{

-		gain = convertTo<double>(replaygain_album_gain.GetAnsi(), false);

+		gain = convertTo<double>(replaygain_album_gain, false);

 		hadReplayGain = true;

 	}

 	if (!hadReplayGain && preferredVolumeType != VOLUMETYPE_VOLUME && !replaygain_track_gain.empty())

 	{

-		gain = convertTo<double>(replaygain_track_gain.GetAnsi(), false);

+		gain = convertTo<double>(replaygain_track_gain, false);

 		hadReplayGain = true;

 	}

 	if (hadReplayGain)

 	{

 		double vol = std::pow(10.0, gain / 20.0), peak = 1.0;

 		if (preferredPeakType == PEAKTYPE_REPLAYGAIN_ALBUM && !replaygain_album_peak.empty())

-			peak = convertTo<double>(replaygain_album_peak.GetAnsi(), false);

+			peak = convertTo<double>(replaygain_album_peak, false);

 		else if (preferredPeakType != PEAKTYPE_NONE && !replaygain_track_peak.empty())

-			peak = convertTo<double>(replaygain_track_peak.GetAnsi(), false);

+			peak = convertTo<double>(replaygain_track_peak, false);

 		return !fEqual(peak, 1.0) ? std::min(vol, 1.0 / peak) : vol;

 	}

-	return volume.empty() ? 1.0 : convertTo<double>(volume.GetAnsi(), false);

+	return volume.empty() ? 1.0 : convertTo<double>(volume, false);

 }

-String XSFFile::FormattedTitleOptionalBlock(const std::wstring &block, bool &hadReplacement, unsigned level) const

+std::string XSFFile::FormattedTitleOptionalBlock(const std::string &block, bool &hadReplacement, unsigned level) const

 {

-	String formattedBlock;

+	std::string formattedBlock;

 	for (size_t x = 0, len = block.length(); x < len; ++x)

 	{

-		wchar_t c = block[x];

-		if (c == L'%')

+		char c = block[x];

+		if (c == '%')

 		{

 			size_t origX = x;

 			for (++x; x < len; ++x)

-				if (block[x] == L'%')

+				if (block[x] == '%')

 					break;

 			if (x != len)

 			{

-				std::wstring tagname = block.substr(origX + 1, x - origX - 1);

-				String value = this->GetTagValue(String(tagname).GetAnsi());

+				std::string tagname = block.substr(origX + 1, x - origX - 1);

+				std::string value = this->GetTagValue(tagname);

 				if (!value.empty())

 				{

 					formattedBlock += value;

@@ -358,15 +369,15 @@ String XSFFile::FormattedTitleOptionalBlock(const std::wstring &block, bool &had

 			}

 			continue;

 		}

-		if (c == L'[' && level + 1 < 10)

+		if (c == '[' && level + 1 < 10)

 		{

 			size_t origX = x;

 			unsigned nests = 0;

 			for (++x; x < len; ++x)

 			{

-				if (block[x] == L'[')

+				if (block[x] == '[')

 					++nests;

-				else if (block[x] == L']')

+				else if (block[x] == ']')

 				{

 					if (!nests)

 						break;

@@ -375,9 +386,9 @@ String XSFFile::FormattedTitleOptionalBlock(const std::wstring &block, bool &had

 			}

 			if (x != len)

 			{

-				std::wstring innerBlock = block.substr(origX + 1, x - origX - 1);

+				std::string innerBlock = block.substr(origX + 1, x - origX - 1);

 				bool hadInnerReplacement = false;

-				String replacedBlock = this->FormattedTitleOptionalBlock(innerBlock, hadInnerReplacement, level + 1);

+				std::string replacedBlock = this->FormattedTitleOptionalBlock(innerBlock, hadInnerReplacement, level + 1);

 				if (hadInnerReplacement)

 					formattedBlock += replacedBlock;

 			}

@@ -388,37 +399,37 @@ String XSFFile::FormattedTitleOptionalBlock(const std::wstring &block, bool &had

 	return formattedBlock;

 }

-String XSFFile::GetFormattedTitle(const std::wstring &format) const

+std::string XSFFile::GetFormattedTitle(const std::string &format) const

 {

-	String formattedTitle;

+	std::string formattedTitle;

 	for (size_t x = 0, len = format.length(); x < len; ++x)

 	{

-		wchar_t c = format[x];

-		if (c == L'%')

+		char c = format[x];

+		if (c == '%')

 		{

 			size_t origX = x;

 			for (++x; x < len; ++x)

-				if (format[x] == L'%')

+				if (format[x] == '%')

 					break;

 			if (x != len)

 			{

-				std::wstring tagname = format.substr(origX + 1, x - origX - 1);

-				String value = this->GetTagValue(String(tagname).GetAnsi());

+				std::string tagname = format.substr(origX + 1, x - origX - 1);

+				std::string value = this->GetTagValue(tagname);

 				if (value.empty())

 					formattedTitle += "???";

 				else

 					formattedTitle += value;

 			}

 		}

-		else if (c == L'[')

+		else if (c == '[')

 		{

 			size_t origX = x;

 			unsigned nests = 0;

 			for (++x; x < len; ++x)

 			{

-				if (format[x] == L'[')

+				if (format[x] == '[')

 					++nests;

-				else if (format[x] == L']')

+				else if (format[x] == ']')

 				{

 					if (!nests)

 						break;

@@ -427,9 +438,9 @@ String XSFFile::GetFormattedTitle(const std::wstring &format) const

 			}

 			if (x != len)

 			{

-				std::wstring block = format.substr(origX + 1, x - origX - 1);

+				std::string block = format.substr(origX + 1, x - origX - 1);

 				bool hadReplacement = false;

-				String replacedBlock = this->FormattedTitleOptionalBlock(block, hadReplacement, 1);

+				std::string replacedBlock = this->FormattedTitleOptionalBlock(block, hadReplacement, 1);

 				if (hadReplacement)

 					formattedTitle += replacedBlock;

 			}

@@ -440,24 +451,28 @@ String XSFFile::GetFormattedTitle(const std::wstring &format) const

 	return formattedTitle;

 }

-String XSFFile::GetFilename() const

+std::string XSFFile::GetFilename() const

 {

 	return this->fileName;

 }

-String XSFFile::GetFilenameWithoutPath() const

+std::string XSFFile::GetFilenameWithoutPath() const

 {

-	return ExtractFilenameFromPath(this->fileName.GetStr());

+	return ExtractFilenameFromPath(this->fileName);

 }

 void XSFFile::SaveFile() const

 {

+#if defined(_WIN32) && !defined(_MSC_VER)

+	ofstream_wfopen xSF;

+#else

 	std::ofstream xSF;

+#endif

 	xSF.exceptions(std::ofstream::failbit);

-#ifdef _MSC_VER

-	xSF.open(this->fileName.GetWStrC(), std::ofstream::out | std::ofstream::binary);

+#ifdef _WIN32

+	xSF.open(ConvertFuncs::StringToWString(this->fileName).c_str(), std::ofstream::out | std::ofstream::binary);

 #else

-	xSF.open(this->fileName.GetStrC(), std::ofstream::out | std::ofstream::binary);

+	xSF.open(this->fileName.c_str(), std::ofstream::out | std::ofstream::binary);

 #endif

 	xSF.write(reinterpret_cast<const char *>(&this->rawData[0]), this->rawData.size());

@@ -1,7 +1,7 @@

 /*

  * xSF - File structure

  * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]

- * Last modification on 2013-03-30

+ * Last modification on 2014-09-17

  *

  * Partially based on the vio*sf framework

  */

@@ -64,7 +64,7 @@ XSFFile::XSFFile(const std::string &filename, uint32_t programSizeOffset, uint32

 	this->ReadXSF(filename, programSizeOffset, programHeaderSize);

 }

-#ifdef _WIN32

+#ifdef _MSC_VER

 XSFFile::XSFFile(const std::wstring &filename) : xSFType(0), hasFile(false), rawData(), reservedSection(), programSection(), tags(), fileName(filename)

 {

 	this->ReadXSF(filename, 0, 0, true);

@@ -88,7 +88,7 @@ void XSFFile::ReadXSF(const std::string &filename, uint32_t programSizeOffset, u

 	this->ReadXSF(xSF, programSizeOffset, programHeaderSize, readTagsOnly);

 }

-#ifdef _WIN32

+#ifdef _MSC_VER

 void XSFFile::ReadXSF(const std::wstring &filename, uint32_t programSizeOffset, uint32_t programHeaderSize, bool readTagsOnly)

 {

 	if (!FileExists(filename))

@@ -454,7 +454,7 @@ void XSFFile::SaveFile() const

 {

 	std::ofstream xSF;

 	xSF.exceptions(std::ofstream::failbit);

-#ifdef _WIN32

+#ifdef _MSC_VER

 	xSF.open(this->fileName.GetWStrC(), std::ofstream::out | std::ofstream::binary);

 #else

 	xSF.open(this->fileName.GetStrC(), std::ofstream::out | std::ofstream::binary);

@@ -1,7 +1,7 @@

 /*

  * xSF - File structure

  * By Naram Qashat (CyberBotX) [cyberbotx@cyberbotx.com]

- * Last modification on 2013-03-25

+ * Last modification on 2013-03-30

  *

  * Partially based on the vio*sf framework

  */

@@ -466,10 +466,10 @@ void XSFFile::SaveFile() const

 	if (!allTags.empty())

 	{

 		xSF.write("[TAG]", 5);

-		for (auto curr = allTags.begin(), end = allTags.end(); curr != end; ++curr)

+		std::for_each(allTags.begin(), allTags.end(), [&](const std::string &tag)

 		{

-			xSF.write(curr->c_str(), curr->length());

+			xSF.write(tag.c_str(), tag.length());

 			xSF.write("\n", 1);

-		}

+		});

 	}

 }

@@ -447,7 +447,7 @@ String XSFFile::GetFilename() const

 String XSFFile::GetFilenameWithoutPath() const

 {

-	return ExtractDirectoryFromPath(this->fileName.GetStr());

+	return ExtractFilenameFromPath(this->fileName.GetStr());