Archive/Play-
0
0
Fork 0
mirror of https://github.com/jpd002/Play-.git synced 2025-04-28 13:47:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove usage of boost::filesystem.

Browse source
This commit is contained in:
Jean-Philip Desjardins 2019-10-16 20:51:11 -04:00
parent 6eca7d23fd
commit 7131a28fd4
48 changed files with 243 additions and 263 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Source/DiskUtils.cpp
View file

@ -23,7 +23,7 @@
#include "TargetConditionals.h" #include "TargetConditionals.h"
#endif #endif
static Framework::CStream* CreateImageStream(const boost::filesystem::path& imagePath) static Framework::CStream* CreateImageStream(const fs::path& imagePath)
{ {
auto imagePathString = imagePath.string(); auto imagePathString = imagePath.string();
if(imagePathString.find("s3://") == 0) if(imagePathString.find("s3://") == 0)
@ -48,7 +48,7 @@ static Framework::CStream* CreateImageStream(const boost::filesystem::path& imag
#endif #endif
} }
DiskUtils::OpticalMediaPtr DiskUtils::CreateOpticalMediaFromPath(const boost::filesystem::path& imagePath) DiskUtils::OpticalMediaPtr DiskUtils::CreateOpticalMediaFromPath(const fs::path& imagePath)
{ {
assert(!imagePath.empty()); assert(!imagePath.empty());
@ -138,7 +138,7 @@ static std::string GetDiskIdFromPath(const std::string& filePath)
return regionCode + "-" + serial1 + serial2; return regionCode + "-" + serial1 + serial2;
} }
bool DiskUtils::TryGetDiskId(const boost::filesystem::path& imagePath, std::string* diskIdPtr) bool DiskUtils::TryGetDiskId(const fs::path& imagePath, std::string* diskIdPtr)
{ {
try try
{ {

6
Source/DiskUtils.h
View file

@ -2,7 +2,7 @@
#include <string> #include <string>
#include <memory> #include <memory>
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include "OpticalMedia.h" #include "OpticalMedia.h"
namespace DiskUtils namespace DiskUtils
@ -10,8 +10,8 @@ namespace DiskUtils
typedef std::unique_ptr<COpticalMedia> OpticalMediaPtr; typedef std::unique_ptr<COpticalMedia> OpticalMediaPtr;
typedef std::map<std::string, std::string> SystemConfigMap; typedef std::map<std::string, std::string> SystemConfigMap;
OpticalMediaPtr CreateOpticalMediaFromPath(const boost::filesystem::path&); OpticalMediaPtr CreateOpticalMediaFromPath(const fs::path&);
SystemConfigMap ParseSystemConfigFile(Framework::CStream*); SystemConfigMap ParseSystemConfigFile(Framework::CStream*);
bool TryGetDiskId(const boost::filesystem::path&, std::string*); bool TryGetDiskId(const fs::path&, std::string*);
} }

4
Source/Log.h
View file

@ -2,7 +2,7 @@
#include <string> #include <string>
#include <map> #include <map>
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include "StdStream.h" #include "StdStream.h"
#include "Singleton.h" #include "Singleton.h"
@ -20,7 +20,7 @@ private:
Framework::CStdStream& GetLog(const char*); Framework::CStdStream& GetLog(const char*);
boost::filesystem::path m_logBasePath; fs::path m_logBasePath;
LogMapType m_logs; LogMapType m_logs;
bool m_showPrints = false; bool m_showPrints = false;
}; };

22
Source/PS2VM.cpp
View file

@ -39,8 +39,6 @@
#define ONSCREEN_TICKS (FRAME_TICKS * 9 / 10) #define ONSCREEN_TICKS (FRAME_TICKS * 9 / 10)
#define VBLANK_TICKS (FRAME_TICKS / 10) #define VBLANK_TICKS (FRAME_TICKS / 10)
namespace filesystem = boost::filesystem;
CPS2VM::CPS2VM() CPS2VM::CPS2VM()
: m_nStatus(PAUSED) : m_nStatus(PAUSED)
, m_nEnd(false) , m_nEnd(false)
@ -77,7 +75,7 @@ CPS2VM::CPS2VM()
CAppConfig::GetInstance().RegisterPreferencePath(setting, absolutePath); CAppConfig::GetInstance().RegisterPreferencePath(setting, absolutePath);
auto currentPath = CAppConfig::GetInstance().GetPreferencePath(setting); auto currentPath = CAppConfig::GetInstance().GetPreferencePath(setting);
if(!boost::filesystem::exists(currentPath)) if(!fs::exists(currentPath))
{ {
CAppConfig::GetInstance().SetPreferencePath(setting, absolutePath); CAppConfig::GetInstance().SetPreferencePath(setting, absolutePath);
} }
@ -240,18 +238,18 @@ void CPS2VM::Destroy()
DestroyVM(); DestroyVM();
} }
boost::filesystem::path CPS2VM::GetStateDirectoryPath() fs::path CPS2VM::GetStateDirectoryPath()
{ {
return CAppConfig::GetBasePath() / boost::filesystem::path("states/"); return CAppConfig::GetBasePath() / fs::path("states/");
} }
boost::filesystem::path CPS2VM::GenerateStatePath(unsigned int slot) const fs::path CPS2VM::GenerateStatePath(unsigned int slot) const
{ {
auto stateFileName = string_format("%s.st%d.zip", m_ee->m_os->GetExecutableName(), slot); auto stateFileName = string_format("%s.st%d.zip", m_ee->m_os->GetExecutableName(), slot);
return GetStateDirectoryPath() / boost::filesystem::path(stateFileName); return GetStateDirectoryPath() / fs::path(stateFileName);
} }
std::future<bool> CPS2VM::SaveState(const filesystem::path& statePath) std::future<bool> CPS2VM::SaveState(const fs::path& statePath)
{ {
auto promise = std::make_shared<std::promise<bool>>(); auto promise = std::make_shared<std::promise<bool>>();
auto future = promise->get_future(); auto future = promise->get_future();
@ -263,7 +261,7 @@ std::future<bool> CPS2VM::SaveState(const filesystem::path& statePath)
return future; return future;
} }
std::future<bool> CPS2VM::LoadState(const filesystem::path& statePath) std::future<bool> CPS2VM::LoadState(const fs::path& statePath)
{ {
auto promise = std::make_shared<std::promise<bool>>(); auto promise = std::make_shared<std::promise<bool>>();
auto future = promise->get_future(); auto future = promise->get_future();
@ -306,7 +304,7 @@ CPS2VM::CPU_UTILISATION_INFO CPS2VM::GetCpuUtilisationInfo() const
std::string CPS2VM::MakeDebugTagsPackagePath(const char* packageName) std::string CPS2VM::MakeDebugTagsPackagePath(const char* packageName)
{ {
auto tagsPath = CAppConfig::GetBasePath() / boost::filesystem::path(TAGS_PATH); auto tagsPath = CAppConfig::GetBasePath() / fs::path(TAGS_PATH);
Framework::PathUtils::EnsurePathExists(tagsPath); Framework::PathUtils::EnsurePathExists(tagsPath);
auto tagsPackagePath = tagsPath / (std::string(packageName) + std::string(".tags.xml")); auto tagsPackagePath = tagsPath / (std::string(packageName) + std::string(".tags.xml"));
return tagsPackagePath.string(); return tagsPackagePath.string();
@ -422,7 +420,7 @@ void CPS2VM::DestroyVM()
CDROM0_Reset(); CDROM0_Reset();
} }
bool CPS2VM::SaveVMState(const filesystem::path& statePath) bool CPS2VM::SaveVMState(const fs::path& statePath)
{ {
if(m_ee->m_gs == NULL) if(m_ee->m_gs == NULL)
{ {
@ -449,7 +447,7 @@ bool CPS2VM::SaveVMState(const filesystem::path& statePath)
return true; return true;
} }
bool CPS2VM::LoadVMState(const filesystem::path& statePath) bool CPS2VM::LoadVMState(const fs::path& statePath)
{ {
if(m_ee->m_gs == NULL) if(m_ee->m_gs == NULL)
{ {

14
Source/PS2VM.h
View file

@ -2,7 +2,7 @@
#include <thread> #include <thread>
#include <future> #include <future>
#include "boost_filesystem_def.h" #include "filesystem_def.h"
#include "AppDef.h" #include "AppDef.h"
#include "Types.h" #include "Types.h"
#include "MIPS.h" #include "MIPS.h"
@ -65,11 +65,11 @@ public:
void DestroySoundHandler(); void DestroySoundHandler();
void ReloadSpuBlockCount(); void ReloadSpuBlockCount();
static boost::filesystem::path GetStateDirectoryPath(); static fs::path GetStateDirectoryPath();
boost::filesystem::path GenerateStatePath(unsigned int) const; fs::path GenerateStatePath(unsigned int) const;
std::future<bool> SaveState(const boost::filesystem::path&); std::future<bool> SaveState(const fs::path&);
std::future<bool> LoadState(const boost::filesystem::path&); std::future<bool> LoadState(const fs::path&);
void TriggerFrameDump(const FrameDumpCallback&); void TriggerFrameDump(const FrameDumpCallback&);
@ -94,8 +94,8 @@ private:
void CreateVM(); void CreateVM();
void ResetVM(); void ResetVM();
void DestroyVM(); void DestroyVM();
bool SaveVMState(const boost::filesystem::path&); bool SaveVMState(const fs::path&);
bool LoadVMState(const boost::filesystem::path&); bool LoadVMState(const fs::path&);
void ReloadExecutable(const char*, const CPS2OS::ArgumentList&); void ReloadExecutable(const char*, const CPS2OS::ArgumentList&);

8
Source/ScreenShotUtils.cpp
View file

@ -31,14 +31,14 @@ CScreenShotUtils::Connection CScreenShotUtils::TriggerGetScreenshot(CPS2VM* virt
}); });
} }
boost::filesystem::path CScreenShotUtils::GetScreenShotDirectoryPath() fs::path CScreenShotUtils::GetScreenShotDirectoryPath()
{ {
auto screenshotpath(CAppConfig::GetBasePath() / boost::filesystem::path("screenshots")); auto screenshotpath(CAppConfig::GetBasePath() / fs::path("screenshots"));
Framework::PathUtils::EnsurePathExists(screenshotpath); Framework::PathUtils::EnsurePathExists(screenshotpath);
return screenshotpath; return screenshotpath;
} }
boost::filesystem::path CScreenShotUtils::GenerateScreenShotPath(const char* gameID) fs::path CScreenShotUtils::GenerateScreenShotPath(const char* gameID)
{ {
auto t = std::time(nullptr); auto t = std::time(nullptr);
auto tm = *std::localtime(&t); auto tm = *std::localtime(&t);
@ -48,5 +48,5 @@ boost::filesystem::path CScreenShotUtils::GenerateScreenShotPath(const char* gam
oss << gameID << std::put_time(&tm, "_%d-%m-%Y_%H.%M.%S.") << ms << ".bmp"; oss << gameID << std::put_time(&tm, "_%d-%m-%Y_%H.%M.%S.") << ms << ".bmp";
auto screenshotFileName = oss.str(); auto screenshotFileName = oss.str();
return GetScreenShotDirectoryPath() / boost::filesystem::path(screenshotFileName); return GetScreenShotDirectoryPath() / fs::path(screenshotFileName);
} }

4
Source/ScreenShotUtils.h
View file

@ -12,6 +12,6 @@ public:
static Connection TriggerGetScreenshot(CPS2VM*, Callback); static Connection TriggerGetScreenshot(CPS2VM*, Callback);
private: private:
static boost::filesystem::path GetScreenShotDirectoryPath(); static fs::path GetScreenShotDirectoryPath();
static boost::filesystem::path GenerateScreenShotPath(const char* gameID); static fs::path GenerateScreenShotPath(const char* gameID);
}; };

2
Source/ee/PS2OS.cpp
View file

@ -327,7 +327,7 @@ void CPS2OS::DumpDmacHandlers()
} }
} }
void CPS2OS::BootFromFile(const boost::filesystem::path& execPath) void CPS2OS::BootFromFile(const fs::path& execPath)
{ {
auto stream = Framework::CreateInputStdStream(execPath.native()); auto stream = Framework::CreateInputStdStream(execPath.native());
auto virtualExecutablePath = "host:" + execPath.filename().string(); auto virtualExecutablePath = "host:" + execPath.filename().string();

4
Source/ee/PS2OS.h
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <string> #include <string>
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include "signal/Signal.h" #include "signal/Signal.h"
#include "../ELF.h" #include "../ELF.h"
#include "../MIPS.h" #include "../MIPS.h"
@ -34,7 +34,7 @@ public:
void DumpIntcHandlers(); void DumpIntcHandlers();
void DumpDmacHandlers(); void DumpDmacHandlers();
void BootFromFile(const boost::filesystem::path&); void BootFromFile(const fs::path&);
void BootFromVirtualPath(const char*, const ArgumentList&); void BootFromVirtualPath(const char*, const ArgumentList&);
void BootFromCDROM(); void BootFromCDROM();
CELF* GetELF(); CELF* GetELF();

4
Source/iop/DirectoryDevice.cpp
View file

@ -68,9 +68,9 @@ Directory CDirectoryDevice::GetDirectory(const char* devicePath)
{ {
auto basePath = CAppConfig::GetInstance().GetPreferencePath(m_basePathPreferenceName.c_str()); auto basePath = CAppConfig::GetInstance().GetPreferencePath(m_basePathPreferenceName.c_str());
auto path = basePath / devicePath; auto path = basePath / devicePath;
if(!boost::filesystem::is_directory(path)) if(!fs::is_directory(path))
{ {
throw std::runtime_error("Not a directory."); throw std::runtime_error("Not a directory.");
} }
return boost::filesystem::directory_iterator(path); return fs::directory_iterator(path);
} }

4
Source/iop/Ioman_Device.h
View file

@ -1,13 +1,13 @@
#pragma once #pragma once
#include "Stream.h" #include "Stream.h"
#include <boost/filesystem.hpp> #include "filesystem_def.h"
namespace Iop namespace Iop
{ {
namespace Ioman namespace Ioman
{ {
typedef boost::filesystem::directory_iterator Directory; typedef fs::directory_iterator Directory;
class CDevice class CDevice
{ {

6
Source/iop/Iop_Ioman.cpp
View file

@ -375,13 +375,13 @@ int32 CIoman::Dread(uint32 handle, Ioman::DIRENTRY* dirEntry)
} }
auto itemPath = directory->path(); auto itemPath = directory->path();
auto name = itemPath.leaf().string(); auto name = itemPath.filename().string();
strncpy(dirEntry->name, name.c_str(), Ioman::DIRENTRY::NAME_SIZE); strncpy(dirEntry->name, name.c_str(), Ioman::DIRENTRY::NAME_SIZE);
dirEntry->name[Ioman::DIRENTRY::NAME_SIZE - 1] = 0; dirEntry->name[Ioman::DIRENTRY::NAME_SIZE - 1] = 0;
auto& stat = dirEntry->stat; auto& stat = dirEntry->stat;
memset(&stat, 0, sizeof(Ioman::STAT)); memset(&stat, 0, sizeof(Ioman::STAT));
if(boost::filesystem::is_directory(itemPath)) if(fs::is_directory(itemPath))
{ {
stat.mode = STAT_MODE_DIR; stat.mode = STAT_MODE_DIR;
stat.attr = 0x8427; stat.attr = 0x8427;
@ -389,7 +389,7 @@ int32 CIoman::Dread(uint32 handle, Ioman::DIRENTRY* dirEntry)
else else
{ {
stat.mode = STAT_MODE_FILE; stat.mode = STAT_MODE_FILE;
stat.loSize = boost::filesystem::file_size(itemPath); stat.loSize = fs::file_size(itemPath);
stat.attr = 0x8497; stat.attr = 0x8497;
} }

61
Source/iop/Iop_McServ.cpp
View file

@ -14,7 +14,6 @@
#include "MIPSAssembler.h" #include "MIPSAssembler.h"
using namespace Iop; using namespace Iop;
namespace filesystem = boost::filesystem;
#define CLUSTER_SIZE 0x400 #define CLUSTER_SIZE 0x400
@ -269,7 +268,7 @@ void CMcServ::Open(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize, u
return; return;
} }
filesystem::path filePath; fs::path filePath;
try try
{ {
@ -288,7 +287,7 @@ void CMcServ::Open(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize, u
uint32 result = -1; uint32 result = -1;
try try
{ {
filesystem::create_directory(filePath); fs::create_directory(filePath);
result = 0; result = 0;
} }
catch(...) catch(...)
@ -301,7 +300,7 @@ void CMcServ::Open(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize, u
{ {
if(cmd->flags & OPEN_FLAG_CREAT) if(cmd->flags & OPEN_FLAG_CREAT)
{ {
if(!boost::filesystem::exists(filePath)) if(!fs::exists(filePath))
{ {
//Create file if it doesn't exist //Create file if it doesn't exist
Framework::CreateOutputStdStream(filePath.native()); Framework::CreateOutputStdStream(filePath.native());
@ -310,7 +309,7 @@ void CMcServ::Open(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize, u
if(cmd->flags & OPEN_FLAG_TRUNC) if(cmd->flags & OPEN_FLAG_TRUNC)
{ {
if(boost::filesystem::exists(filePath)) if(fs::exists(filePath))
{ {
//Create file (discard contents) if it exists //Create file (discard contents) if it exists
Framework::CreateOutputStdStream(filePath.native()); Framework::CreateOutputStdStream(filePath.native());
@ -482,8 +481,8 @@ void CMcServ::ChDir(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize,
try try
{ {
filesystem::path newCurrentDirectory; fs::path newCurrentDirectory;
filesystem::path requestedDirectory(cmd->name); fs::path requestedDirectory(cmd->name);
if(!requestedDirectory.root_directory().empty()) if(!requestedDirectory.root_directory().empty())
{ {
@ -504,7 +503,7 @@ void CMcServ::ChDir(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize,
auto mcPath = CAppConfig::GetInstance().GetPreferencePath(m_mcPathPreference[cmd->port]); auto mcPath = CAppConfig::GetInstance().GetPreferencePath(m_mcPathPreference[cmd->port]);
mcPath /= newCurrentDirectory; mcPath /= newCurrentDirectory;
if(filesystem::exists(mcPath) && filesystem::is_directory(mcPath)) if(fs::exists(mcPath) && fs::is_directory(mcPath))
{ {
m_currentDirectory = newCurrentDirectory; m_currentDirectory = newCurrentDirectory;
result = 0; result = 0;
@ -552,18 +551,18 @@ void CMcServ::GetDir(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize,
{ {
mcPath /= m_currentDirectory; mcPath /= m_currentDirectory;
} }
mcPath = filesystem::absolute(mcPath); mcPath = fs::absolute(mcPath);
if(!filesystem::exists(mcPath)) if(!fs::exists(mcPath))
{ {
//Directory doesn't exist //Directory doesn't exist
ret[0] = RET_NO_ENTRY; ret[0] = RET_NO_ENTRY;
return; return;
} }
filesystem::path searchPath = mcPath / cmd->name; fs::path searchPath = mcPath / cmd->name;
searchPath.remove_filename(); searchPath.remove_filename();
if(!filesystem::exists(searchPath)) if(!fs::exists(searchPath))
{ {
//Specified directory doesn't exist, this is an error //Specified directory doesn't exist, this is an error
ret[0] = RET_NO_ENTRY; ret[0] = RET_NO_ENTRY;
@ -593,9 +592,9 @@ void CMcServ::Delete(uint32* args, uint32 argsSize, uint32* ret, uint32 retSize,
try try
{ {
auto filePath = GetAbsoluteFilePath(cmd->port, cmd->slot, cmd->name); auto filePath = GetAbsoluteFilePath(cmd->port, cmd->slot, cmd->name);
if(boost::filesystem::exists(filePath)) if(fs::exists(filePath))
{ {
boost::filesystem::remove(filePath); fs::remove(filePath);
ret[0] = 0; ret[0] = 0;
} }
else else
@ -622,7 +621,7 @@ void CMcServ::GetEntSpace(uint32* args, uint32 argsSize, uint32* ret, uint32 ret
auto mcPath = CAppConfig::GetInstance().GetPreferencePath(m_mcPathPreference[cmd->port]); auto mcPath = CAppConfig::GetInstance().GetPreferencePath(m_mcPathPreference[cmd->port]);
auto savePath = mcPath / cmd->name; auto savePath = mcPath / cmd->name;
if(filesystem::exists(savePath) && filesystem::is_directory(savePath)) if(fs::exists(savePath) && fs::is_directory(savePath))
{ {
// Arbitrarity number, allows Drakengard to detect MC // Arbitrarity number, allows Drakengard to detect MC
ret[0] = 0xFE; ret[0] = 0xFE;
@ -756,10 +755,10 @@ Framework::CStdStream* CMcServ::GetFileFromHandle(uint32 handle)
return &file; return &file;
} }
boost::filesystem::path CMcServ::GetAbsoluteFilePath(unsigned int port, unsigned int slot, const char* name) const fs::path CMcServ::GetAbsoluteFilePath(unsigned int port, unsigned int slot, const char* name) const
{ {
auto mcPath = CAppConfig::GetInstance().GetPreferencePath(m_mcPathPreference[port]); auto mcPath = CAppConfig::GetInstance().GetPreferencePath(m_mcPathPreference[port]);
auto requestedFilePath = boost::filesystem::path(name); auto requestedFilePath = fs::path(name);
if(!requestedFilePath.root_directory().empty()) if(!requestedFilePath.root_directory().empty())
{ {
@ -790,7 +789,7 @@ void CMcServ::CPathFinder::Reset()
m_index = 0; m_index = 0;
} }
void CMcServ::CPathFinder::Search(const boost::filesystem::path& basePath, const char* filter) void CMcServ::CPathFinder::Search(const fs::path& basePath, const char* filter)
{ {
m_basePath = basePath; m_basePath = basePath;
@ -809,7 +808,7 @@ void CMcServ::CPathFinder::Search(const boost::filesystem::path& basePath, const
m_filterExp = std::regex(filterExpString); m_filterExp = std::regex(filterExpString);
} }
auto filterPath = boost::filesystem::path(filterPathString); auto filterPath = fs::path(filterPathString);
filterPath.remove_filename(); filterPath.remove_filename();
auto currentDirPath = filterPath / "."; auto currentDirPath = filterPath / ".";
@ -856,15 +855,15 @@ unsigned int CMcServ::CPathFinder::Read(ENTRY* entry, unsigned int size)
return readCount; return readCount;
} }
void CMcServ::CPathFinder::SearchRecurse(const filesystem::path& path) void CMcServ::CPathFinder::SearchRecurse(const fs::path& path)
{ {
bool found = false; bool found = false;
filesystem::directory_iterator endIterator; fs::directory_iterator endIterator;
for(filesystem::directory_iterator elementIterator(path); for(fs::directory_iterator elementIterator(path);
elementIterator != endIterator; elementIterator++) elementIterator != endIterator; elementIterator++)
{ {
boost::filesystem::path relativePath(*elementIterator); fs::path relativePath(*elementIterator);
std::string relativePathString(relativePath.generic_string()); std::string relativePathString(relativePath.generic_string());
//"Extract" a more appropriate relative path from the memory card point of view //"Extract" a more appropriate relative path from the memory card point of view
@ -880,22 +879,24 @@ void CMcServ::CPathFinder::SearchRecurse(const filesystem::path& path)
strncpy(reinterpret_cast<char*>(entry.name), relativePath.filename().string().c_str(), 0x1F); strncpy(reinterpret_cast<char*>(entry.name), relativePath.filename().string().c_str(), 0x1F);
entry.name[0x1F] = 0; entry.name[0x1F] = 0;
if(filesystem::is_directory(*elementIterator)) if(fs::is_directory(*elementIterator))
{ {
entry.size = 0; entry.size = 0;
entry.attributes = 0x8427; entry.attributes = 0x8427;
} }
else else
{ {
entry.size = static_cast<uint32>(filesystem::file_size(*elementIterator)); entry.size = static_cast<uint32>(fs::file_size(*elementIterator));
entry.attributes = 0x8497; entry.attributes = 0x8497;
} }
//Fill in modification date info //Fill in modification date info
{ {
auto changeDate = filesystem::last_write_time(*elementIterator); auto changeFileTime = fs::last_write_time(*elementIterator);
auto localChangeDate = localtime(&changeDate); auto changeSystemTime = std::chrono::system_clock::to_time_t(
std::chrono::system_clock::now() + (changeFileTime - fs::file_time_type::clock::now()));
auto localChangeDate = std::localtime(&changeSystemTime);
entry.modificationTime.second = localChangeDate->tm_sec; entry.modificationTime.second = localChangeDate->tm_sec;
entry.modificationTime.minute = localChangeDate->tm_min; entry.modificationTime.minute = localChangeDate->tm_min;
entry.modificationTime.hour = localChangeDate->tm_hour; entry.modificationTime.hour = localChangeDate->tm_hour;
@ -904,14 +905,14 @@ void CMcServ::CPathFinder::SearchRecurse(const filesystem::path& path)
entry.modificationTime.year = localChangeDate->tm_year + 1900; entry.modificationTime.year = localChangeDate->tm_year + 1900;
} }
//boost::filesystem doesn't provide a way to get creation time, so just make it the same as modification date //std::filesystem doesn't provide a way to get creation time, so just make it the same as modification date
entry.creationTime = entry.modificationTime; entry.creationTime = entry.modificationTime;
m_entries.push_back(entry); m_entries.push_back(entry);
found = true; found = true;
} }
if(filesystem::is_directory(*elementIterator) && !found) if(fs::is_directory(*elementIterator) && !found)
{ {
SearchRecurse(*elementIterator); SearchRecurse(*elementIterator);
} }

12
Source/iop/Iop_McServ.h
View file

@ -3,7 +3,7 @@
#include <string> #include <string>
#include <map> #include <map>
#include <regex> #include <regex>
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include "StdStream.h" #include "StdStream.h"
#include "Iop_Module.h" #include "Iop_Module.h"
#include "Iop_SifMan.h" #include "Iop_SifMan.h"
@ -125,16 +125,16 @@ namespace Iop
virtual ~CPathFinder(); virtual ~CPathFinder();
void Reset(); void Reset();
void Search(const boost::filesystem::path&, const char*); void Search(const fs::path&, const char*);
unsigned int Read(ENTRY*, unsigned int); unsigned int Read(ENTRY*, unsigned int);
private: private:
typedef std::vector<ENTRY> EntryList; typedef std::vector<ENTRY> EntryList;
void SearchRecurse(const boost::filesystem::path&); void SearchRecurse(const fs::path&);
EntryList m_entries; EntryList m_entries;
boost::filesystem::path m_basePath; fs::path m_basePath;
std::regex m_filterExp; std::regex m_filterExp;
unsigned int m_index; unsigned int m_index;
}; };
@ -163,7 +163,7 @@ namespace Iop
uint32 GenerateHandle(); uint32 GenerateHandle();
Framework::CStdStream* GetFileFromHandle(uint32); Framework::CStdStream* GetFileFromHandle(uint32);
boost::filesystem::path GetAbsoluteFilePath(unsigned int, unsigned int, const char*) const; fs::path GetAbsoluteFilePath(unsigned int, unsigned int, const char*) const;
CIopBios& m_bios; CIopBios& m_bios;
CSifMan& m_sifMan; CSifMan& m_sifMan;
@ -177,7 +177,7 @@ namespace Iop
uint32 m_readFastAddr = 0; uint32 m_readFastAddr = 0;
Framework::CStdStream m_files[MAX_FILES]; Framework::CStdStream m_files[MAX_FILES];
static const char* m_mcPathPreference[2]; static const char* m_mcPathPreference[2];
boost::filesystem::path m_currentDirectory; fs::path m_currentDirectory;
CPathFinder m_pathFinder; CPathFinder m_pathFinder;
}; };
} }

4
Source/s3stream/S3ObjectStream.cpp
View file

@ -106,7 +106,7 @@ bool CS3ObjectStream::IsEOF()
return (m_objectPosition == m_objectSize); return (m_objectPosition == m_objectSize);
} }
boost::filesystem::path CS3ObjectStream::GetCachePath() fs::path CS3ObjectStream::GetCachePath()
{ {
return Framework::PathUtils::GetCachePath() / CACHE_PATH; return Framework::PathUtils::GetCachePath() / CACHE_PATH;
} }
@ -176,7 +176,7 @@ void CS3ObjectStream::SyncBuffer()
[&]() { [&]() {
try try
{ {
if(boost::filesystem::exists(readCacheFilePath)) if(fs::exists(readCacheFilePath))
{ {
auto readCacheFileStream = Framework::CreateInputStdStream(readCacheFilePath.native()); auto readCacheFileStream = Framework::CreateInputStdStream(readCacheFilePath.native());
auto cacheRead = readCacheFileStream.Read(m_buffer.data(), size); auto cacheRead = readCacheFileStream.Read(m_buffer.data(), size);

4
Source/s3stream/S3ObjectStream.h
View file

@ -2,7 +2,7 @@
#include "Singleton.h" #include "Singleton.h"
#include "Stream.h" #include "Stream.h"
#include "boost_filesystem_def.h" #include "filesystem_def.h"
class CS3ObjectStream : public Framework::CStream class CS3ObjectStream : public Framework::CStream
{ {
@ -24,7 +24,7 @@ public:
bool IsEOF() override; bool IsEOF() override;
private: private:
static boost::filesystem::path GetCachePath(); static fs::path GetCachePath();
std::string GenerateReadCacheKey(const std::pair<uint64, uint64>&) const; std::string GenerateReadCacheKey(const std::pair<uint64, uint64>&) const;
void GetObjectInfo(); void GetObjectInfo();
void SyncBuffer(); void SyncBuffer();

8
Source/saves/MaxSaveImporter.cpp
View file

@ -5,8 +5,6 @@
#include "MemStream.h" #include "MemStream.h"
#include "StdStreamUtils.h" #include "StdStreamUtils.h"
namespace filesystem = boost::filesystem;
CMaxSaveImporter::CMaxSaveImporter() CMaxSaveImporter::CMaxSaveImporter()
{ {
} }
@ -15,7 +13,7 @@ CMaxSaveImporter::~CMaxSaveImporter()
{ {
} }
void CMaxSaveImporter::Import(Framework::CStream& inputStream, const filesystem::path& basePath) void CMaxSaveImporter::Import(Framework::CStream& inputStream, const fs::path& basePath)
{ {
char magic[12]; char magic[12];
inputStream.Read(magic, sizeof(magic)); inputStream.Read(magic, sizeof(magic));
@ -42,9 +40,9 @@ void CMaxSaveImporter::Import(Framework::CStream& inputStream, const filesystem:
directoryDataStream.Seek(0, Framework::STREAM_SEEK_SET); directoryDataStream.Seek(0, Framework::STREAM_SEEK_SET);
auto directoryPath = basePath / directoryName; auto directoryPath = basePath / directoryName;
if(!filesystem::exists(directoryPath)) if(!fs::exists(directoryPath))
{ {
filesystem::create_directory(directoryPath); fs::create_directory(directoryPath);
} }
for(unsigned int i = 0; i < fileCount; i++) for(unsigned int i = 0; i < fileCount; i++)

2
Source/saves/MaxSaveImporter.h
View file

@ -9,7 +9,7 @@ public:
CMaxSaveImporter(); CMaxSaveImporter();
virtual ~CMaxSaveImporter(); virtual ~CMaxSaveImporter();
virtual void Import(Framework::CStream&, const boost::filesystem::path&); void Import(Framework::CStream&, const fs::path&) override;
}; };
#endif #endif

18
Source/saves/MemoryCard.cpp
View file

@ -1,8 +1,6 @@
#include "MemoryCard.h" #include "MemoryCard.h"
namespace filesystem = boost::filesystem; CMemoryCard::CMemoryCard(const fs::path& basePath)
CMemoryCard::CMemoryCard(const filesystem::path& basePath)
: m_basePath(basePath) : m_basePath(basePath)
{ {
ScanSaves(); ScanSaves();
@ -18,7 +16,7 @@ const CSave* CMemoryCard::GetSaveByIndex(size_t index) const
return m_saves[index].get(); return m_saves[index].get();
} }
filesystem::path CMemoryCard::GetBasePath() const fs::path CMemoryCard::GetBasePath() const
{ {
return m_basePath; return m_basePath;
} }
@ -33,18 +31,18 @@ void CMemoryCard::ScanSaves()
{ {
try try
{ {
filesystem::directory_iterator endIterator; fs::directory_iterator endIterator;
for(filesystem::directory_iterator elementIterator(m_basePath); for(fs::directory_iterator elementIterator(m_basePath);
elementIterator != endIterator; elementIterator++) elementIterator != endIterator; elementIterator++)
{ {
filesystem::path element(*elementIterator); fs::path element(*elementIterator);
if(filesystem::is_directory(element)) if(fs::is_directory(element))
{ {
filesystem::path iconSysPath = element / "icon.sys"; fs::path iconSysPath = element / "icon.sys";
//Check if 'icon.sys' exists in this directory //Check if 'icon.sys' exists in this directory
if(filesystem::exists(iconSysPath)) if(fs::exists(iconSysPath))
{ {
try try
{ {

8
Source/saves/MemoryCard.h
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <memory> #include <memory>
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include "Save.h" #include "Save.h"
class CMemoryCard class CMemoryCard
@ -10,18 +10,18 @@ public:
typedef std::shared_ptr<CSave> SavePtr; typedef std::shared_ptr<CSave> SavePtr;
typedef std::vector<SavePtr> SaveList; typedef std::vector<SavePtr> SaveList;
CMemoryCard(const boost::filesystem::path&); CMemoryCard(const fs::path&);
virtual ~CMemoryCard() = default; virtual ~CMemoryCard() = default;
size_t GetSaveCount() const; size_t GetSaveCount() const;
const CSave* GetSaveByIndex(size_t) const; const CSave* GetSaveByIndex(size_t) const;
boost::filesystem::path GetBasePath() const; fs::path GetBasePath() const;
void RefreshContents(); void RefreshContents();
private: private:
void ScanSaves(); void ScanSaves();
SaveList m_saves; SaveList m_saves;
boost::filesystem::path m_basePath; fs::path m_basePath;
}; };

10
Source/saves/PsuSaveImporter.cpp
View file

@ -1,8 +1,6 @@
#include "PsuSaveImporter.h" #include "PsuSaveImporter.h"
#include "StdStreamUtils.h" #include "StdStreamUtils.h"
namespace filesystem = boost::filesystem;
CPsuSaveImporter::CPsuSaveImporter() CPsuSaveImporter::CPsuSaveImporter()
{ {
} }
@ -11,11 +9,11 @@ CPsuSaveImporter::~CPsuSaveImporter()
{ {
} }
void CPsuSaveImporter::Import(Framework::CStream& input, const filesystem::path& basePath) void CPsuSaveImporter::Import(Framework::CStream& input, const fs::path& basePath)
{ {
if(!filesystem::exists(basePath)) if(!fs::exists(basePath))
{ {
filesystem::create_directory(basePath); fs::create_directory(basePath);
} }
uint16 nEntryType = input.Read16(); uint16 nEntryType = input.Read16();
@ -43,7 +41,7 @@ void CPsuSaveImporter::Import(Framework::CStream& input, const filesystem::path&
} }
else if(nEntryType == 0x8497) else if(nEntryType == 0x8497)
{ {
filesystem::path outputPath = basePath / sEntryName; fs::path outputPath = basePath / sEntryName;
if(!CanExtractFile(outputPath)) if(!CanExtractFile(outputPath))
{ {
input.Seek(nEntrySize, Framework::STREAM_SEEK_CUR); input.Seek(nEntrySize, Framework::STREAM_SEEK_CUR);

2
Source/saves/PsuSaveImporter.h
View file

@ -9,7 +9,7 @@ public:
CPsuSaveImporter(); CPsuSaveImporter();
virtual ~CPsuSaveImporter(); virtual ~CPsuSaveImporter();
virtual void Import(Framework::CStream&, const boost::filesystem::path&); void Import(Framework::CStream&, const fs::path&) override;
}; };
#endif #endif

29
Source/saves/Save.cpp
View file

@ -1,16 +1,13 @@
#include <boost/filesystem/operations.hpp>
#include <exception> #include <exception>
#include "string_cast_sjis.h" #include "string_cast_sjis.h"
#include "Save.h" #include "Save.h"
#include "StdStream.h" #include "StdStream.h"
#include "StdStreamUtils.h" #include "StdStreamUtils.h"
namespace filesystem = boost::filesystem; CSave::CSave(const fs::path& basePath)
CSave::CSave(const filesystem::path& basePath)
: m_basePath(basePath) : m_basePath(basePath)
{ {
filesystem::path iconSysPath = m_basePath / "icon.sys"; auto iconSysPath = m_basePath / "icon.sys";
auto iconStream(Framework::CreateInputStdStream(iconSysPath.native())); auto iconStream(Framework::CreateInputStdStream(iconSysPath.native()));
@ -39,7 +36,7 @@ CSave::CSave(const filesystem::path& basePath)
m_sId = m_basePath.filename().string(); m_sId = m_basePath.filename().string();
m_nLastModificationTime = filesystem::last_write_time(iconSysPath); m_nLastModificationTime = std::chrono::time_point_cast<std::chrono::seconds>(fs::last_write_time(iconSysPath)).time_since_epoch().count();
} }
CSave::~CSave() CSave::~CSave()
@ -58,30 +55,30 @@ const char* CSave::GetId() const
unsigned int CSave::GetSize() const unsigned int CSave::GetSize() const
{ {
filesystem::directory_iterator itEnd; fs::directory_iterator itEnd;
unsigned int nSize = 0; unsigned int nSize = 0;
for(filesystem::directory_iterator itElement(m_basePath); for(fs::directory_iterator itElement(m_basePath);
itElement != itEnd; itElement != itEnd;
itElement++) itElement++)
{ {
if(!filesystem::is_directory(*itElement)) if(!fs::is_directory(*itElement))
{ {
nSize += filesystem::file_size(*itElement); nSize += fs::file_size(*itElement);
} }
} }
return nSize; return nSize;
} }
filesystem::path CSave::GetPath() const fs::path CSave::GetPath() const
{ {
return m_basePath; return m_basePath;
} }
filesystem::path CSave::GetIconPath(const ICONTYPE& iconType) const fs::path CSave::GetIconPath(const ICONTYPE& iconType) const
{ {
filesystem::path iconPath; fs::path iconPath;
switch(iconType) switch(iconType)
{ {
case ICON_NORMAL: case ICON_NORMAL:
@ -97,17 +94,17 @@ filesystem::path CSave::GetIconPath(const ICONTYPE& iconType) const
return iconPath; return iconPath;
} }
filesystem::path CSave::GetNormalIconPath() const fs::path CSave::GetNormalIconPath() const
{ {
return m_basePath / m_sNormalIconFileName; return m_basePath / m_sNormalIconFileName;
} }
filesystem::path CSave::GetDeletingIconPath() const fs::path CSave::GetDeletingIconPath() const
{ {
return m_basePath / m_sDeletingIconFileName; return m_basePath / m_sDeletingIconFileName;
} }
filesystem::path CSave::GetCopyingIconPath() const fs::path CSave::GetCopyingIconPath() const
{ {
return m_basePath / m_sCopyingIconFileName; return m_basePath / m_sCopyingIconFileName;
} }

16
Source/saves/Save.h
View file

@ -1,7 +1,7 @@
#ifndef _SAVE_H_ #ifndef _SAVE_H_
#define _SAVE_H_ #define _SAVE_H_
#include <boost/filesystem/path.hpp> #include "filesystem_def.h"
#include <string> #include <string>
#include <ctime> #include <ctime>
#include "Types.h" #include "Types.h"
@ -17,18 +17,18 @@ public:
ICON_COPYING, ICON_COPYING,
}; };
CSave(const boost::filesystem::path&); CSave(const fs::path&);
virtual ~CSave(); virtual ~CSave();
const wchar_t* GetName() const; const wchar_t* GetName() const;
const char* GetId() const; const char* GetId() const;
unsigned int GetSize() const; unsigned int GetSize() const;
boost::filesystem::path GetPath() const; fs::path GetPath() const;
boost::filesystem::path GetIconPath(const ICONTYPE&) const; fs::path GetIconPath(const ICONTYPE&) const;
boost::filesystem::path GetNormalIconPath() const; fs::path GetNormalIconPath() const;
boost::filesystem::path GetDeletingIconPath() const; fs::path GetDeletingIconPath() const;
boost::filesystem::path GetCopyingIconPath() const; fs::path GetCopyingIconPath() const;
size_t GetSecondLineStartPosition() const; size_t GetSecondLineStartPosition() const;
time_t GetLastModificationTime() const; time_t GetLastModificationTime() const;
@ -36,7 +36,7 @@ public:
private: private:
void ReadName(Framework::CStream&); void ReadName(Framework::CStream&);
boost::filesystem::path m_basePath; fs::path m_basePath;
std::wstring m_sName; std::wstring m_sName;
std::string m_sId; std::string m_sId;
std::string m_sNormalIconFileName; std::string m_sNormalIconFileName;

42
Source/saves/SaveExporter.cpp
View file

@ -1,15 +1,13 @@
#include <boost/filesystem/operations.hpp>
#include <cstring> #include <cstring>
#include "SaveExporter.h" #include "SaveExporter.h"
#include "StdStream.h" #include "StdStream.h"
#include "StdStreamUtils.h" #include "StdStreamUtils.h"
void CSaveExporter::ExportPSU(Framework::CStream& outputStream, const boost::filesystem::path& savePath) void CSaveExporter::ExportPSU(Framework::CStream& outputStream, const fs::path& savePath)
{ {
uint32 nSector = 0x18D; uint32 nSector = 0x18D;
boost::posix_time::ptime baseTime = auto baseTime = fs::last_write_time(savePath);
boost::posix_time::from_time_t(boost::filesystem::last_write_time(savePath));
//Save base directory entry //Save base directory entry
{ {
@ -18,12 +16,12 @@ void CSaveExporter::ExportPSU(Framework::CStream& outputStream, const boost::fil
Entry.nSize = 2; Entry.nSize = 2;
const boost::filesystem::directory_iterator itEnd; const fs::directory_iterator itEnd;
for(boost::filesystem::directory_iterator itElement(savePath); for(fs::directory_iterator itElement(savePath);
itElement != itEnd; itElement != itEnd;
itElement++) itElement++)
{ {
if(boost::filesystem::is_directory(*itElement)) continue; if(fs::is_directory(*itElement)) continue;
Entry.nSize++; Entry.nSize++;
} }
@ -64,23 +62,22 @@ void CSaveExporter::ExportPSU(Framework::CStream& outputStream, const boost::fil
nSector += 2; nSector += 2;
//Save individual file entries //Save individual file entries
const boost::filesystem::directory_iterator itEnd; const fs::directory_iterator itEnd;
for(boost::filesystem::directory_iterator itElement(savePath); for(fs::directory_iterator itElement(savePath);
itElement != itEnd; itElement != itEnd;
itElement++) itElement++)
{ {
if(boost::filesystem::is_directory(*itElement)) continue; if(fs::is_directory(*itElement)) continue;
boost::filesystem::path saveItemPath(*itElement); fs::path saveItemPath(*itElement);
boost::posix_time::ptime itemTime = auto itemTime = fs::last_write_time(saveItemPath);
boost::posix_time::from_time_t(boost::filesystem::last_write_time(saveItemPath));
PSUENTRY Entry; PSUENTRY Entry;
memset(&Entry, 0, sizeof(PSUENTRY)); memset(&Entry, 0, sizeof(PSUENTRY));
Entry.nFlags = 0x8497; Entry.nFlags = 0x8497;
Entry.nSize = static_cast<uint32>(boost::filesystem::file_size(saveItemPath)); Entry.nSize = static_cast<uint32>(fs::file_size(saveItemPath));
Entry.nSector = nSector; Entry.nSector = nSector;
PSU_CopyTime(&Entry.CreationTime, itemTime); PSU_CopyTime(&Entry.CreationTime, itemTime);
@ -121,12 +118,15 @@ void CSaveExporter::ExportPSU(Framework::CStream& outputStream, const boost::fil
} }
} }
void CSaveExporter::PSU_CopyTime(PSUENTRY::TIME* pDst, const boost::posix_time::ptime& pSrc) void CSaveExporter::PSU_CopyTime(PSUENTRY::TIME* pDst, const fs::file_time_type& fileTime)
{ {
pDst->nSecond = static_cast<uint8>(pSrc.time_of_day().seconds()); auto systemTime = std::chrono::system_clock::now() + (fileTime - fs::file_time_type::clock::now());
pDst->nMinute = static_cast<uint8>(pSrc.time_of_day().minutes()); auto tm = std::chrono::system_clock::to_time_t(systemTime);
pDst->nHour = static_cast<uint8>(pSrc.time_of_day().hours()); const auto pSrc = std::localtime(&tm);
pDst->nDay = static_cast<uint8>(pSrc.date().day()); pDst->nSecond = static_cast<uint8>(pSrc->tm_sec);
pDst->nMonth = static_cast<uint8>(pSrc.date().month()); pDst->nMinute = static_cast<uint8>(pSrc->tm_min);
pDst->nYear = pSrc.date().year(); pDst->nHour = static_cast<uint8>(pSrc->tm_hour);
pDst->nDay = static_cast<uint8>(pSrc->tm_mday);
pDst->nMonth = static_cast<uint8>(pSrc->tm_mon);
pDst->nYear = pSrc->tm_year;
} }

7
Source/saves/SaveExporter.h
View file

@ -1,15 +1,14 @@
#ifndef _SAVEEXPORTER_H_ #ifndef _SAVEEXPORTER_H_
#define _SAVEEXPORTER_H_ #define _SAVEEXPORTER_H_
#include <boost/date_time/posix_time/posix_time.hpp> #include "filesystem_def.h"
#include <boost/filesystem/path.hpp>
#include "Types.h" #include "Types.h"
#include "Stream.h" #include "Stream.h"
class CSaveExporter class CSaveExporter
{ {
public: public:
static void ExportPSU(Framework::CStream&, const boost::filesystem::path&); static void ExportPSU(Framework::CStream&, const fs::path&);
private: private:
#pragma pack(push, 1) #pragma pack(push, 1)
@ -40,7 +39,7 @@ private:
#pragma pack(pop) #pragma pack(pop)
static void PSU_CopyTime(PSUENTRY::TIME*, const boost::posix_time::ptime&); static void PSU_CopyTime(PSUENTRY::TIME*, const fs::file_time_type&);
}; };
#endif #endif

6
Source/saves/SaveImporter.cpp
View file

@ -1,14 +1,10 @@
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>
#include "SaveImporter.h" #include "SaveImporter.h"
#include "StdStreamUtils.h" #include "StdStreamUtils.h"
#include "PsuSaveImporter.h" #include "PsuSaveImporter.h"
#include "XpsSaveImporter.h" #include "XpsSaveImporter.h"
#include "MaxSaveImporter.h" #include "MaxSaveImporter.h"
namespace filesystem = boost::filesystem; void CSaveImporter::ImportSave(Framework::CStream& input, const fs::path& outputPath, const OverwritePromptHandlerType& overwritePromptHandler)
void CSaveImporter::ImportSave(Framework::CStream& input, const boost::filesystem::path& outputPath, const OverwritePromptHandlerType& overwritePromptHandler)
{ {
std::shared_ptr<CSaveImporterBase> importer; std::shared_ptr<CSaveImporterBase> importer;

4
Source/saves/SaveImporter.h
View file

@ -1,7 +1,7 @@
#ifndef _SAVEIMPORTER_H_ #ifndef _SAVEIMPORTER_H_
#define _SAVEIMPORTER_H_ #define _SAVEIMPORTER_H_
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include "Stream.h" #include "Stream.h"
#include "SaveImporterBase.h" #include "SaveImporterBase.h"
@ -10,7 +10,7 @@ class CSaveImporter
public: public:
typedef CSaveImporterBase::OverwritePromptHandlerType OverwritePromptHandlerType; typedef CSaveImporterBase::OverwritePromptHandlerType OverwritePromptHandlerType;
static void ImportSave(Framework::CStream&, const boost::filesystem::path&, const OverwritePromptHandlerType&); static void ImportSave(Framework::CStream&, const fs::path&, const OverwritePromptHandlerType&);
}; };
#endif #endif

8
Source/saves/SaveImporterBase.cpp
View file

@ -1,7 +1,5 @@
#include "SaveImporterBase.h" #include "SaveImporterBase.h"
namespace filesystem = boost::filesystem;
CSaveImporterBase::CSaveImporterBase() CSaveImporterBase::CSaveImporterBase()
: m_overwriteAll(false) : m_overwriteAll(false)
{ {
@ -16,13 +14,13 @@ void CSaveImporterBase::SetOverwritePromptHandler(const OverwritePromptHandlerTy
m_overwritePromptHandler = overwritePromptHandler; m_overwritePromptHandler = overwritePromptHandler;
} }
bool CSaveImporterBase::CanExtractFile(const filesystem::path& filePath) bool CSaveImporterBase::CanExtractFile(const fs::path& filePath)
{ {
if(!filesystem::exists(filePath)) return true; if(!fs::exists(filePath)) return true;
if(m_overwriteAll) return true; if(m_overwriteAll) return true;
if(!m_overwritePromptHandler) return true; if(!m_overwritePromptHandler) return true;
auto result = m_overwritePromptHandler(filesystem::absolute(filePath).string()); auto result = m_overwritePromptHandler(fs::absolute(filePath).string());
switch(result) switch(result)
{ {

8
Source/saves/SaveImporterBase.h
View file

@ -1,7 +1,7 @@
#ifndef _SAVEIMPORTERBASE_H_ #ifndef _SAVEIMPORTERBASE_H_
#define _SAVEIMPORTERBASE_H_ #define _SAVEIMPORTERBASE_H_
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include <functional> #include <functional>
#include "Stream.h" #include "Stream.h"
@ -15,17 +15,17 @@ public:
OVERWRITE_NO OVERWRITE_NO
}; };
typedef std::function<OVERWRITE_PROMPT_RETURN(const boost::filesystem::path&)> OverwritePromptHandlerType; typedef std::function<OVERWRITE_PROMPT_RETURN(const fs::path&)> OverwritePromptHandlerType;
CSaveImporterBase(); CSaveImporterBase();
virtual ~CSaveImporterBase(); virtual ~CSaveImporterBase();
virtual void Import(Framework::CStream&, const boost::filesystem::path&) = 0; virtual void Import(Framework::CStream&, const fs::path&) = 0;
void SetOverwritePromptHandler(const OverwritePromptHandlerType&); void SetOverwritePromptHandler(const OverwritePromptHandlerType&);
protected: protected:
bool CanExtractFile(const boost::filesystem::path&); bool CanExtractFile(const fs::path&);
private: private:
bool m_overwriteAll; bool m_overwriteAll;

12
Source/saves/XpsSaveImporter.cpp
View file

@ -2,8 +2,6 @@
#include "XpsSaveImporter.h" #include "XpsSaveImporter.h"
#include "StdStreamUtils.h" #include "StdStreamUtils.h"
namespace filesystem = boost::filesystem;
CXpsSaveImporter::CXpsSaveImporter() CXpsSaveImporter::CXpsSaveImporter()
{ {
} }
@ -12,7 +10,7 @@ CXpsSaveImporter::~CXpsSaveImporter()
{ {
} }
void CXpsSaveImporter::Import(Framework::CStream& input, const boost::filesystem::path& outputPath) void CXpsSaveImporter::Import(Framework::CStream& input, const fs::path& outputPath)
{ {
input.Seek(4, Framework::STREAM_SEEK_SET); input.Seek(4, Framework::STREAM_SEEK_SET);
@ -53,11 +51,11 @@ void CXpsSaveImporter::Import(Framework::CStream& input, const boost::filesystem
ExtractFiles(input, outputPath, nArchiveSize); ExtractFiles(input, outputPath, nArchiveSize);
} }
void CXpsSaveImporter::ExtractFiles(Framework::CStream& input, const boost::filesystem::path& basePath, uint32 nArchiveSize) void CXpsSaveImporter::ExtractFiles(Framework::CStream& input, const fs::path& basePath, uint32 nArchiveSize)
{ {
if(!filesystem::exists(basePath)) if(!fs::exists(basePath))
{ {
filesystem::create_directory(basePath); fs::create_directory(basePath);
} }
while(!input.IsEOF() && (static_cast<uint32>(input.Tell()) < nArchiveSize)) while(!input.IsEOF() && (static_cast<uint32>(input.Tell()) < nArchiveSize))
@ -74,7 +72,7 @@ void CXpsSaveImporter::ExtractFiles(Framework::CStream& input, const boost::file
input.Seek(nDescriptorLength - (0x40 + 4 + 4 + 8 + 2), Framework::STREAM_SEEK_CUR); input.Seek(nDescriptorLength - (0x40 + 4 + 4 + 8 + 2), Framework::STREAM_SEEK_CUR);
filesystem::path outputPath(basePath / sName); fs::path outputPath(basePath / sName);
if(nAttributes & 0x2000) if(nAttributes & 0x2000)
{ {

4
Source/saves/XpsSaveImporter.h
View file

@ -9,10 +9,10 @@ public:
CXpsSaveImporter(); CXpsSaveImporter();
virtual ~CXpsSaveImporter(); virtual ~CXpsSaveImporter();
virtual void Import(Framework::CStream&, const boost::filesystem::path&); void Import(Framework::CStream&, const fs::path&) override;
private: private:
void ExtractFiles(Framework::CStream&, const boost::filesystem::path&, uint32); void ExtractFiles(Framework::CStream&, const fs::path&, uint32);
}; };
#endif #endif

5
Source/ui_qt/CoverUtils.cpp
View file

@ -27,12 +27,13 @@ void CoverUtils::PopulatePlaceholderCover()
CoverUtils::cache.insert(std::make_pair("PH", pixmap)); CoverUtils::cache.insert(std::make_pair("PH", pixmap));
} }
} }
void CoverUtils::PopulateCache(std::vector<BootablesDb::Bootable> bootables) void CoverUtils::PopulateCache(std::vector<BootablesDb::Bootable> bootables)
{ {
m_lock.lock(); m_lock.lock();
PopulatePlaceholderCover(); PopulatePlaceholderCover();
auto coverpath(CAppConfig::GetBasePath() / boost::filesystem::path("covers")); auto coverpath(CAppConfig::GetBasePath() / fs::path("covers"));
Framework::PathUtils::EnsurePathExists(coverpath); Framework::PathUtils::EnsurePathExists(coverpath);
auto itr = CoverUtils::cache.find("PH"); auto itr = CoverUtils::cache.find("PH");
@ -43,7 +44,7 @@ void CoverUtils::PopulateCache(std::vector<BootablesDb::Bootable> bootables)
continue; continue;
auto path = coverpath / (bootable.discId + ".jpg"); auto path = coverpath / (bootable.discId + ".jpg");
if(boost::filesystem::exists(path)) if(fs::exists(path))
{ {
auto itr = CoverUtils::cache.find(bootable.discId.c_str()); auto itr = CoverUtils::cache.find(bootable.discId.c_str());
if(itr == CoverUtils::cache.end()) if(itr == CoverUtils::cache.end())

8
Source/ui_qt/QStringUtils.cpp
View file

@ -31,14 +31,14 @@ QString CvtToString(const std::wstring& str)
return QString::fromStdWString(str); return QString::fromStdWString(str);
} }
boost::filesystem::path QStringToPath(const QString& str) fs::path QStringToPath(const QString& str)
{ {
auto nativeStr = QDir::toNativeSeparators(str); auto nativeStr = QDir::toNativeSeparators(str);
auto result = CvtToNativePath<boost::filesystem::path::string_type>(nativeStr); auto result = CvtToNativePath<fs::path::string_type>(nativeStr);
return boost::filesystem::path(result); return fs::path(result);
} }
QString PathToQString(const boost::filesystem::path& path) QString PathToQString(const fs::path& path)
{ {
return CvtToString(path.native()); return CvtToString(path.native());
} }

6
Source/ui_qt/QStringUtils.h
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <QString> #include <QString>
#include "boost_filesystem_def.h" #include "filesystem_def.h"
boost::filesystem::path QStringToPath(const QString&); fs::path QStringToPath(const QString&);
QString PathToQString(const boost::filesystem::path&); QString PathToQString(const fs::path&);

2
Source/ui_qt/S3FileBrowser.cpp
View file

@ -37,7 +37,7 @@ bool S3FileBrowser::IsAvailable()
return !accessKeyId.empty() && !accessKeySecret.empty(); return !accessKeyId.empty() && !accessKeySecret.empty();
} }
boost::filesystem::path S3FileBrowser::GetSelectedPath() const fs::path S3FileBrowser::GetSelectedPath() const
{ {
return m_selectedPath; return m_selectedPath;
} }

6
Source/ui_qt/S3FileBrowser.h
View file

@ -4,7 +4,7 @@
#include <QListWidgetItem> #include <QListWidgetItem>
#undef DELETE #undef DELETE
#include "../s3stream/AmazonS3Client.h" #include "../s3stream/AmazonS3Client.h"
#include "boost_filesystem_def.h" #include "filesystem_def.h"
#include "ContinuationChecker.h" #include "ContinuationChecker.h"
namespace Ui namespace Ui
@ -22,7 +22,7 @@ public:
static bool IsAvailable(); static bool IsAvailable();
boost::filesystem::path GetSelectedPath() const; fs::path GetSelectedPath() const;
private slots: private slots:
void refreshButton_clicked(); void refreshButton_clicked();
@ -41,5 +41,5 @@ private:
QTimer* m_filterTimer = nullptr; QTimer* m_filterTimer = nullptr;
ListObjectsResult m_bucketItems; ListObjectsResult m_bucketItems;
boost::filesystem::path m_selectedPath; fs::path m_selectedPath;
}; };

6
Source/ui_qt/VfsDevice.h
View file

@ -2,7 +2,7 @@
#include <QWidget> #include <QWidget>
#include <map> #include <map>
#include "boost_filesystem_def.h" #include "filesystem_def.h"
class CDevice class CDevice
{ {
@ -31,7 +31,7 @@ public:
private: private:
const char* m_name; const char* m_name;
const char* m_preference; const char* m_preference;
boost::filesystem::path m_value; fs::path m_value;
}; };
class CCdrom0Device : public CDevice class CCdrom0Device : public CDevice
@ -53,6 +53,6 @@ public:
void Save() override; void Save() override;
private: private:
boost::filesystem::path m_imagePath; fs::path m_imagePath;
BINDINGTYPE m_bindingType; BINDINGTYPE m_bindingType;
}; };

14
Source/ui_qt/mainwindow.cpp
View file

@ -94,7 +94,7 @@ MainWindow::MainWindow(QWidget* parent)
m_pauseFocusLost = CAppConfig::GetInstance().GetPreferenceBoolean(PREF_UI_PAUSEWHENFOCUSLOST); m_pauseFocusLost = CAppConfig::GetInstance().GetPreferenceBoolean(PREF_UI_PAUSEWHENFOCUSLOST);
auto lastPath = CAppConfig::GetInstance().GetPreferencePath(PREF_PS2_CDROM0_PATH); auto lastPath = CAppConfig::GetInstance().GetPreferencePath(PREF_PS2_CDROM0_PATH);
if(boost::filesystem::exists(lastPath)) if(fs::exists(lastPath))
{ {
m_lastPath = lastPath.parent_path(); m_lastPath = lastPath.parent_path();
} }
@ -338,7 +338,7 @@ void MainWindow::on_actionBoot_ELF_triggered()
} }
} }
void MainWindow::BootElf(boost::filesystem::path filePath) void MainWindow::BootElf(fs::path filePath)
{ {
BootablesDb::CClient::GetInstance().SetLastBootedTime(filePath, std::time(nullptr)); BootablesDb::CClient::GetInstance().SetLastBootedTime(filePath, std::time(nullptr));
@ -353,7 +353,7 @@ void MainWindow::BootElf(boost::filesystem::path filePath)
.arg(m_virtualMachine->m_ee->m_os->GetExecutableName())); .arg(m_virtualMachine->m_ee->m_os->GetExecutableName()));
} }
void MainWindow::LoadCDROM(boost::filesystem::path filePath) void MainWindow::LoadCDROM(fs::path filePath)
{ {
m_lastPath = filePath.parent_path(); m_lastPath = filePath.parent_path();
CAppConfig::GetInstance().SetPreferencePath(PREF_PS2_CDROM0_PATH, filePath); CAppConfig::GetInstance().SetPreferencePath(PREF_PS2_CDROM0_PATH, filePath);
@ -688,9 +688,9 @@ void MainWindow::ShowFrameDebugger()
SetForegroundWindow(*m_frameDebugger); SetForegroundWindow(*m_frameDebugger);
} }
boost::filesystem::path MainWindow::GetFrameDumpDirectoryPath() fs::path MainWindow::GetFrameDumpDirectoryPath()
{ {
return CAppConfig::GetBasePath() / boost::filesystem::path("framedumps/"); return CAppConfig::GetBasePath() / fs::path("framedumps/");
} }
void MainWindow::DumpNextFrame() void MainWindow::DumpNextFrame()
@ -704,8 +704,8 @@ void MainWindow::DumpNextFrame()
for(unsigned int i = 0; i < UINT_MAX; i++) for(unsigned int i = 0; i < UINT_MAX; i++)
{ {
auto frameDumpFileName = string_format("framedump_%08d.dmp.zip", i); auto frameDumpFileName = string_format("framedump_%08d.dmp.zip", i);
auto frameDumpPath = frameDumpDirectoryPath / boost::filesystem::path(frameDumpFileName); auto frameDumpPath = frameDumpDirectoryPath / fs::path(frameDumpFileName);
if(!boost::filesystem::exists(frameDumpPath)) if(!fs::exists(frameDumpPath))
{ {
auto dumpStream = Framework::CreateOutputStdStream(frameDumpPath.native()); auto dumpStream = Framework::CreateOutputStdStream(frameDumpPath.native());
frameDump.Write(dumpStream); frameDump.Write(dumpStream);

12
Source/ui_qt/mainwindow.h
View file

@ -42,15 +42,15 @@ public:
explicit MainWindow(QWidget* parent = nullptr); explicit MainWindow(QWidget* parent = nullptr);
~MainWindow(); ~MainWindow();
void BootElf(boost::filesystem::path); void BootElf(fs::path);
void BootCDROM(); void BootCDROM();
void LoadCDROM(boost::filesystem::path filePath); void LoadCDROM(fs::path filePath);
void loadState(int); void loadState(int);
#ifdef DEBUGGER_INCLUDED #ifdef DEBUGGER_INCLUDED
void ShowDebugger(); void ShowDebugger();
void ShowFrameDebugger(); void ShowFrameDebugger();
boost::filesystem::path GetFrameDumpDirectoryPath(); fs::path GetFrameDumpDirectoryPath();
void DumpNextFrame(); void DumpNextFrame();
void ToggleGsDraw(); void ToggleGsDraw();
#endif #endif
@ -65,13 +65,13 @@ private:
struct LastOpenCommand struct LastOpenCommand
{ {
LastOpenCommand() = default; LastOpenCommand() = default;
LastOpenCommand(BootType type, boost::filesystem::path path) LastOpenCommand(BootType type, fs::path path)
: type(type) : type(type)
, path(path) , path(path)
{ {
} }
BootType type = BootType::CD; BootType type = BootType::CD;
boost::filesystem::path path; fs::path path;
}; };
void SetOpenGlPanelSize(); void SetOpenGlPanelSize();
@ -106,7 +106,7 @@ private:
bool m_pauseFocusLost = true; bool m_pauseFocusLost = true;
std::shared_ptr<CInputProviderQtKey> m_qtKeyInputProvider; std::shared_ptr<CInputProviderQtKey> m_qtKeyInputProvider;
LastOpenCommand m_lastOpenCommand; LastOpenCommand m_lastOpenCommand;
boost::filesystem::path m_lastPath; fs::path m_lastPath;
Framework::CSignal<void()>::Connection m_OnExecutableChangeConnection; Framework::CSignal<void()>::Connection m_OnExecutableChangeConnection;
CGSHandler::NewFrameEvent::Connection m_OnNewFrameConnection; CGSHandler::NewFrameEvent::Connection m_OnNewFrameConnection;

6
Source/ui_qt/memorycardmanagerdialog.cpp
View file

@ -64,9 +64,9 @@ void MemoryCardManagerDialog::on_import_saves_button_clicked()
} }
} }
CSaveImporterBase::OVERWRITE_PROMPT_RETURN MemoryCardManagerDialog::OnImportOverwrite(const boost::filesystem::path& filePath) CSaveImporterBase::OVERWRITE_PROMPT_RETURN MemoryCardManagerDialog::OnImportOverwrite(const fs::path& filePath)
{ {
std::string fileName = filePath.leaf().string(); std::string fileName = filePath.filename().string();
QString msg("File %1 already exists.\n\nOverwrite?"); QString msg("File %1 already exists.\n\nOverwrite?");
QMessageBox::StandardButton resBtn = QMessageBox::question(this, "Overwrite?", QMessageBox::StandardButton resBtn = QMessageBox::question(this, "Overwrite?",
msg.arg(fileName.c_str()), msg.arg(fileName.c_str()),
@ -136,7 +136,7 @@ void MemoryCardManagerDialog::on_delete_save_button_clicked()
if(currentRow >= 0 && currentRow <= nItemCount) if(currentRow >= 0 && currentRow <= nItemCount)
{ {
const CSave* save = m_pCurrentMemoryCard->GetSaveByIndex(currentRow); const CSave* save = m_pCurrentMemoryCard->GetSaveByIndex(currentRow);
boost::filesystem::remove_all(save->GetPath()); fs::remove_all(save->GetPath());
m_pCurrentMemoryCard->RefreshContents(); m_pCurrentMemoryCard->RefreshContents();
populateSaveList(); populateSaveList();
} }

3
Source/ui_qt/memorycardmanagerdialog.h
View file

@ -6,7 +6,6 @@
#include "saves/SaveImporter.h" #include "saves/SaveImporter.h"
#include <QDialog> #include <QDialog>
#include <QDir> #include <QDir>
#include <boost/filesystem.hpp>
namespace Ui namespace Ui
{ {
@ -22,7 +21,7 @@ public:
~MemoryCardManagerDialog(); ~MemoryCardManagerDialog();
private: private:
CSaveImporterBase::OVERWRITE_PROMPT_RETURN OnImportOverwrite(const boost::filesystem::path&); CSaveImporterBase::OVERWRITE_PROMPT_RETURN OnImportOverwrite(const fs::path&);
void populateSaveList(); void populateSaveList();
Ui::MemoryCardManagerDialog* ui; Ui::MemoryCardManagerDialog* ui;

2
Source/ui_qt/vfsdiscselectordialog.cpp
View file

@ -5,7 +5,7 @@
#include <QMessageBox> #include <QMessageBox>
#include "QStringUtils.h" #include "QStringUtils.h"
VFSDiscSelectorDialog::VFSDiscSelectorDialog(boost::filesystem::path path, CCdrom0Device::BINDINGTYPE m_nBindingType, QWidget* parent) VFSDiscSelectorDialog::VFSDiscSelectorDialog(fs::path path, CCdrom0Device::BINDINGTYPE m_nBindingType, QWidget* parent)
: QDialog(parent) : QDialog(parent)
, ui(new Ui::VFSDiscSelectorDialog) , ui(new Ui::VFSDiscSelectorDialog)
, m_path(path) , m_path(path)

4
Source/ui_qt/vfsdiscselectordialog.h
View file

@ -15,7 +15,7 @@ class VFSDiscSelectorDialog : public QDialog
Q_OBJECT Q_OBJECT
public: public:
explicit VFSDiscSelectorDialog(boost::filesystem::path, CCdrom0Device::BINDINGTYPE, QWidget* parent = nullptr); explicit VFSDiscSelectorDialog(fs::path, CCdrom0Device::BINDINGTYPE, QWidget* parent = nullptr);
~VFSDiscSelectorDialog(); ~VFSDiscSelectorDialog();
protected: protected:
@ -35,6 +35,6 @@ private:
void Refresh_disc_drive(); void Refresh_disc_drive();
Ui::VFSDiscSelectorDialog* ui; Ui::VFSDiscSelectorDialog* ui;
boost::filesystem::path m_path; fs::path m_path;
QList<QStorageInfo> m_discInfo; QList<QStorageInfo> m_discInfo;
}; };

18
Source/ui_shared/BootablesDbClient.cpp
View file

@ -43,7 +43,7 @@ CClient::CClient()
} }
} }
Bootable CClient::GetBootable(const boost::filesystem::path& path) Bootable CClient::GetBootable(const fs::path& path)
{ {
Framework::CSqliteStatement statement(m_db, "SELECT * FROM bootables WHERE path = ?"); Framework::CSqliteStatement statement(m_db, "SELECT * FROM bootables WHERE path = ?");
statement.BindText(1, Framework::PathUtils::GetNativeStringFromPath(path).c_str()); statement.BindText(1, Framework::PathUtils::GetNativeStringFromPath(path).c_str());
@ -78,7 +78,7 @@ std::vector<Bootable> CClient::GetBootables(int32_t sortMethod)
return bootables; return bootables;
} }
void CClient::RegisterBootable(const boost::filesystem::path& path, const char* title, const char* discId) void CClient::RegisterBootable(const fs::path& path, const char* title, const char* discId)
{ {
Framework::CSqliteStatement statement(m_db, "INSERT OR IGNORE INTO bootables (path, title, discId) VALUES (?,?,?)"); Framework::CSqliteStatement statement(m_db, "INSERT OR IGNORE INTO bootables (path, title, discId) VALUES (?,?,?)");
statement.BindText(1, Framework::PathUtils::GetNativeStringFromPath(path).c_str()); statement.BindText(1, Framework::PathUtils::GetNativeStringFromPath(path).c_str());
@ -87,14 +87,14 @@ void CClient::RegisterBootable(const boost::filesystem::path& path, const char*
statement.StepNoResult(); statement.StepNoResult();
} }
void CClient::UnregisterBootable(const boost::filesystem::path& path) void CClient::UnregisterBootable(const fs::path& path)
{ {
Framework::CSqliteStatement statement(m_db, "DELETE FROM bootables WHERE path = ?"); Framework::CSqliteStatement statement(m_db, "DELETE FROM bootables WHERE path = ?");
statement.BindText(1, Framework::PathUtils::GetNativeStringFromPath(path).c_str()); statement.BindText(1, Framework::PathUtils::GetNativeStringFromPath(path).c_str());
statement.StepNoResult(); statement.StepNoResult();
} }
void CClient::SetDiscId(const boost::filesystem::path& path, const char* discId) void CClient::SetDiscId(const fs::path& path, const char* discId)
{ {
Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET discId = ? WHERE path = ?"); Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET discId = ? WHERE path = ?");
statement.BindText(1, discId, true); statement.BindText(1, discId, true);
@ -102,7 +102,7 @@ void CClient::SetDiscId(const boost::filesystem::path& path, const char* discId)
statement.StepNoResult(); statement.StepNoResult();
} }
void CClient::SetTitle(const boost::filesystem::path& path, const char* title) void CClient::SetTitle(const fs::path& path, const char* title)
{ {
Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET title = ? WHERE path = ?"); Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET title = ? WHERE path = ?");
statement.BindText(1, title, true); statement.BindText(1, title, true);
@ -110,7 +110,7 @@ void CClient::SetTitle(const boost::filesystem::path& path, const char* title)
statement.StepNoResult(); statement.StepNoResult();
} }
void CClient::SetCoverUrl(const boost::filesystem::path& path, const char* coverUrl) void CClient::SetCoverUrl(const fs::path& path, const char* coverUrl)
{ {
Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET coverUrl = ? WHERE path = ?"); Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET coverUrl = ? WHERE path = ?");
statement.BindText(1, coverUrl, true); statement.BindText(1, coverUrl, true);
@ -118,7 +118,7 @@ void CClient::SetCoverUrl(const boost::filesystem::path& path, const char* cover
statement.StepNoResult(); statement.StepNoResult();
} }
void CClient::SetLastBootedTime(const boost::filesystem::path& path, time_t lastBootedTime) void CClient::SetLastBootedTime(const fs::path& path, time_t lastBootedTime)
{ {
Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET lastBootedTime = ? WHERE path = ?"); Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET lastBootedTime = ? WHERE path = ?");
statement.BindInteger(1, lastBootedTime); statement.BindInteger(1, lastBootedTime);
@ -126,7 +126,7 @@ void CClient::SetLastBootedTime(const boost::filesystem::path& path, time_t last
statement.StepNoResult(); statement.StepNoResult();
} }
void CClient::SetOverview(const boost::filesystem::path& path, const char* overview) void CClient::SetOverview(const fs::path& path, const char* overview)
{ {
Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET overview = ? WHERE path = ?"); Framework::CSqliteStatement statement(m_db, "UPDATE bootables SET overview = ? WHERE path = ?");
statement.BindText(1, overview, true); statement.BindText(1, overview, true);
@ -168,6 +168,6 @@ void CClient::CheckDbVersion()
if(!dbExistsAndMatchesVersion) if(!dbExistsAndMatchesVersion)
{ {
boost::filesystem::remove(m_dbPath); fs::remove(m_dbPath);
} }
} }

22
Source/ui_shared/BootablesDbClient.h
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <string> #include <string>
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include "Types.h" #include "Types.h"
#include "Singleton.h" #include "Singleton.h"
#include "sqlite/SqliteDb.h" #include "sqlite/SqliteDb.h"
@ -11,7 +11,7 @@ namespace BootablesDb
{ {
struct Bootable struct Bootable
{ {
boost::filesystem::path path; fs::path path;
std::string discId; std::string discId;
std::string title; std::string title;
std::string coverUrl; std::string coverUrl;
@ -33,24 +33,24 @@ namespace BootablesDb
CClient(); CClient();
virtual ~CClient() = default; virtual ~CClient() = default;
Bootable GetBootable(const boost::filesystem::path&); Bootable GetBootable(const fs::path&);
std::vector<Bootable> GetBootables(int32_t = SORT_METHOD_NONE); std::vector<Bootable> GetBootables(int32_t = SORT_METHOD_NONE);
void RegisterBootable(const boost::filesystem::path&, const char*, const char*); void RegisterBootable(const fs::path&, const char*, const char*);
void UnregisterBootable(const boost::filesystem::path&); void UnregisterBootable(const fs::path&);
void SetDiscId(const boost::filesystem::path&, const char*); void SetDiscId(const fs::path&, const char*);
void SetTitle(const boost::filesystem::path&, const char*); void SetTitle(const fs::path&, const char*);
void SetCoverUrl(const boost::filesystem::path&, const char*); void SetCoverUrl(const fs::path&, const char*);
void SetLastBootedTime(const boost::filesystem::path&, time_t); void SetLastBootedTime(const fs::path&, time_t);
void SetOverview(const boost::filesystem::path& path, const char* overview); void SetOverview(const fs::path& path, const char* overview);
private: private:
static Bootable ReadBootable(Framework::CSqliteStatement&); static Bootable ReadBootable(Framework::CSqliteStatement&);
void CheckDbVersion(); void CheckDbVersion();
boost::filesystem::path m_dbPath; fs::path m_dbPath;
Framework::CSqliteDb m_db; Framework::CSqliteDb m_db;
}; };
}; };

31
Source/ui_shared/BootablesProcesses.cpp
View file

@ -6,8 +6,8 @@
#include "DiskUtils.h" #include "DiskUtils.h"
#include "PathUtils.h" #include "PathUtils.h"
#include "string_format.h" #include "string_format.h"
#include "StdStreamUtils.h"
#include "http/HttpClientFactory.h" #include "http/HttpClientFactory.h"
#include <iostream>
//Jobs //Jobs
// Scan for new games (from input directory) // Scan for new games (from input directory)
@ -15,14 +15,14 @@
// Extract game ids from disk images // Extract game ids from disk images
// Pull disc cover URLs and titles from GamesDb/TheGamesDb // Pull disc cover URLs and titles from GamesDb/TheGamesDb
bool IsBootableExecutablePath(const boost::filesystem::path& filePath) bool IsBootableExecutablePath(const fs::path& filePath)
{ {
auto extension = filePath.extension().string(); auto extension = filePath.extension().string();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower); std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
return (extension == ".elf"); return (extension == ".elf");
} }
bool IsBootableDiscImagePath(const boost::filesystem::path& filePath) bool IsBootableDiscImagePath(const fs::path& filePath)
{ {
auto extension = filePath.extension().string(); auto extension = filePath.extension().string();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower); std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
@ -32,7 +32,7 @@ bool IsBootableDiscImagePath(const boost::filesystem::path& filePath)
(extension == ".bin"); (extension == ".bin");
} }
void TryRegisteringBootable(const boost::filesystem::path& path) void TryRegisteringBootable(const fs::path& path)
{ {
std::string serial; std::string serial;
if( if(
@ -44,15 +44,15 @@ void TryRegisteringBootable(const boost::filesystem::path& path)
BootablesDb::CClient::GetInstance().RegisterBootable(path, path.filename().string().c_str(), serial.c_str()); BootablesDb::CClient::GetInstance().RegisterBootable(path, path.filename().string().c_str(), serial.c_str());
} }
void ScanBootables(const boost::filesystem::path& parentPath, bool recursive) void ScanBootables(const fs::path& parentPath, bool recursive)
{ {
for(auto pathIterator = boost::filesystem::directory_iterator(parentPath); for(auto pathIterator = fs::directory_iterator(parentPath);
pathIterator != boost::filesystem::directory_iterator(); pathIterator++) pathIterator != fs::directory_iterator(); pathIterator++)
{ {
auto& path = pathIterator->path(); auto& path = pathIterator->path();
try try
{ {
if(recursive && boost::filesystem::is_directory(path)) if(recursive && fs::is_directory(path))
{ {
ScanBootables(path, recursive); ScanBootables(path, recursive);
continue; continue;
@ -66,9 +66,9 @@ void ScanBootables(const boost::filesystem::path& parentPath, bool recursive)
} }
} }
std::set<boost::filesystem::path> GetActiveBootableDirectories() std::set<fs::path> GetActiveBootableDirectories()
{ {
std::set<boost::filesystem::path> result; std::set<fs::path> result;
auto bootables = BootablesDb::CClient::GetInstance().GetBootables(); auto bootables = BootablesDb::CClient::GetInstance().GetBootables();
for(const auto& bootable : bootables) for(const auto& bootable : bootables)
{ {
@ -83,7 +83,7 @@ void PurgeInexistingFiles()
auto bootables = BootablesDb::CClient::GetInstance().GetBootables(); auto bootables = BootablesDb::CClient::GetInstance().GetBootables();
for(const auto& bootable : bootables) for(const auto& bootable : bootables)
{ {
if(boost::filesystem::exists(bootable.path)) continue; if(fs::exists(bootable.path)) continue;
BootablesDb::CClient::GetInstance().UnregisterBootable(bootable.path); BootablesDb::CClient::GetInstance().UnregisterBootable(bootable.path);
} }
} }
@ -140,7 +140,7 @@ void FetchGameTitles()
void FetchGameCovers() void FetchGameCovers()
{ {
auto coverpath(CAppConfig::GetBasePath() / boost::filesystem::path("covers")); auto coverpath(CAppConfig::GetBasePath() / fs::path("covers"));
Framework::PathUtils::EnsurePathExists(coverpath); Framework::PathUtils::EnsurePathExists(coverpath);
auto bootables = BootablesDb::CClient::GetInstance().GetBootables(); auto bootables = BootablesDb::CClient::GetInstance().GetBootables();
@ -151,7 +151,7 @@ void FetchGameCovers()
continue; continue;
auto path = coverpath / (bootable.discId + ".jpg"); auto path = coverpath / (bootable.discId + ".jpg");
if(boost::filesystem::exists(path)) if(fs::exists(path))
continue; continue;
auto requestResult = auto requestResult =
@ -162,9 +162,8 @@ void FetchGameCovers()
}(); }();
if(requestResult.statusCode == Framework::Http::HTTP_STATUS_CODE::OK) if(requestResult.statusCode == Framework::Http::HTTP_STATUS_CODE::OK)
{ {
auto myfile = std::fstream(path.c_str(), std::ios::out | std::ios::binary); auto outputStream = Framework::CreateOutputStdStream(path.native());
myfile.write(reinterpret_cast<char*>(requestResult.data.GetBuffer()), requestResult.data.GetSize()); outputStream.Write(requestResult.data.GetBuffer(), requestResult.data.GetSize());
myfile.close();
} }
} }
} }

12
Source/ui_shared/BootablesProcesses.h
View file

@ -1,13 +1,13 @@
#pragma once #pragma once
#include <boost/filesystem.hpp> #include "filesystem_def.h"
#include <set> #include <set>
bool IsBootableExecutablePath(const boost::filesystem::path&); bool IsBootableExecutablePath(const fs::path&);
bool IsBootableDiscImagePath(const boost::filesystem::path&); bool IsBootableDiscImagePath(const fs::path&);
void TryRegisteringBootable(const boost::filesystem::path&); void TryRegisteringBootable(const fs::path&);
void ScanBootables(const boost::filesystem::path&, bool = true); void ScanBootables(const fs::path&, bool = true);
std::set<boost::filesystem::path> GetActiveBootableDirectories(); std::set<fs::path> GetActiveBootableDirectories();
void PurgeInexistingFiles(); void PurgeInexistingFiles();
void FetchGameTitles(); void FetchGameTitles();
void FetchGameCovers(); void FetchGameCovers();