578 lines
11 KiB
C++
578 lines
11 KiB
C++
// Copyright (C) 2015 Jérôme Leclercq
|
|
// This file is part of the "Nazara Engine - Core module"
|
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
|
|
|
#include <Nazara/Core/File.hpp>
|
|
#include <Nazara/Core/AbstractHash.hpp>
|
|
#include <Nazara/Core/Config.hpp>
|
|
#include <Nazara/Core/Error.hpp>
|
|
#include <Nazara/Core/ErrorFlags.hpp>
|
|
#include <Nazara/Core/StringStream.hpp>
|
|
#include <cstring>
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
#if defined(NAZARA_PLATFORM_WINDOWS)
|
|
#include <Nazara/Core/Win32/FileImpl.hpp>
|
|
#elif defined(NAZARA_PLATFORM_POSIX)
|
|
#include <Nazara/Core/Posix/FileImpl.hpp>
|
|
#else
|
|
#error OS not handled
|
|
#endif
|
|
|
|
#if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_FILE
|
|
#include <Nazara/Core/ThreadSafety.hpp>
|
|
#else
|
|
#include <Nazara/Core/ThreadSafetyOff.hpp>
|
|
#endif
|
|
|
|
#include <Nazara/Core/Debug.hpp>
|
|
|
|
namespace Nz
|
|
{
|
|
File::File() :
|
|
Stream(OpenMode_Current),
|
|
m_impl(nullptr)
|
|
{
|
|
}
|
|
|
|
File::File(const String& filePath) :
|
|
File()
|
|
{
|
|
SetFile(filePath);
|
|
}
|
|
|
|
File::File(const String& filePath, UInt32 openMode) :
|
|
File()
|
|
{
|
|
Open(filePath, openMode);
|
|
}
|
|
|
|
File::File(File&& file) noexcept :
|
|
Stream(std::move(file)),
|
|
InputStream(std::move(file)),
|
|
OutputStream(std::move(file)),
|
|
m_filePath(std::move(file.m_filePath)),
|
|
m_impl(file.m_impl)
|
|
{
|
|
file.m_impl = nullptr;
|
|
}
|
|
|
|
File::~File()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
bool File::Copy(const String& newFilePath)
|
|
{
|
|
return Copy(m_filePath, newFilePath);
|
|
}
|
|
|
|
void File::Close()
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
if (m_impl)
|
|
{
|
|
m_impl->Close();
|
|
delete m_impl;
|
|
m_impl = nullptr;
|
|
}
|
|
}
|
|
|
|
bool File::Delete()
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
Close();
|
|
|
|
return Delete(m_filePath);
|
|
}
|
|
|
|
bool File::EndOfFile() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
#if NAZARA_CORE_SAFE
|
|
if (!IsOpen())
|
|
{
|
|
NazaraError("File not opened");
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
return m_impl->EndOfFile();
|
|
}
|
|
|
|
bool File::EndOfStream() const
|
|
{
|
|
return EndOfFile();
|
|
}
|
|
|
|
bool File::Exists() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
if (IsOpen())
|
|
return true; // Le fichier est ouvert, donc il existe
|
|
else
|
|
return Exists(m_filePath);
|
|
}
|
|
|
|
void File::Flush()
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
NazaraAssert(IsOpen(), "File is not open");
|
|
NazaraAssert(IsWritable(), "File not opened with write access");
|
|
|
|
m_impl->Flush();
|
|
}
|
|
|
|
time_t File::GetCreationTime() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return GetCreationTime(m_filePath);
|
|
}
|
|
|
|
UInt64 File::GetCursorPos() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
NazaraAssert(IsOpen(), "File is not opened");
|
|
|
|
return m_impl->GetCursorPos();
|
|
}
|
|
|
|
String File::GetDirectory() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return m_filePath.SubStringTo(NAZARA_DIRECTORY_SEPARATOR, -1, true, true);
|
|
}
|
|
|
|
String File::GetFileName() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return m_filePath.SubStringFrom(NAZARA_DIRECTORY_SEPARATOR, -1, true);
|
|
}
|
|
|
|
time_t File::GetLastAccessTime() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return GetLastAccessTime(m_filePath);
|
|
}
|
|
|
|
time_t File::GetLastWriteTime() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return GetLastWriteTime(m_filePath);
|
|
}
|
|
|
|
String File::GetPath() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return m_filePath;
|
|
}
|
|
|
|
UInt64 File::GetSize() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return GetSize(m_filePath);
|
|
}
|
|
|
|
bool File::IsOpen() const
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
return m_impl != nullptr;
|
|
}
|
|
|
|
std::size_t File::Read(void* buffer, std::size_t size)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
NazaraAssert(IsOpen(), "File is not opened");
|
|
NazaraAssert(IsReadable(), "File not opened with read access");
|
|
|
|
if (size == 0)
|
|
return 0;
|
|
|
|
if (buffer)
|
|
return m_impl->Read(buffer, size);
|
|
else
|
|
{
|
|
// Si nous ne devons rien lire, nous avançons simplement
|
|
UInt64 currentPos = m_impl->GetCursorPos();
|
|
|
|
m_impl->SetCursorPos(CursorPosition_AtCurrent, size);
|
|
|
|
return static_cast<std::size_t>(m_impl->GetCursorPos() - currentPos);
|
|
}
|
|
}
|
|
|
|
bool File::Rename(const String& newFilePath)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
bool opened = IsOpen();
|
|
Close();
|
|
|
|
bool success = Rename(m_filePath, newFilePath);
|
|
if (success)
|
|
m_filePath = NormalizePath(newFilePath);
|
|
|
|
if (opened)
|
|
Open();
|
|
|
|
return success;
|
|
}
|
|
|
|
bool File::Open(unsigned int openMode)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
Close();
|
|
|
|
if (m_filePath.IsEmpty())
|
|
return false;
|
|
|
|
if (openMode != 0)
|
|
m_openMode = openMode;
|
|
|
|
if (m_openMode == 0)
|
|
return false;
|
|
|
|
std::unique_ptr<FileImpl> impl(new FileImpl(this));
|
|
if (!impl->Open(m_filePath, m_openMode))
|
|
{
|
|
ErrorFlags flags(ErrorFlag_Silent); // Silencieux par défaut
|
|
NazaraError("Failed to open \"" + m_filePath + "\": " + Error::GetLastSystemError());
|
|
return false;
|
|
}
|
|
|
|
m_impl = impl.release();
|
|
|
|
if (m_openMode & OpenMode_Text)
|
|
m_streamOptions |= StreamOption_Text;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool File::Open(const String& filePath, unsigned int openMode)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
Close();
|
|
|
|
SetFile(filePath);
|
|
return Open(openMode);
|
|
}
|
|
|
|
bool File::SetCursorPos(CursorPosition pos, Int64 offset)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
NazaraAssert(IsOpen(), "File is not opened");
|
|
|
|
return m_impl->SetCursorPos(pos, offset);
|
|
}
|
|
|
|
bool File::SetCursorPos(UInt64 offset)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
NazaraAssert(IsOpen(), "File is not opened");
|
|
|
|
return m_impl->SetCursorPos(CursorPosition_AtBegin, offset);
|
|
}
|
|
|
|
bool File::SetFile(const String& filePath)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
if (IsOpen())
|
|
{
|
|
if (filePath.IsEmpty())
|
|
return false;
|
|
|
|
std::unique_ptr<FileImpl> impl(new FileImpl(this));
|
|
if (!impl->Open(filePath, m_openMode))
|
|
{
|
|
NazaraError("Failed to open new file; " + Error::GetLastSystemError());
|
|
return false;
|
|
}
|
|
|
|
m_impl->Close();
|
|
delete m_impl;
|
|
|
|
m_impl = impl.release();
|
|
}
|
|
|
|
m_filePath = AbsolutePath(filePath);
|
|
return true;
|
|
}
|
|
|
|
std::size_t File::Write(const void* buffer, std::size_t size)
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
NazaraAssert(IsOpen(), "File is not opened");
|
|
NazaraAssert(IsWritable(), "File not opened with write access");
|
|
|
|
if (size == 0)
|
|
return 0;
|
|
|
|
NazaraAssert(buffer, "Invalid buffer");
|
|
|
|
return m_impl->Write(buffer, size);
|
|
}
|
|
|
|
File& File::operator=(const String& filePath)
|
|
{
|
|
SetFile(filePath);
|
|
|
|
return *this;
|
|
}
|
|
|
|
File& File::operator=(File&& file) noexcept
|
|
{
|
|
NazaraLock(m_mutex)
|
|
|
|
std::swap(m_filePath, file.m_filePath);
|
|
std::swap(m_impl, file.m_impl);
|
|
|
|
return *this;
|
|
}
|
|
|
|
String File::AbsolutePath(const String& filePath)
|
|
{
|
|
// Je n'utilise pas les fonctions de l'OS car elles ne fonctionnent que pour un chemin existant
|
|
String path = NormalizePath(filePath);
|
|
if (path.IsEmpty())
|
|
return String();
|
|
|
|
String base;
|
|
unsigned int start;
|
|
#ifdef NAZARA_PLATFORM_WINDOWS
|
|
if (path.Match("?:*"))
|
|
start = 1;
|
|
else if (path.Match("\\\\*"))
|
|
{
|
|
base = "\\\\";
|
|
start = 2;
|
|
}
|
|
else if (path.StartsWith('\\')) // Spécial : '\' fait référence au disque racine
|
|
{
|
|
String drive = Directory::GetCurrent().SubStringTo('\\');
|
|
String end = path.SubString(1, -1);
|
|
if (end.IsEmpty())
|
|
path = drive;
|
|
else
|
|
path = drive + '\\' + end;
|
|
|
|
start = 1;
|
|
}
|
|
else
|
|
{
|
|
NazaraError("Path unrecognized");
|
|
return path;
|
|
}
|
|
#elif defined(NAZARA_PLATFORM_POSIX)
|
|
base = '/';
|
|
start = 0;
|
|
#else
|
|
#error OS case not implemented
|
|
#endif
|
|
|
|
static String upDir = NAZARA_DIRECTORY_SEPARATOR + String('.');
|
|
|
|
if (path.Find(upDir) == String::npos)
|
|
return path;
|
|
|
|
std::vector<String> sep;
|
|
if (path.Split(sep, NAZARA_DIRECTORY_SEPARATOR) <= 1)
|
|
return path;
|
|
|
|
// Nous avons un chemin absolu, mais il nous faut un peu le nettoyer
|
|
for (unsigned int i = 0; i < sep.size(); ++i)
|
|
{
|
|
if (sep[i] == '.')
|
|
sep.erase(sep.begin() + i--);
|
|
else if (sep[i] == "..")
|
|
{
|
|
if (i > start) // Si nous ne sommes pas dans la partie protégée
|
|
sep.erase(sep.begin() + i--);
|
|
|
|
sep.erase(sep.begin() + i--);
|
|
}
|
|
}
|
|
|
|
StringStream stream(base);
|
|
for (unsigned int i = 0; i < sep.size(); ++i)
|
|
{
|
|
if (i != sep.size()-1)
|
|
stream << sep[i] << NAZARA_DIRECTORY_SEPARATOR;
|
|
else
|
|
stream << sep[i];
|
|
}
|
|
|
|
return stream;
|
|
}
|
|
|
|
bool File::Copy(const String& sourcePath, const String& targetPath)
|
|
{
|
|
if (sourcePath.IsEmpty() || targetPath.IsEmpty())
|
|
return false;
|
|
|
|
return FileImpl::Copy(NormalizePath(sourcePath), NormalizePath(targetPath));
|
|
}
|
|
|
|
bool File::Delete(const String& filePath)
|
|
{
|
|
if (filePath.IsEmpty())
|
|
return false;
|
|
|
|
return FileImpl::Delete(NormalizePath(filePath));
|
|
}
|
|
|
|
bool File::Exists(const String& filePath)
|
|
{
|
|
if (filePath.IsEmpty())
|
|
return false;
|
|
|
|
return FileImpl::Exists(NormalizePath(filePath));
|
|
}
|
|
|
|
time_t File::GetCreationTime(const String& filePath)
|
|
{
|
|
if (filePath.IsEmpty())
|
|
return 0;
|
|
|
|
return FileImpl::GetCreationTime(NormalizePath(filePath));
|
|
}
|
|
|
|
String File::GetDirectory(const String& filePath)
|
|
{
|
|
return filePath.SubStringTo(NAZARA_DIRECTORY_SEPARATOR, -1, true, true);
|
|
}
|
|
|
|
time_t File::GetLastAccessTime(const String& filePath)
|
|
{
|
|
if (filePath.IsEmpty())
|
|
return 0;
|
|
|
|
return FileImpl::GetLastAccessTime(NormalizePath(filePath));
|
|
}
|
|
|
|
time_t File::GetLastWriteTime(const String& filePath)
|
|
{
|
|
if (filePath.IsEmpty())
|
|
return 0;
|
|
|
|
return FileImpl::GetLastWriteTime(NormalizePath(filePath));
|
|
}
|
|
|
|
UInt64 File::GetSize(const String& filePath)
|
|
{
|
|
if (filePath.IsEmpty())
|
|
return 0;
|
|
|
|
return FileImpl::GetSize(NormalizePath(filePath));
|
|
}
|
|
|
|
bool File::IsAbsolute(const String& filePath)
|
|
{
|
|
String path(filePath.Trimmed());
|
|
if (path.IsEmpty())
|
|
return false;
|
|
|
|
path = NormalizeSeparators(path);
|
|
|
|
#ifdef NAZARA_PLATFORM_WINDOWS
|
|
if (path.Match("?:*")) // Ex: C:\Hello
|
|
return true;
|
|
else if (path.Match("\\\\*")) // Ex: \\Laptop
|
|
return true;
|
|
else if (path.StartsWith('\\')) // Spécial : '\' fait référence au disque racine
|
|
return true;
|
|
else
|
|
return false;
|
|
#elif defined(NAZARA_PLATFORM_POSIX)
|
|
return path.StartsWith('/');
|
|
#else
|
|
#error OS case not implemented
|
|
#endif
|
|
}
|
|
|
|
String File::NormalizePath(const String& filePath)
|
|
{
|
|
String path = NormalizeSeparators(filePath.Trimmed());
|
|
|
|
if (!IsAbsolute(path))
|
|
path = Directory::GetCurrent() + NAZARA_DIRECTORY_SEPARATOR + path;
|
|
|
|
while (path.EndsWith(NAZARA_DIRECTORY_SEPARATOR))
|
|
path.Resize(-1);
|
|
|
|
return path;
|
|
}
|
|
|
|
String File::NormalizeSeparators(const String& filePath)
|
|
{
|
|
String path(filePath);
|
|
|
|
#if defined(NAZARA_PLATFORM_WINDOWS)
|
|
path.Replace('/', '\\');
|
|
#elif defined(NAZARA_PLATFORM_LINUX)
|
|
path.Replace('\\', '/');
|
|
#else
|
|
#error OS case not implemented
|
|
#endif
|
|
|
|
return path;
|
|
}
|
|
|
|
bool File::Rename(const String& sourcePath, const String& targetPath)
|
|
{
|
|
if (sourcePath.IsEmpty() || targetPath.IsEmpty())
|
|
return false;
|
|
|
|
return FileImpl::Rename(NormalizePath(sourcePath), NormalizePath(targetPath));
|
|
}
|
|
|
|
NAZARA_CORE_API bool HashAppend(AbstractHash* hash, const File& originalFile)
|
|
{
|
|
File file(originalFile.GetPath());
|
|
if (!file.Open(OpenMode_ReadOnly))
|
|
{
|
|
NazaraError("Unable to open file");
|
|
return false;
|
|
}
|
|
|
|
UInt64 remainingSize = file.GetSize();
|
|
|
|
char buffer[NAZARA_CORE_FILE_BUFFERSIZE];
|
|
while (remainingSize > 0)
|
|
{
|
|
std::size_t size = std::min<std::size_t>(static_cast<std::size_t>(remainingSize), NAZARA_CORE_FILE_BUFFERSIZE);
|
|
if (file.Read(&buffer[0], size) != size)
|
|
{
|
|
NazaraError("Unable to read file");
|
|
return false;
|
|
}
|
|
|
|
remainingSize -= size;
|
|
hash->Append(reinterpret_cast<UInt8*>(&buffer[0]), size);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
}
|