FileSystem.cpp

/*********************************************************************** Author: Zihan Chen (vczh) Licensed under https://github.com/vczh-libraries/License ***********************************************************************/

#include "FileSystem.h"

#include "Locale.h"

#include "Stream/FileStream.h"

#include "Stream/Accessor.h"

#if defined VCZH_MSVC

#include <Windows.h> #include <Shlwapi.h>

#pragma comment(lib,

"Shlwapi.lib"

)

#elif defined VCZH_GCC

#include <sys/stat.h>

#include <dirent.h>

#include <unistd.h> #endif

namespace

{

namespace

filesystem

{

using

namespace

collections

;

using

namespace

stream

;

// ReadDirectoryChangesW

/*********************************************************************** FilePath ***********************************************************************/

#if defined VCZH_GCC

const wchar_t FilePath::Delimiter; #endif

void

FilePath

Initialize

() { {

Array

wchar_t

buffer

(

fullPath

Length

() +

);

#if defined VCZH_MSVC

wcscpy_s

buffer

[

fullPath

Length

() +

fullPath

Buffer

());

#elif defined VCZH_GCC

wcscpy(&buffer[0], fullPath.Buffer()); #endif

for

(

vint

;

buffer

Count

();

++) {

(

buffer

[

] ==

L'\\'

buffer

[

] ==

L'/'

) {

buffer

[

] =

Delimiter

; } }

fullPath

= &

buffer

[

]; }

#if defined VCZH_MSVC

(

fullPath

L""

) {

(

fullPath

Length

() <

fullPath

[

] !=

L':'

) {

wchar_t buffer[MAX_PATH + 1] = { 0 };

wchar_t

buffer

[

260

] = {

};

auto result = GetCurrentDirectory(sizeof(buffer) / sizeof(*buffer), buffer);

auto

result

GetCurrentDirectoryW

(

sizeof

(

buffer

) /

sizeof

buffer

);

if (result > MAX_PATH + 1 || result == 0)

(

result

260

result

)

{

throw

ArgumentException

(

L"Failed to call GetCurrentDirectory."

L"vl::filesystem::FilePath::Initialize"

L""

); }

fullPath

WString

(

buffer

) +

L"\\"

fullPath

; } {

wchar_t buffer[MAX_PATH + 1] = { 0 };

wchar_t

buffer

[

260

] = {

};

(

fullPath

Length

() ==

fullPath

[

] ==

L':'

) {

fullPath

L"\\"

; }

auto result = GetFullPathName(fullPath.Buffer(), sizeof(buffer) / sizeof(*buffer), buffer, NULL);

auto

result

GetFullPathNameW

(

fullPath

Buffer

(),

sizeof

(

buffer

) /

sizeof

buffer

);

if (result > MAX_PATH + 1 || result == 0)

(

result

260

result

)

{

throw

ArgumentException

(

L"The path is illegal."

L"vl::filesystem::FilePath::FilePath"

L"_filePath"

); } {

wchar_t shortPath[MAX_PATH + 1];

wchar_t

shortPath

[

260

];

wchar_t longPath[MAX_PATH + 1];

wchar_t

longPath

[

260

];

if (GetShortPathName(buffer, shortPath, MAX_PATH) > 0)

(

GetShortPathNameW

(

buffer

shortPath

260

) >

)

{

if (GetLongPathName(shortPath, longPath, MAX_PATH) > 0)

(

GetLongPathNameW

(

shortPath

longPath

260

) >

)

{

memcpy

(

buffer

longPath

sizeof

(

buffer

)); } } }

fullPath

buffer

; } }

#elif defined VCZH_GCC

if (fullPath.Length() == 0)

fullPath = L"/";

if (fullPath[0] != Delimiter)

{

char buffer[PATH_MAX] = { 0 };

getcwd(buffer, PATH_MAX);

fullPath = atow(AString(buffer)) + Delimiter + fullPath;

}

{

collections::List<WString> components;

GetPathComponents(fullPath, components);

for(int i = 0; i < components.Count(); i++)

{

if(components[i] == L".")

{

components.RemoveAt(i);

i--;

}

else if(components[i] == L"..")

{

if(i > 0)

{

components.RemoveAt(i);

components.RemoveAt(i - 1);

i -= 2;

}

else

{

throw ArgumentException(L"Illegal path.");

}

fullPath = ComponentsToPath(components);

} #endif

(

fullPath

L"/"

fullPath

Length

() >

fullPath

[

fullPath

Length

() -

] ==

Delimiter

) {

fullPath

Left

(

fullPath

Length

() -

); } }

FilePath

() { }

FilePath

(

const

WString

_filePath

) :fullPath(

_filePath

) {

Initialize

(); }

FilePath

(

const

wchar_t

_filePath

) :fullPath(

_filePath

) {

Initialize

(); }

FilePath

(

const

FilePath

_filePath

) :fullPath(

_filePath

fullPath

) { }

FilePath

() { }

vint

FilePath

Compare

(

const

FilePath

const

FilePath

) {

return

WString

Compare

(

fullPath

); }

FilePath

operator

(

const

WString

relativePath

)

const

{

(

IsRoot

()) {

return

relativePath

; }

else

{

return

fullPath

L"/"

relativePath

; } }

bool

FilePath

IsFile

()

const

{

#if defined VCZH_MSVC

WIN32_FILE_ATTRIBUTE_DATA

info

;

BOOL result = GetFileAttributesEx(fullPath.Buffer(), GetFileExInfoStandard, &info);

BOOL

result

GetFileAttributesExW

(

fullPath

Buffer

(),

GetFileExInfoStandard

, &

info

);

result

)

return

false

;

return (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0;

return

(

info

dwFileAttributes

0x00000010

) ==

;

#elif defined VCZH_GCC

struct stat info;

AString path = wtoa(fullPath);

int result = stat(path.Buffer(), &info);

if(result != 0) return false;

else return S_ISREG(info.st_mode); #endif

}

bool

FilePath

IsFolder

()

const

{

#if defined VCZH_MSVC

WIN32_FILE_ATTRIBUTE_DATA

info

;

BOOL result = GetFileAttributesEx(fullPath.Buffer(), GetFileExInfoStandard, &info);

BOOL

result

GetFileAttributesExW

(

fullPath

Buffer

(),

GetFileExInfoStandard

, &

info

);

result

)

return

false

;

return (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;

return

(

info

dwFileAttributes

0x00000010

) !=

;

#elif defined VCZH_GCC

struct stat info;

AString path = wtoa(fullPath);

int result = stat(path.Buffer(), &info);

if(result != 0) return false;

else return S_ISDIR(info.st_mode); #endif

}

bool

FilePath

IsRoot

()

const

{

#if defined VCZH_MSVC

return

fullPath

L""

;

#elif defined VCZH_GCC

return fullPath == L"/"; #endif

}

WString

FilePath

GetName

()

const

{

WString

delimiter

Delimiter

;

auto index = INVLOC.FindLast(fullPath, delimiter, Locale::None);

auto

index

Locale

Invariant

().

FindLast

(

fullPath

delimiter

Locale

None

);

(

index

key

== -

)

return

fullPath

;

return

fullPath

Right

(

fullPath

Length

() -

index

key

); }

FilePath

GetFolder

()

const

{

WString

delimiter

Delimiter

;

auto index = INVLOC.FindLast(fullPath, delimiter, Locale::None);

auto

index

Locale

Invariant

().

FindLast

(

fullPath

delimiter

Locale

None

);

(

index

key

== -

)

return

FilePath

();

return

fullPath

Left

(

index

key

); }

WString

FilePath

GetFullPath

()

const

{

return

fullPath

; }

WString

FilePath

GetRelativePathFor

(

const

FilePath

_filePath

) {

(

fullPath

Length

()==

_filePath

fullPath

Length

()==

fullPath

[

] !=

_filePath

fullPath

[

]) {

return

_filePath

fullPath

; }

#if defined VCZH_MSVC

wchar_t buffer[MAX_PATH + 1] = { 0 };

wchar_t

buffer

[

260

] = {

};

PathRelativePathTo(

PathRelativePathToW

(

buffer

fullPath

Buffer

(),

(IsFolder() ? FILE_ATTRIBUTE_DIRECTORY : 0),

(

IsFolder

() ?

0x00000010

_filePath

fullPath

Buffer

(),

(_filePath.IsFolder() ? FILE_ATTRIBUTE_DIRECTORY : 0)

(

_filePath

IsFolder

() ?

0x00000010

)

);

return

buffer

;

#elif defined VCZH_GCC

collections::List<WString> srcComponents, tgtComponents, resultComponents;

GetPathComponents(IsFolder() ? fullPath : GetFolder().GetFullPath(), srcComponents);

GetPathComponents(_filePath.fullPath, tgtComponents);

int minLength = srcComponents.Count() <= tgtComponents.Count() ? srcComponents.Count() : tgtComponents.Count();

int lastCommonComponent = 0;

for(int i = 0; i < minLength; i++)

{

if(srcComponents[i] == tgtComponents[i])

{

lastCommonComponent = i;

}

else

break;

}

for(int i = lastCommonComponent + 1; i < srcComponents.Count(); i++)

{

resultComponents.Add(L"..");

}

for(int i = lastCommonComponent + 1; i < tgtComponents.Count(); i++)

{

resultComponents.Add(tgtComponents[i]);

}

return ComponentsToPath(resultComponents); #endif

}

void

FilePath

GetPathComponents

(

WString

path

collections

List

WString

components

) {

WString

pathRemaining

path

;

WString

delimiter

Delimiter

;

components

Clear

();

while

(

true

) {

auto index = INVLOC.FindFirst(pathRemaining, delimiter, Locale::None);

auto

index

Locale

Invariant

().

FindFirst

(

pathRemaining

delimiter

Locale

None

);

(

index

key

== -

)

break

;

(

index

key

)

components

Add

(

pathRemaining

Left

(

index

key

));

else

{

#if defined VCZH_GCC

// Unix absolute path starting with "/"

// components[0] will be L"/"

components.Add(delimiter); #elif defined VCZH_MSVC

(

pathRemaining

Length

() >=

pathRemaining

[

] ==

Delimiter

) {

// Windows UNC Path starting with "\\"

// components[0] will be L"\\"

components

Add

(

L"\\"

);

index

value

++; }

#endif

}

pathRemaining

Right

(

pathRemaining

Length

() - (

index

key

index

value

)); }

(

pathRemaining

Length

() !=

) {

components

Add

(

pathRemaining

); } }

WString

FilePath

ComponentsToPath

(

const

collections

List

WString

components

) {

WString

result

;

WString

delimiter

Delimiter

;

int

;

#if defined VCZH_GCC

// For Unix-like OSes, if first component is "/" then take it as absolute path

if(components.Count() > 0 && components[0] == delimiter)

{

result += delimiter;

i++;

} #elif defined VCZH_MSVC

// For Windows, if first component is "\\" then it is an UNC path

(

components

Count

() >

components

[

] ==

L"\\"

) {

result

delimiter

;

++; }

#endif

for

(;

components

Count

();

++) {

result

components

[

];

(

components

Count

())

result

delimiter

; }

return

result

; }

/*********************************************************************** File ***********************************************************************/

File

() { }

File

(

const

FilePath

_filePath

) :filePath(

_filePath

) { }

File

() { }

const

FilePath

File

GetFilePath

()

const

{

return

filePath

; }

bool

File

ReadAllTextWithEncodingTesting

(

WString

text

stream

BomEncoder

Encoding

encoding

bool

containsBom

) {

Array

unsigned

char

buffer

; {

FileStream

fileStream

(

filePath

GetFullPath

(),

FileStream

ReadOnly

);

fileStream

IsAvailable

())

return

false

;

(

fileStream

Size

() ==

) {

text

L""

;

encoding

BomEncoder

Mbcs

;

containsBom

false

;

return

true

; }

buffer

Resize

((

vint

)

fileStream

Size

());

vint

count

fileStream

Read

buffer

[

buffer

Count

());

CHECK_ERROR(count == buffer.Count(), L"vl::filesystem::File::ReadAllTextWithEncodingTesting(WString&, BomEncoder::Encoding&, bool&)#Failed to read the whole file.");

{

(!(

count

buffer

Count

()))

throw

Error

(

L"vl::filesystem::File::ReadAllTextWithEncodingTesting(WString&, BomEncoder::Encoding&, bool&)#Failed to read the whole file."

);}

while

(

);

}

TestEncoding

buffer

[

buffer

Count

(),

encoding

containsBom

);

MemoryWrapperStream

memoryStream

buffer

[

buffer

Count

());

(

containsBom

) {

BomDecoder

decoder

;

DecoderStream

decoderStream

(

memoryStream

decoder

);

StreamReader

reader

(

decoderStream

);

text

reader

ReadToEnd

(); }

else

{

switch

(

encoding

) {

case

BomEncoder

Utf8

: {

Utf8Decoder

decoder

;

DecoderStream

decoderStream

(

memoryStream

decoder

);

StreamReader

reader

(

decoderStream

);

text

reader

ReadToEnd

(); }

break

;

case

BomEncoder

Utf16

: {

Utf16Decoder

decoder

;

DecoderStream

decoderStream

(

memoryStream

decoder

);

StreamReader

reader

(

decoderStream

);

text

reader

ReadToEnd

(); }

break

;

case

BomEncoder

Utf16BE

: {

Utf16BEDecoder

decoder

;

DecoderStream

decoderStream

(

memoryStream

decoder

);

StreamReader

reader

(

decoderStream

);

text

reader

ReadToEnd

(); }

break

;

default

: {

MbcsDecoder

decoder

;

DecoderStream

decoderStream

(

memoryStream

decoder

);

StreamReader

reader

(

decoderStream

);

text

reader

ReadToEnd

(); } } }

return

true

; }

WString

File

ReadAllTextByBom

()

const

{

WString

text

;

ReadAllTextByBom

(

text

);

return

text

; }

bool

File

ReadAllTextByBom

(

WString

text

)

const

{

FileStream

fileStream

(

filePath

GetFullPath

(),

FileStream

ReadOnly

);

fileStream

IsAvailable

())

return

false

;

BomDecoder

decoder

;

DecoderStream

decoderStream

(

fileStream

decoder

);

StreamReader

reader

(

decoderStream

);

text

reader

ReadToEnd

();

return

true

; }

bool

File

ReadAllLinesByBom

(

collections

List

WString

lines

)

const

{

FileStream

fileStream

(

filePath

GetFullPath

(),

FileStream

ReadOnly

);

fileStream

IsAvailable

())

return

false

;

BomDecoder

decoder

;

DecoderStream

decoderStream

(

fileStream

decoder

);

StreamReader

reader

(

decoderStream

);

while

reader

IsEnd

()) {

lines

Add

(

reader

ReadLine

()); }

return

true

; }

bool

File

WriteAllText

(

const

WString

text

bool

bom

stream

BomEncoder

Encoding

encoding

) {

FileStream

fileStream

(

filePath

GetFullPath

(),

FileStream

WriteOnly

);

fileStream

IsAvailable

())

return

false

;

IEncoder

encoder

nullptr

;

(

bom

) {

encoder

new

BomEncoder

(

encoding

); }

else

switch

(

encoding

) {

case

BomEncoder

Utf8

encoder

new

Utf8Encoder

;

break

;

case

BomEncoder

Utf16

encoder

new

Utf16Encoder

;

break

;

case

BomEncoder

Utf16BE

encoder

new

Utf16BEEncoder

;

break

;

default

encoder

new

MbcsEncoder

;

break

; } {

EncoderStream

encoderStream

(

fileStream

, *

encoder

);

StreamWriter

writer

(

encoderStream

);

writer

WriteString

(

text

); }

delete

encoder

;

return

true

; }

bool

File

WriteAllLines

(

collections

List

WString

lines

bool

bom

stream

BomEncoder

Encoding

encoding

) {

FileStream

fileStream

(

filePath

GetFullPath

(),

FileStream

WriteOnly

);

fileStream

IsAvailable

())

return

false

;

IEncoder

encoder

nullptr

;

(

bom

) {

encoder

new

BomEncoder

(

encoding

); }

else

switch

(

encoding

) {

case

BomEncoder

Utf8

encoder

new

Utf8Encoder

;

break

;

case

BomEncoder

Utf16

encoder

new

Utf16Encoder

;

break

;

case

BomEncoder

Utf16BE

encoder

new

Utf16BEEncoder

;

break

;

default

encoder

new

MbcsEncoder

;

break

; } {

EncoderStream

encoderStream

(

fileStream

, *

encoder

);

StreamWriter

writer

(

encoderStream

);

FOREACH(WString, line, lines)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

WString

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

lines

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

WString

line

;

__foreach_iterator__

(

line

);)

{

writer

WriteLine

(

line

); } }

delete

encoder

;

return

true

; }

bool

File

Exists

()

const

{

return

filePath

IsFile

(); }

bool

File

Delete

()

const

{

#if defined VCZH_MSVC

return DeleteFile(filePath.GetFullPath().Buffer()) != 0;

return

DeleteFileW

(

filePath

GetFullPath

().

Buffer

()) !=

;

#elif defined VCZH_GCC

AString path = wtoa(filePath.GetFullPath());

return unlink(path.Buffer()) == 0; #endif

}

bool

File

Rename

(

const

WString

newName

)

const

{

#if defined VCZH_MSVC

WString

oldFileName

filePath

GetFullPath

();

WString

newFileName

= (

filePath

GetFolder

()

newName

GetFullPath

();

return MoveFile(oldFileName.Buffer(), newFileName.Buffer()) != 0;

return

MoveFileW

(

oldFileName

Buffer

(),

newFileName

Buffer

()) !=

;

#elif defined VCZH_GCC

AString oldFileName = wtoa(filePath.GetFullPath());

AString newFileName = wtoa((filePath.GetFolder() / newName).GetFullPath());

return rename(oldFileName.Buffer(), newFileName.Buffer()) == 0; #endif

}

/*********************************************************************** Folder ***********************************************************************/

Folder

() { }

Folder

(

const

FilePath

_filePath

) :filePath(

_filePath

) { }

Folder

() { }

const

FilePath

Folder

GetFilePath

()

const

{

return

filePath

; }

bool

Folder

GetFolders

(

collections

List

Folder

folders

)

const

{

#if defined VCZH_MSVC

(

filePath

IsRoot

()) {

auto bufferSize = GetLogicalDriveStrings(0, nullptr);

auto

bufferSize

GetLogicalDriveStringsW

(

nullptr

);

(

bufferSize

) {

Array

wchar_t

buffer

(

bufferSize

);

if (GetLogicalDriveStrings((DWORD)buffer.Count(), &buffer[0]) > 0)

(

GetLogicalDriveStringsW

((

DWORD

)

buffer

Count

(), &

buffer

[

]) >

)

{

auto

begin

= &

buffer

[

];

auto

end

begin

buffer

Count

();

while

(

begin

end

&& *

begin

) {

WString

driveString

begin

;

begin

driveString

Length

() +

;

folders

Add

(

Folder

(

FilePath

(

driveString

))); }

return

true

; } }

return

false

; }

else

{

Exists

())

return

false

;

WIN32_FIND_DATA

findData

;

HANDLE findHandle = INVALID_HANDLE_VALUE;

HANDLE

findHandle

= ((

HANDLE

)(

LONG_PTR

);

while

(

true

) {

if (findHandle == INVALID_HANDLE_VALUE)

(

findHandle

== ((

HANDLE

)(

LONG_PTR

))

{

WString

searchPath

= (

filePath

L"*"

).GetFullPath();

findHandle = FindFirstFile(searchPath.Buffer(), &findData);

findHandle

FindFirstFileW

(

searchPath

Buffer

(), &

findData

);

if (findHandle == INVALID_HANDLE_VALUE)

(

findHandle

== ((

HANDLE

)(

LONG_PTR

))

{

break

; } }

else

{

BOOL result = FindNextFile(findHandle, &findData);

BOOL

result

FindNextFileW

(

findHandle

, &

findData

);

(

result

) {

FindClose

(

findHandle

);

break

; } }

if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)

(

findData

dwFileAttributes

0x00000010

)

{

(

wcscmp

(

findData

cFileName

L"."

) !=

wcscmp

(

findData

cFileName

L".."

) !=

) {

folders

Add

(

Folder

(

filePath

findData

cFileName

)); } } }

return

true

; }

#elif defined VCZH_GCC

if (!Exists()) return false;

DIR *dir;

AString searchPath = wtoa(filePath.GetFullPath());

if ((dir = opendir(searchPath.Buffer())) == NULL)

{

return false;

}

struct dirent* entry;

while ((entry = readdir(dir)) != NULL)

{

WString childName = atow(AString(entry->d_name));

FilePath childFullPath = filePath / childName;

if (childName != L"." && childName != L".." && childFullPath.IsFolder())

{

folders.Add(Folder(childFullPath));

}

if (closedir(dir) != 0)

{

return false;

}

return true; #endif

}

bool

Folder

GetFiles

(

collections

List

File

files

)

const

{

#if defined VCZH_MSVC

(

filePath

IsRoot

()) {

return

true

; }

Exists

())

return

false

;

WIN32_FIND_DATA

findData

;

HANDLE findHandle = INVALID_HANDLE_VALUE;

HANDLE

findHandle

= ((

HANDLE

)(

LONG_PTR

);

while

(

true

) {

if (findHandle == INVALID_HANDLE_VALUE)

(

findHandle

== ((

HANDLE

)(

LONG_PTR

))

{

WString

searchPath

= (

filePath

L"*"

).GetFullPath();

findHandle = FindFirstFile(searchPath.Buffer(), &findData);

findHandle

FindFirstFileW

(

searchPath

Buffer

(), &

findData

);

if (findHandle == INVALID_HANDLE_VALUE)

(

findHandle

== ((

HANDLE

)(

LONG_PTR

))

{

break

; } }

else

{

BOOL result = FindNextFile(findHandle, &findData);

BOOL

result

FindNextFileW

(

findHandle

, &

findData

);

(

result

) {

FindClose

(

findHandle

);

break

; } }

if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))

(!(

findData

dwFileAttributes

0x00000010

))

{

files

Add

(

File

(

filePath

findData

cFileName

)); } }

return

true

;

#elif defined VCZH_GCC

if (!Exists()) return false;

DIR *dir;

AString searchPath = wtoa(filePath.GetFullPath());

if ((dir = opendir(searchPath.Buffer())) == NULL)

{

return false;

}

struct dirent* entry;

while ((entry = readdir(dir)) != NULL)

{

FilePath childFullPath = filePath / (atow(AString(entry->d_name)));

if (childFullPath.IsFile())

{

files.Add(File(childFullPath));

}

if (closedir(dir) != 0)

{

return false;

}

return true; #endif

}

bool

Folder

Exists

()

const

{

return

filePath

IsFolder

(); }

bool

Folder

Create

(

bool

recursively

)

const

{

(

recursively

) {

auto

folder

filePath

GetFolder

();

(

folder

IsFile

())

return

false

;

(

folder

IsFolder

())

return

Create

(

false

);

return

Folder

(

folder

Create

(

true

) &&

Create

(

false

); }

else

{

#if defined VCZH_MSVC

return CreateDirectory(filePath.GetFullPath().Buffer(), NULL) != 0;

return

CreateDirectoryW

(

filePath

GetFullPath

().

Buffer

(),

) !=

;

#elif defined VCZH_GCC

AString path = wtoa(filePath.GetFullPath());

return mkdir(path.Buffer(), 0777) == 0; #endif

} }

bool

Folder

Delete

(

bool

recursively

)

const

{

Exists

())

return

false

;

(

recursively

) {

List

Folder

folders

;

GetFolders

(

folders

);

FOREACH(Folder, folder, folders)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Folder

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

folders

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Folder

folder

;

__foreach_iterator__

(

folder

);)

{

folder

Delete

(

true

))

return

false

; }

List

File

files

;

GetFiles

(

files

);

FOREACH(File, file, files)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

File

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

files

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

File

file

;

__foreach_iterator__

(

file

);)

{

file

Delete

())

return

false

; }

return

Delete

(

false

); }

#if defined VCZH_MSVC

return RemoveDirectory(filePath.GetFullPath().Buffer()) != 0;

return

RemoveDirectoryW

(

filePath

GetFullPath

().

Buffer

()) !=

;

#elif defined VCZH_GCC

AString path = wtoa(filePath.GetFullPath());

return rmdir(path.Buffer()) == 0; #endif

}

bool

Folder

Rename

(

const

WString

newName

)

const

{

#if defined VCZH_MSVC

WString

oldFileName

filePath

GetFullPath

();

WString

newFileName

= (

filePath

GetFolder

()

newName

GetFullPath

();

return MoveFile(oldFileName.Buffer(), newFileName.Buffer()) != 0;

return

MoveFileW

(

oldFileName

Buffer

(),

newFileName

Buffer

()) !=

;

#elif defined VCZH_GCC

AString oldFileName = wtoa(filePath.GetFullPath());

AString newFileName = wtoa((filePath.GetFolder() / newName).GetFullPath());

return rename(oldFileName.Buffer(), newFileName.Buffer()) == 0; #endif

} } }