2019-11-23 20:27:39 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2010-2012 cocos2d-x.org
|
|
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
2022-04-28 11:43:59 +08:00
|
|
|
Copyright (c) 2021-2022 Bytedance Inc.
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-10-01 16:24:52 +08:00
|
|
|
https://axmolengine.github.io/
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
2023-06-11 13:08:08 +08:00
|
|
|
#include "platform/win32/FileUtils-win32.h"
|
|
|
|
#include "platform/Common.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
#include <Shlobj.h>
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <regex>
|
|
|
|
#include <sstream>
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-11-26 17:19:50 +08:00
|
|
|
#include "ntcvt/ntcvt.hpp"
|
2020-07-10 16:56:18 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
#define DECLARE_GUARD (void)0 // std::lock_guard<std::recursive_mutex> mutexGuard(_mutex)
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_BEGIN
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-04-28 12:00:32 +08:00
|
|
|
#define AX_MAX_PATH 512
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2023-08-09 13:52:28 +08:00
|
|
|
// The root path of resources, the character encoding is UTF-8.
|
|
|
|
// UTF-8 is the only encoding supported by axmol API by default.
|
|
|
|
static std::string s_workingDir;
|
|
|
|
static std::string s_exeDir;
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// D:\aaa\bbb\ccc\ddd\abc.txt --> D:/aaa/bbb/ccc/ddd/abc.txt
|
2022-04-28 11:43:59 +08:00
|
|
|
static std::string convertPathFormatToUnixStyle(const std::string_view& path)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string ret{path};
|
2022-04-28 11:43:59 +08:00
|
|
|
std::replace(ret.begin(), ret.end(), '\\', '/');
|
2019-11-23 20:27:39 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-04-28 11:43:59 +08:00
|
|
|
static std::string convertPathFormatToWinStyle(const std::string_view& path)
|
2021-12-31 12:12:40 +08:00
|
|
|
{
|
|
|
|
std::string ret{path};
|
2022-04-28 11:43:59 +08:00
|
|
|
std::replace(ret.begin(), ret.end(), '/', '\\');
|
2021-12-31 12:12:40 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-08-09 13:52:28 +08:00
|
|
|
static void _checkWorkingPath()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2023-08-09 13:52:28 +08:00
|
|
|
if (s_workingDir.empty())
|
|
|
|
{
|
|
|
|
WCHAR utf16Path[AX_MAX_PATH + 2] = {0};
|
|
|
|
size_t nNum = GetCurrentDirectoryW(AX_MAX_PATH, utf16Path);
|
|
|
|
utf16Path[nNum++] = '\\';
|
|
|
|
s_workingDir = ntcvt::from_chars(std::wstring_view{utf16Path, static_cast<size_t>(nNum)});
|
|
|
|
std::replace(s_workingDir.begin(), s_workingDir.end(), '\\', '/');
|
|
|
|
}
|
2021-10-07 18:44:34 +08:00
|
|
|
}
|
|
|
|
|
2023-08-09 13:52:28 +08:00
|
|
|
static void _checkExePath()
|
2021-10-07 18:44:34 +08:00
|
|
|
{
|
2023-08-09 13:52:28 +08:00
|
|
|
if (s_exeDir.empty())
|
|
|
|
{
|
|
|
|
WCHAR utf16Path[AX_MAX_PATH + 1] = {0};
|
|
|
|
size_t nNum = GetModuleFileNameW(NULL, utf16Path, AX_MAX_PATH);
|
|
|
|
std::wstring_view u16pathsv{utf16Path, nNum};
|
|
|
|
u16pathsv.remove_suffix(u16pathsv.length() - u16pathsv.find_last_of('\\') - 1);
|
|
|
|
s_exeDir = ntcvt::from_chars(u16pathsv);
|
|
|
|
std::replace(s_exeDir.begin(), s_exeDir.end(), '\\', '/');
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
FileUtils* FileUtils::getInstance()
|
|
|
|
{
|
|
|
|
if (s_sharedFileUtils == nullptr)
|
|
|
|
{
|
|
|
|
s_sharedFileUtils = new FileUtilsWin32();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!s_sharedFileUtils->init())
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
delete s_sharedFileUtils;
|
|
|
|
s_sharedFileUtils = nullptr;
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOG("ERROR: Could not init CCFileUtilsWin32");
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return s_sharedFileUtils;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
FileUtilsWin32::FileUtilsWin32() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
bool FileUtilsWin32::init()
|
|
|
|
{
|
2023-08-09 13:52:28 +08:00
|
|
|
_checkWorkingPath();
|
|
|
|
_checkExePath();
|
2021-10-07 18:44:34 +08:00
|
|
|
|
2023-08-09 13:52:28 +08:00
|
|
|
bool startedFromSelfLocation = s_workingDir == s_exeDir;
|
2023-02-23 21:57:30 +08:00
|
|
|
if (!startedFromSelfLocation || !isDirectoryExistInternal(AX_CONTENT_DIR))
|
2023-08-09 13:52:28 +08:00
|
|
|
_defaultResRootPath = s_workingDir;
|
2022-04-28 11:43:59 +08:00
|
|
|
else
|
2022-04-28 12:00:32 +08:00
|
|
|
{
|
2023-02-23 21:57:30 +08:00
|
|
|
_defaultResRootPath.reserve(s_exeDir.size() + AX_CONTENT_DIR_LEN);
|
|
|
|
_defaultResRootPath.append(s_exeDir).append(AX_CONTENT_DIR, AX_CONTENT_DIR_LEN);
|
2022-04-28 12:00:32 +08:00
|
|
|
}
|
2021-10-07 18:44:34 +08:00
|
|
|
|
2022-04-28 11:43:59 +08:00
|
|
|
bool bRet = FileUtils::init();
|
2021-10-07 18:44:34 +08:00
|
|
|
|
2022-04-28 11:43:59 +08:00
|
|
|
// make sure any path relative to exe dir can be found when app working directory location not exe path
|
|
|
|
if (!startedFromSelfLocation)
|
2022-04-28 12:00:32 +08:00
|
|
|
addSearchPath(s_exeDir);
|
2021-10-07 18:44:34 +08:00
|
|
|
|
|
|
|
return bRet;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool FileUtilsWin32::isDirectoryExistInternal(std::string_view dirPath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-09-05 20:45:32 +08:00
|
|
|
uint32_t fAttrib = GetFileAttributesW(ntcvt::from_chars(dirPath).c_str());
|
2021-12-25 10:04:45 +08:00
|
|
|
return (fAttrib != INVALID_FILE_ATTRIBUTES && (fAttrib & FILE_ATTRIBUTE_DIRECTORY));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool FileUtilsWin32::isFileExistInternal(std::string_view strFilePath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-04-28 11:43:59 +08:00
|
|
|
DWORD attr = GetFileAttributesW(ntcvt::from_chars(strFilePath).c_str());
|
2019-11-27 14:34:40 +08:00
|
|
|
return (attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
FileUtils::Status FileUtilsWin32::getContents(std::string_view filename, ResizableBuffer* buffer) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (filename.empty())
|
|
|
|
return FileUtils::Status::NotExists;
|
|
|
|
|
|
|
|
// read the file from hardware
|
|
|
|
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(filename);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
HANDLE fileHandle = ::CreateFileW(ntcvt::from_chars(fullPath).c_str(), GENERIC_READ,
|
2023-08-09 13:52:28 +08:00
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
if (fileHandle == INVALID_HANDLE_VALUE)
|
|
|
|
return FileUtils::Status::OpenFailed;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
DWORD hi;
|
2019-11-23 20:27:39 +08:00
|
|
|
auto size = ::GetFileSize(fileHandle, &hi);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (hi > 0)
|
|
|
|
{
|
|
|
|
::CloseHandle(fileHandle);
|
|
|
|
return FileUtils::Status::TooLarge;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
// don't read file content if it is empty
|
|
|
|
if (size == 0)
|
|
|
|
{
|
|
|
|
::CloseHandle(fileHandle);
|
|
|
|
return FileUtils::Status::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
buffer->resize(size);
|
|
|
|
DWORD sizeRead = 0;
|
|
|
|
BOOL successed = ::ReadFile(fileHandle, buffer->buffer(), size, &sizeRead, nullptr);
|
|
|
|
::CloseHandle(fileHandle);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!successed)
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOG("Get data from file(%s) failed, error code is %s", filename.data(),
|
2021-12-25 10:04:45 +08:00
|
|
|
std::to_string(::GetLastError()).data());
|
|
|
|
buffer->resize(sizeRead);
|
|
|
|
return FileUtils::Status::ReadFailed;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
return FileUtils::Status::OK;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string FileUtilsWin32::getPathForFilename(std::string_view filename,
|
|
|
|
std::string_view searchPath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
std::string unixFileName = convertPathFormatToUnixStyle(filename);
|
|
|
|
std::string unixSearchPath = convertPathFormatToUnixStyle(searchPath);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-11-01 06:47:36 +08:00
|
|
|
return FileUtils::getPathForFilename(unixFileName, unixSearchPath);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string FileUtilsWin32::getFullPathForFilenameWithinDirectory(std::string_view strDirectory,
|
|
|
|
std::string_view strFilename) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
std::string unixDirectory = convertPathFormatToUnixStyle(strDirectory);
|
2021-12-25 10:04:45 +08:00
|
|
|
std::string unixFilename = convertPathFormatToUnixStyle(strFilename);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
return FileUtils::getFullPathForFilenameWithinDirectory(unixDirectory, unixFilename);
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
int64_t FileUtilsWin32::getFileSize(std::string_view filepath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2019-11-27 15:09:45 +08:00
|
|
|
if (filepath.empty())
|
|
|
|
return -1;
|
2021-12-25 10:04:45 +08:00
|
|
|
WIN32_FILE_ATTRIBUTE_DATA attrs = {0};
|
2020-08-05 12:24:31 +08:00
|
|
|
if (GetFileAttributesExW(ntcvt::from_chars(filepath).c_str(), GetFileExInfoStandard, &attrs) &&
|
2019-11-27 15:09:45 +08:00
|
|
|
!(attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
2021-12-25 10:04:45 +08:00
|
|
|
return static_cast<long long>(attrs.nFileSizeHigh) << 32 | static_cast<unsigned long long>(attrs.nFileSizeLow);
|
2019-11-27 15:09:45 +08:00
|
|
|
return -1;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-07-04 21:21:29 +08:00
|
|
|
std::string FileUtilsWin32::getWritablePath() const
|
2021-04-22 23:00:00 +08:00
|
|
|
{
|
|
|
|
DECLARE_GUARD;
|
|
|
|
return getNativeWritableAbsolutePath();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string FileUtilsWin32::getNativeWritableAbsolutePath() const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
DECLARE_GUARD;
|
|
|
|
if (_writablePath.length())
|
|
|
|
{
|
|
|
|
return _writablePath;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get full path of executable, e.g. c:\Program Files (x86)\My Game Folder\MyGame.exe
|
2022-04-28 12:00:32 +08:00
|
|
|
WCHAR full_path[AX_MAX_PATH + 1] = {0};
|
|
|
|
::GetModuleFileNameW(nullptr, full_path, AX_MAX_PATH + 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// Debug app uses executable directory; Non-debug app uses local app data directory
|
2021-12-25 10:04:45 +08:00
|
|
|
//#ifndef _DEBUG
|
2019-11-23 20:27:39 +08:00
|
|
|
// Get filename of executable only, e.g. MyGame.exe
|
2021-04-22 23:00:00 +08:00
|
|
|
WCHAR* base_name = wcsrchr(full_path, '\\');
|
2021-07-04 21:21:29 +08:00
|
|
|
std::wstring retPath;
|
2021-04-22 23:00:00 +08:00
|
|
|
if (base_name)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-04-28 12:00:32 +08:00
|
|
|
WCHAR app_data_path[AX_MAX_PATH + 1];
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// Get local app data directory, e.g. C:\Documents and Settings\username\Local Settings\Application Data
|
2020-07-10 16:56:18 +08:00
|
|
|
if (SUCCEEDED(SHGetFolderPathW(nullptr, CSIDL_LOCAL_APPDATA, nullptr, SHGFP_TYPE_CURRENT, app_data_path)))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-07-04 21:21:29 +08:00
|
|
|
std::wstring ret(app_data_path);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// Adding executable filename, e.g. C:\Documents and Settings\username\Local Settings\Application
|
|
|
|
// Data\MyGame.exe
|
2019-11-23 20:27:39 +08:00
|
|
|
ret += base_name;
|
|
|
|
|
|
|
|
// Remove ".exe" extension, e.g. C:\Documents and Settings\username\Local Settings\Application Data\MyGame
|
|
|
|
ret = ret.substr(0, ret.rfind(L"."));
|
|
|
|
|
|
|
|
ret += L"\\";
|
|
|
|
|
|
|
|
// Create directory
|
2020-07-10 16:56:18 +08:00
|
|
|
if (SUCCEEDED(SHCreateDirectoryExW(nullptr, ret.c_str(), nullptr)))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
retPath = ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (retPath.empty())
|
2021-12-25 10:04:45 +08:00
|
|
|
//#endif // not defined _DEBUG
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// If fetching of local app data directory fails, use the executable one
|
|
|
|
retPath = full_path;
|
|
|
|
|
|
|
|
// remove xxx.exe
|
|
|
|
retPath = retPath.substr(0, retPath.rfind(L"\\") + 1);
|
|
|
|
}
|
|
|
|
|
2020-07-10 16:56:18 +08:00
|
|
|
return convertPathFormatToUnixStyle(ntcvt::from_chars(retPath));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool FileUtilsWin32::renameFile(std::string_view oldfullpath, std::string_view newfullpath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(!oldfullpath.empty(), "Invalid path");
|
|
|
|
AXASSERT(!newfullpath.empty(), "Invalid path");
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2020-07-10 16:56:18 +08:00
|
|
|
std::wstring _wNew = ntcvt::from_chars(newfullpath);
|
|
|
|
std::wstring _wOld = ntcvt::from_chars(oldfullpath);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (FileUtils::getInstance()->isFileExist(newfullpath))
|
|
|
|
{
|
|
|
|
if (!DeleteFile(_wNew.c_str()))
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOGERROR("Fail to delete file %s !Error code is 0x%x", newfullpath.data(), GetLastError());
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-10 16:56:18 +08:00
|
|
|
if (MoveFileW(_wOld.c_str(), _wNew.c_str()))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOGERROR("Fail to rename file %s to %s !Error code is 0x%x", oldfullpath.data(), newfullpath.data(),
|
2021-12-25 10:04:45 +08:00
|
|
|
GetLastError());
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool FileUtilsWin32::renameFile(std::string_view path, std::string_view oldname, std::string_view name) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(!path.empty(), "Invalid path");
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string oldPath{path};
|
|
|
|
oldPath += oldname;
|
|
|
|
std::string newPath{path};
|
|
|
|
newPath += name;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
std::regex pat("\\/");
|
|
|
|
std::string _old = std::regex_replace(oldPath, pat, "\\");
|
|
|
|
std::string _new = std::regex_replace(newPath, pat, "\\");
|
|
|
|
|
|
|
|
return renameFile(_old, _new);
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool FileUtilsWin32::createDirectory(std::string_view dirPath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(!dirPath.empty(), "Invalid path");
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (isDirectoryExist(dirPath))
|
|
|
|
return true;
|
|
|
|
|
2020-07-10 16:56:18 +08:00
|
|
|
std::wstring path = ntcvt::from_chars(dirPath);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// Split the path
|
|
|
|
size_t start = 0;
|
|
|
|
size_t found = path.find_first_of(L"/\\", start);
|
|
|
|
std::wstring subpath;
|
|
|
|
std::vector<std::wstring> dirs;
|
|
|
|
|
|
|
|
if (found != std::wstring::npos)
|
|
|
|
{
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
subpath = path.substr(start, found - start + 1);
|
|
|
|
if (!subpath.empty())
|
2022-08-08 13:18:33 +08:00
|
|
|
dirs.emplace_back(subpath);
|
2019-11-23 20:27:39 +08:00
|
|
|
start = found + 1;
|
|
|
|
found = path.find_first_of(L"/\\", start);
|
|
|
|
if (found == std::wstring::npos)
|
|
|
|
{
|
|
|
|
if (start < path.length())
|
|
|
|
{
|
2022-08-08 13:18:33 +08:00
|
|
|
dirs.emplace_back(path.substr(start));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-10 16:56:18 +08:00
|
|
|
if ((GetFileAttributesW(path.c_str())) == INVALID_FILE_ATTRIBUTES)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
subpath = L"";
|
|
|
|
for (unsigned int i = 0, size = dirs.size(); i < size; ++i)
|
|
|
|
{
|
|
|
|
subpath += dirs[i];
|
|
|
|
|
2020-07-10 16:56:18 +08:00
|
|
|
std::string utf8Path = ntcvt::from_chars(subpath);
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!isDirectoryExist(utf8Path))
|
|
|
|
{
|
2020-07-10 16:56:18 +08:00
|
|
|
BOOL ret = CreateDirectoryW(subpath.c_str(), NULL);
|
2019-11-23 20:27:39 +08:00
|
|
|
if (!ret && ERROR_ALREADY_EXISTS != GetLastError())
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOGERROR("Fail create directory %s !Error code is 0x%x", utf8Path.c_str(), GetLastError());
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool FileUtilsWin32::removeFile(std::string_view filepath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string win32path = convertPathFormatToWinStyle(filepath);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2020-07-10 16:56:18 +08:00
|
|
|
if (DeleteFileW(ntcvt::from_chars(win32path).c_str()))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOGERROR("Fail remove file %s !Error code is 0x%x", filepath.data(), GetLastError());
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool FileUtilsWin32::removeDirectory(std::string_view dirPath) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string dirPathCopy{dirPath};
|
2020-08-18 14:29:09 +08:00
|
|
|
if (!dirPath.empty() && dirPath[dirPath.length() - 1] != '/' && dirPath[dirPath.length() - 1] != '\\')
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2019-11-25 17:10:25 +08:00
|
|
|
dirPathCopy.push_back('/');
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2020-07-10 16:56:18 +08:00
|
|
|
std::wstring wpath = ntcvt::from_chars(dirPathCopy);
|
2019-11-23 20:27:39 +08:00
|
|
|
std::wstring files = wpath + L"*.*";
|
|
|
|
WIN32_FIND_DATA wfd;
|
2021-12-25 10:04:45 +08:00
|
|
|
HANDLE search = FindFirstFileEx(files.c_str(), FindExInfoStandard, &wfd, FindExSearchNameMatch, NULL, 0);
|
|
|
|
bool ret = true;
|
2019-11-23 20:27:39 +08:00
|
|
|
if (search != INVALID_HANDLE_VALUE)
|
|
|
|
{
|
|
|
|
BOOL find = true;
|
|
|
|
while (find)
|
|
|
|
{
|
|
|
|
// Need check string . and .. for delete folders and files begin name.
|
|
|
|
std::wstring fileName = wfd.cFileName;
|
|
|
|
if (fileName != L"." && fileName != L"..")
|
|
|
|
{
|
|
|
|
std::wstring temp = wpath + wfd.cFileName;
|
|
|
|
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
|
{
|
|
|
|
temp += '/';
|
2020-07-10 16:56:18 +08:00
|
|
|
ret = ret && this->removeDirectory(ntcvt::from_chars(temp));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-07-10 16:56:18 +08:00
|
|
|
SetFileAttributesW(temp.c_str(), FILE_ATTRIBUTE_NORMAL);
|
|
|
|
ret = ret && DeleteFileW(temp.c_str());
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
find = FindNextFile(search, &wfd);
|
|
|
|
}
|
|
|
|
FindClose(search);
|
|
|
|
}
|
2020-07-10 16:56:18 +08:00
|
|
|
if (ret && RemoveDirectoryW(wpath.c_str()))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_END
|