自学教程：C++ GetFileAttributesExW函数代码示例

//------------------------------------------------------------------------------int hooked_stat(const char* path, struct hooked_stat* out){    int ret = -1;    WIN32_FILE_ATTRIBUTE_DATA fad;    wchar_t buf[2048];    size_t characters;    // Utf8 to wchars.    characters = MultiByteToWideChar(        CP_UTF8, 0,        path, -1,        buf, sizeof_array(buf)    );    characters = characters ? characters : sizeof_array(buf) - 1;    buf[characters] = L'/0';    // Get properties.    out->st_size = 0;    out->st_mode = 0;    if (GetFileAttributesExW(buf, GetFileExInfoStandard, &fad) != 0)    {        unsigned dir_bit;        dir_bit = (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? _S_IFDIR : 0;        out->st_size = fad.nFileSizeLow;        out->st_mode |= dir_bit;        ret = 0;    }    else        errno = ENOENT;    return ret;}

int64_tomrfile_length(struct OMRPortLibrary *portLibrary, const char *path){	int64_t result = -1;	wchar_t unicodeBuffer[UNICODE_BUFFER_SIZE], *unicodePath;	Trc_PRT_file_length_Entry(path);	/* Convert the filename from UTF8 to Unicode */	unicodePath = file_get_unicode_path(portLibrary, path, unicodeBuffer, UNICODE_BUFFER_SIZE);	if (NULL != unicodePath) {		WIN32_FILE_ATTRIBUTE_DATA myStat;		if (0 == GetFileAttributesExW(unicodePath, GetFileExInfoStandard, &myStat)) {			int32_t error = GetLastError();			result = portLibrary->error_set_last_error(portLibrary, error, findError(error));		} else {			result = ((int64_t)myStat.nFileSizeHigh) << 32;			result += (int64_t)myStat.nFileSizeLow;		}		if (unicodeBuffer != unicodePath) {			portLibrary->mem_free_memory(portLibrary, unicodePath);		}	}	Trc_PRT_file_length_Exit(result);	return result;}

/****************************************************************************** *        FileMoniker_GetTimeOfLastChange ******************************************************************************/static HRESULT WINAPIFileMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,                                    IMoniker* pmkToLeft, FILETIME* pFileTime){    FileMonikerImpl *This = impl_from_IMoniker(iface);    IRunningObjectTable* rot;    HRESULT res;    WIN32_FILE_ATTRIBUTE_DATA info;    TRACE("(%p,%p,%p,%p)/n",iface,pbc,pmkToLeft,pFileTime);    if (pFileTime==NULL)        return E_POINTER;    if (pmkToLeft!=NULL)        return E_INVALIDARG;    res=IBindCtx_GetRunningObjectTable(pbc,&rot);    if (FAILED(res))        return res;    res= IRunningObjectTable_GetTimeOfLastChange(rot,iface,pFileTime);    if (FAILED(res)){ /* the moniker is not registered */        if (!GetFileAttributesExW(This->filePathName,GetFileExInfoStandard,&info))            return MK_E_NOOBJECT;        *pFileTime=info.ftLastWriteTime;    }    return S_OK;}

bool fs::stat(const std::string& path, stat_t& info){	g_tls_error = fse::ok;#ifdef _WIN32	WIN32_FILE_ATTRIBUTE_DATA attrs;	if (!GetFileAttributesExW(to_wchar(path).get(), GetFileExInfoStandard, &attrs))	{		return false;	}	info.is_directory = (attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;	info.is_writable = (attrs.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;	info.size = (u64)attrs.nFileSizeLow | ((u64)attrs.nFileSizeHigh << 32);	info.atime = to_time_t(attrs.ftLastAccessTime);	info.mtime = to_time_t(attrs.ftLastWriteTime);	info.ctime = to_time_t(attrs.ftCreationTime);#else	struct stat file_info;	if (stat(path.c_str(), &file_info) < 0)	{		return false;	}	info.is_directory = S_ISDIR(file_info.st_mode);	info.is_writable = file_info.st_mode & 0200; // HACK: approximation	info.size = file_info.st_size;	info.atime = file_info.st_atime;	info.mtime = file_info.st_mtime;	info.ctime = file_info.st_ctime;#endif	return true;}

// Changes the mode of a file.  The only supported mode bit is _S_IWRITE, which// controls the user write (read-only) attribute of the file.  Returns zero if// successful; returns -1 and sets errno and _doserrno on failure.extern "C" int __cdecl _wchmod(wchar_t const* const path, int const mode){    _VALIDATE_CLEAR_OSSERR_RETURN(path != nullptr, EINVAL, -1);    WIN32_FILE_ATTRIBUTE_DATA attributes;    if (!GetFileAttributesExW(path, GetFileExInfoStandard, &attributes))    {        __acrt_errno_map_os_error(GetLastError());        return -1;    }    // Set or clear the read-only flag:    if (mode & _S_IWRITE)    {        attributes.dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;    }    else    {        attributes.dwFileAttributes |= FILE_ATTRIBUTE_READONLY;    }    if (!SetFileAttributesW(path, attributes.dwFileAttributes))    {        __acrt_errno_map_os_error(GetLastError());        return -1;    }    return 0;}

JNIEXPORT void JNICALLJava_net_rubygrapefruit_platform_internal_jni_WindowsFileFunctions_stat(JNIEnv *env, jclass target, jstring path, jobject dest, jobject result) {    jclass destClass = env->GetObjectClass(dest);    jmethodID mid = env->GetMethodID(destClass, "details", "(IJJ)V");    if (mid == NULL) {        mark_failed_with_message(env, "could not find method", result);        return;    }    WIN32_FILE_ATTRIBUTE_DATA attr;    wchar_t* pathStr = java_to_wchar(env, path, result);    BOOL ok = GetFileAttributesExW(pathStr, GetFileExInfoStandard, &attr);    free(pathStr);    if (!ok) {        DWORD error = GetLastError();        if (error == ERROR_FILE_NOT_FOUND || error == ERROR_PATH_NOT_FOUND || error == ERROR_NOT_READY) {            // Treat device with no media as missing            env->CallVoidMethod(dest, mid, (jint)FILE_TYPE_MISSING, (jlong)0, (jlong)0);            return;        }        mark_failed_with_errno(env, "could not file attributes", result);        return;    }    jlong lastModified = lastModifiedNanos(&attr.ftLastWriteTime);    if (attr.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {        env->CallVoidMethod(dest, mid, (jint)FILE_TYPE_DIRECTORY, (jlong)0, lastModified);    } else {        jlong size = ((jlong)attr.nFileSizeHigh << 32) | attr.nFileSizeLow;        env->CallVoidMethod(dest, mid, (jint)FILE_TYPE_FILE, size, lastModified);    }}

/* * The CRT of Windows has a number of flaws wrt. its stat() implementation: * - time stamps are restricted to second resolution * - file modification times suffer from forth-and-back conversions between *    UTC and local time * Therefore, we implement our own stat, based on the Win32 API directly. * * This is based on the Python 2 implementation from: * https://github.com/python/cpython/commit/14694662d530d0d1823e1d86f2e5b2e4ec600e86#diff-a6f29e907cbb5fffd44d453bcd7b77d5R741 */static intwin32_wstat(const wchar_t* path, struct meterp_stat *result){	int code;	const wchar_t *dot;	WIN32_FILE_ATTRIBUTE_DATA info;	if (!GetFileAttributesExW(path, GetFileExInfoStandard, &info)) {		if (GetLastError() != ERROR_SHARING_VIOLATION) {			return -1;		}		else {			if (!attributes_from_dir_w(path, &info)) {				return -1;			}		}	}	code = attribute_data_to_stat(&info, result);	if (code < 0) {		return code;	}	/* Set IFEXEC if it is an .exe, .bat, ... */	dot = wcsrchr(path, '.');	if (dot) {		if (_wcsicmp(dot, L".bat") == 0 ||			_wcsicmp(dot, L".cmd") == 0 ||			_wcsicmp(dot, L".exe") == 0 ||			_wcsicmp(dot, L".com") == 0)			result->st_mode |= 0111;	}	return code;}

int64_tomrfile_lastmod(struct OMRPortLibrary *portLibrary, const char *path){	int64_t result = -1;	wchar_t unicodeBuffer[UNICODE_BUFFER_SIZE], *unicodePath;	Trc_PRT_file_lastmod_Entry(path);	/* Convert the filename from UTF8 to Unicode */	unicodePath = file_get_unicode_path(portLibrary, path, unicodeBuffer, UNICODE_BUFFER_SIZE);	if (NULL != unicodePath) {		WIN32_FILE_ATTRIBUTE_DATA myStat;		if (0 == GetFileAttributesExW(unicodePath, GetFileExInfoStandard, &myStat)) {			int32_t error = GetLastError();			result = portLibrary->error_set_last_error(portLibrary, error, findError(error));		} else {			/*			 * Search MSDN for 'Converting a time_t Value to a File Time' for following implementation.			 */			result = ((int64_t) myStat.ftLastWriteTime.dwHighDateTime << 32) | (int64_t) myStat.ftLastWriteTime.dwLowDateTime;			result = (result - 116444736000000000) / 10000;		}		if (unicodeBuffer != unicodePath) {			portLibrary->mem_free_memory(portLibrary, unicodePath);		}	}	Trc_PRT_file_lastmod_Exit(result);	return result;}

static bool _EbrIsDir(const wchar_t* path) {    WIN32_FILE_ATTRIBUTE_DATA fileAttribData;    if (GetFileAttributesExW(path, GetFileExInfoStandard, &fileAttribData)) {        if ((fileAttribData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)            return true;    }    return false;}

bool tr_sys_path_get_info(char const* path, int flags, tr_sys_path_info* info, tr_error** error){    TR_ASSERT(path != NULL);    TR_ASSERT(info != NULL);    bool ret = false;    wchar_t* wide_path = path_to_native_path(path);    if ((flags & TR_SYS_PATH_NO_FOLLOW) == 0)    {        HANDLE handle = INVALID_HANDLE_VALUE;        if (wide_path != NULL)        {            handle = CreateFileW(wide_path, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);        }        if (handle != INVALID_HANDLE_VALUE)        {            tr_error* my_error = NULL;            ret = tr_sys_file_get_info(handle, info, &my_error);            if (!ret)            {                tr_error_propagate(error, &my_error);            }            CloseHandle(handle);        }        else        {            set_system_error(error, GetLastError());        }    }    else    {        WIN32_FILE_ATTRIBUTE_DATA attributes;        if (wide_path != NULL)        {            ret = GetFileAttributesExW(wide_path, GetFileExInfoStandard, &attributes);        }        if (ret)        {            stat_to_sys_path_info(attributes.dwFileAttributes, attributes.nFileSizeLow, attributes.nFileSizeHigh,                &attributes.ftLastWriteTime, info);        }        else        {            set_system_error(error, GetLastError());        }    }    tr_free(wide_path);    return ret;}

static int doPlatformExists(LPWSTR wpath){	WIN32_FILE_ATTRIBUTE_DATA a;	// Returns non-zero if successful	BOOL retval = GetFileAttributesExW(wpath, GetFileExInfoStandard, &a);	return(retval);} /* doPlatformExists */

long DVLib::GetFileSize(const std::wstring& filename){    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };	CHECK_WIN32_BOOL(GetFileAttributesExW(filename.c_str(), GetFileExInfoStandard, & attr),        L"Error getting file attributes of " << filename);    CHECK_BOOL(0 == attr.nFileSizeHigh,        L"File " << filename << L" is > 2GB (" << attr.nFileSizeHigh << ")");    return (long) attr.nFileSizeLow; }

 DWORD WINAPI_DECL GetFileAttributesW(     _In_  LPCWSTR lpFileName     ) {     WIN32_FILE_ATTRIBUTE_DATA fileInformation;     BOOL b = GetFileAttributesExW(         lpFileName,          GetFileExInfoStandard,          &fileInformation);     return b ? fileInformation.dwFileAttributes : INVALID_FILE_ATTRIBUTES; }

        void WinNode::stat_impl(NodeStat& dst)        {            WIN32_FILE_ATTRIBUTE_DATA attrs = { 0 };            GetFileAttributesExW(m_nativePath.c_str(), GetFileExInfoStandard, &attrs);            filetimeToUint64(dst.ctime, attrs.ftCreationTime);            filetimeToUint64(dst.mtime, attrs.ftLastWriteTime);            filetimeToUint64(dst.atime, attrs.ftLastAccessTime);            dst.id = m_id;            dst.size = ((uint64)attrs.nFileSizeHigh << 32) | attrs.nFileSizeLow;        }

ticks_t Platform::getFileModificationTime(std::string file){    boost::replace_all(file, "/", "//");    std::wstring wfile = stdext::utf8_to_utf16(file);    WIN32_FILE_ATTRIBUTE_DATA fileAttrData;    memset(&fileAttrData, 0, sizeof(fileAttrData));    GetFileAttributesExW(wfile.c_str(), GetFileExInfoStandard, &fileAttrData);    ULARGE_INTEGER uli;    uli.LowPart  = fileAttrData.ftLastWriteTime.dwLowDateTime;    uli.HighPart = fileAttrData.ftLastWriteTime.dwHighDateTime;    return uli.QuadPart;}

HRESULT CFileWatcher::GetWatchedFileTimestamp(WatchedFile* file, FILETIME* timestamp){	HRESULT hr;	WIN32_FILE_ATTRIBUTE_DATA attributes;	WIN32_FIND_DATAW findData;	HANDLE foundFile = INVALID_HANDLE_VALUE;	if (file->wildcard)	{		// a timestamp of a wildcard watched file is the XOR of the timestamps of all matching files and their names and sizes;		// that way if any of the matching files changes, or matching files are added or removed, the timestamp will change as well		RtlZeroMemory(timestamp, sizeof FILETIME);		foundFile = FindFirstFileW(file->fileName, &findData);		if (INVALID_HANDLE_VALUE != foundFile)		{			do			{				if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))				{					timestamp->dwHighDateTime ^= findData.ftLastWriteTime.dwHighDateTime ^ findData.nFileSizeHigh;					timestamp->dwLowDateTime ^= findData.ftLastWriteTime.dwLowDateTime ^ findData.nFileSizeLow;					WCHAR* current = findData.cFileName;					while (*current)					{						timestamp->dwLowDateTime ^= *current;						current++;					}				}			} while (FindNextFileW(foundFile, &findData));			ErrorIf(ERROR_NO_MORE_FILES != (hr = GetLastError()), hr);			FindClose(foundFile);			foundFile = NULL;		}	}	else	{		ErrorIf(!GetFileAttributesExW(file->fileName, GetFileExInfoStandard, &attributes), GetLastError());		memcpy(timestamp, &attributes.ftLastWriteTime, sizeof attributes.ftLastWriteTime);	}	return S_OK;Error:	if (INVALID_HANDLE_VALUE != foundFile)	{		FindClose(foundFile);		foundFile = INVALID_HANDLE_VALUE;	}	return hr;}

/**	sys_file_type : string -> string	<doc>	Return the type of the file. The current values are possible :	<ul>	<li>[file]</li>	<li>[dir]</li>	<li>[symlink]</li>	<li>[sock]</li>	<li>[char]</li>	<li>[block]</li>	<li>[fifo]</li>	</ul>	</doc>**/static value sys_file_type( value path ) {	#if defined(EPPC) || defined(KORE_CONSOLE)	return alloc_null();	#else	val_check(path,string);	#ifdef NEKO_WINDOWS	const wchar_t* _path = val_wstring(path);	gc_enter_blocking();	WIN32_FILE_ATTRIBUTE_DATA data;	if( !GetFileAttributesExW(_path,GetFileExInfoStandard,&data) )	{		gc_exit_blocking();		return alloc_null();	}	gc_exit_blocking();	if ((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)	{		return alloc_string("dir");	}	else	{		return alloc_string("file");	}	#else	struct stat s;	gc_enter_blocking();	if( stat(val_string(path),&s) != 0 )	{		gc_exit_blocking();		return alloc_null();	}	gc_exit_blocking();	if( s.st_mode & S_IFREG )		return alloc_string("file");	if( s.st_mode & S_IFDIR )		return alloc_string("dir");	if( s.st_mode & S_IFCHR )		return alloc_string("char");#ifndef NEKO_WINDOWS	if( s.st_mode & S_IFLNK )		return alloc_string("symlink");	if( s.st_mode & S_IFBLK )		return alloc_string("block");	if( s.st_mode & S_IFIFO )		return alloc_string("fifo");	if( s.st_mode & S_IFSOCK )		return alloc_string("sock");#endif	#endif	return alloc_null();	#endif}

bool is_file_existsW(_In_ const wchar_t* file_path){	_ASSERTE(NULL != file_path);	_ASSERTE(TRUE != IsBadStringPtrW(file_path, MAX_PATH));	if ((NULL == file_path) || (TRUE == IsBadStringPtrW(file_path, MAX_PATH))) return false;	WIN32_FILE_ATTRIBUTE_DATA info = { 0 };	if (GetFileAttributesExW(file_path, GetFileExInfoStandard, &info) == 0)		return false;	else		return true;}

bool getFileAttributes(const char* path, uint64_t* mtime, uint64_t* size){	WIN32_FILE_ATTRIBUTE_DATA data;	if (GetFileAttributesExW(fromUtf8(path).c_str(), GetFileExInfoStandard, &data))	{		*mtime = combine(data.ftLastWriteTime.dwHighDateTime, data.ftLastWriteTime.dwLowDateTime);		*size = combine(data.nFileSizeHigh, data.nFileSizeLow);		return true;	}	return false;}

	Yuni::IO::NodeType TypeOf(const AnyString& filename)	{		if (filename.empty())			return Yuni::IO::typeUnknown;		# ifdef YUNI_OS_WINDOWS		const char* p = filename.c_str();		unsigned int len = filename.size();		if (p[len - 1] == '//' or p[len - 1] == '/')		{			if (!--len)			{				# ifdef YUNI_OS_WINDOWS				return Yuni::IO::typeUnknown;				# else				// On Unixes, `/` is a valid folder				return Yuni::IO::typeFolder;				# endif			}		}		// Driver letters		if (len == 2 and p[1] == ':')			return Yuni::IO::typeFolder;		String  norm;		Yuni::IO::Normalize(norm, AnyString(p, len));		// Conversion into wchar_t		Private::WString<true> wstr(norm);		if (wstr.empty())			return Yuni::IO::typeUnknown;		WIN32_FILE_ATTRIBUTE_DATA infoFile;		if (!GetFileAttributesExW(wstr.c_str(), GetFileExInfoStandard, &infoFile))			return Yuni::IO::typeUnknown;		return ((infoFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)			? Yuni::IO::typeFolder			: Yuni::IO::typeFile;		# else // WINDOWS		struct stat s;		if (stat(filename.c_str(), &s) != 0)			return Yuni::IO::typeUnknown;		return (S_ISDIR(s.st_mode))			? Yuni::IO::typeFolder			: Yuni::IO::typeFile;		# endif	}

static int do_lstat(const char *file_name, struct stat *buf){	WIN32_FILE_ATTRIBUTE_DATA fdata;	wchar_t* fbuf = gitwin_to_utf16(file_name);	if (GetFileAttributesExW(fbuf, GetFileExInfoStandard, &fdata)) {		int fMode = S_IREAD;		if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)			fMode |= S_IFDIR;		else			fMode |= S_IFREG;		if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY))			fMode |= S_IWRITE;		if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)			fMode |= S_IFLNK;		buf->st_ino = 0;		buf->st_gid = 0;		buf->st_uid = 0;		buf->st_nlink = 1;		buf->st_mode = (mode_t)fMode;		buf->st_size = fdata.nFileSizeLow; /* Can't use nFileSizeHigh, since it's not a stat64 */		buf->st_dev = buf->st_rdev = (_getdrive() - 1);		buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));		buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));		buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));		git__free(fbuf);		return GIT_SUCCESS;	}	git__free(fbuf);	switch (GetLastError()) {		case ERROR_ACCESS_DENIED:		case ERROR_SHARING_VIOLATION:		case ERROR_LOCK_VIOLATION:		case ERROR_SHARING_BUFFER_EXCEEDED:			return GIT_EOSERR;		case ERROR_BUFFER_OVERFLOW:		case ERROR_NOT_ENOUGH_MEMORY:			return GIT_ENOMEM;		default:			return GIT_EINVALIDPATH;	}}

////	Update variables (after profile loading for example)//PLUGIN_EXPORT void PluginUpdateVars(){    DWORD clr;    SAFE_DELETE(pTextBrush);    clr = PC_GetPluginVarInt(m_dwPluginID, VAR_TEXT_COLOR);    pTextBrush = new Gdiplus::SolidBrush(Gdiplus::Color(255, GetRValue(clr), GetGValue(clr), GetBValue(clr)));    SAFE_DELETE(pBackBrush);    clr = PC_GetPluginVarInt(m_dwPluginID, VAR_BACKGROUND_COLOR);    pBackBrush = new Gdiplus::SolidBrush(Gdiplus::Color(255, GetRValue(clr), GetGValue(clr), GetBValue(clr)));    bShowBackground = PC_GetPluginVarInt(m_dwPluginID, VAR_SHOW_BACKGROUND);    SAFE_DELETE(pFont);    pFont = new Gdiplus::Font(        PC_GetPluginVarStr(m_dwPluginID, VAR_TEXT_FONT_FAMILY),        (float)PC_GetPluginVarInt(m_dwPluginID, VAR_TEXT_FONT_SIZE),        PC_GetPluginVarInt(m_dwPluginID, VAR_TEXT_FONT_STYLE));    //SAFE_DELETE(pFileName);    pFileName = PC_GetPluginVarStr(m_dwPluginID, VAR_TEXT_FILE);    string textContents = "";    if (PathFileExists(pFileName)) {        WIN32_FILE_ATTRIBUTE_DATA       attribs;        GetFileAttributesExW(pFileName, GetFileExInfoStandard, &attribs);        FILETIME modifyTime = attribs.ftLastWriteTime;        oldModifyTime = modifyTime;        string line;        ifstream myfile;        myfile.open(pFileName);        if (myfile.is_open())        {            while (getline(myfile, line))            {                textContents += line;                //cout << line << '/n';            }            myfile.close();        }    }    textLength = textContents.length();    wcTextContents[textLength] = 0;    std::copy(textContents.begin(), textContents.end(), wcTextContents);}

	bool PathUtil::getFileModifiedTime(const String& filename, longlong_t* t) {		WIN32_FILE_ATTRIBUTE_DATA fileAttr;		if (GetFileAttributesExW(u2w(filename).c_str(), GetFileExInfoStandard, &fileAttr)) {			FILETIME time;			time = fileAttr.ftLastWriteTime;			if (t)				(*t) = ((longlong_t)time.dwHighDateTime << 32) + time.dwLowDateTime;			return true;		}		return false;	}

 DWORD WINAPI_DECL GetFileAttributesA(     _In_  LPCSTR lpFileName     ) {     charset_t charset(lpFileName);     if (charset.wstr() == NULL) {         return INVALID_FILE_ATTRIBUTES;     }     WIN32_FILE_ATTRIBUTE_DATA fileInformation;     BOOL b = GetFileAttributesExW(         charset.wstr(),          GetFileExInfoStandard,          &fileInformation);     return b ? fileInformation.dwFileAttributes : INVALID_FILE_ATTRIBUTES; }

	/*!	 * Returns size of the file in bytes, or -1 if it does not exist.	 * @param filename Path to the file.	 */	GDAPI UInt64 FileUtilitiesWindows::FileSize(WideString const& filename)	{		WIN32_FILE_ATTRIBUTE_DATA fileAttributeData = {};		if (GetFileAttributesExW(Paths::Platformize(filename).CStr(), GetFileExInfoStandard, &fileAttributeData) == TRUE)		{			if ((fileAttributeData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)			{				LARGE_INTEGER fileSize = {};				fileSize.HighPart = fileAttributeData.nFileSizeHigh;				fileSize.LowPart = fileAttributeData.nFileSizeLow;				return static_cast<UInt64>(fileSize.QuadPart);			}		}		return UInt64Max;	}

static bool checkDirectoryExistance(const std::wstring& path){    WIN32_FILE_ATTRIBUTE_DATA fileData;    if (GetFileAttributesExW(path.c_str(), GetFileExInfoStandard, &fileData) == 0)    {        // Failed to get attributes        return false;    }    if (fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)    {        return true;    }    return false;}

int __PHYSFS_platformIsDirectory(const char *fname){	int retval = 0;	LPWSTR wpath;	UTF8_TO_UNICODE_STACK_MACRO(wpath, fname);	BAIL_IF_MACRO(wpath == NULL, ERR_OUT_OF_MEMORY, 0);	//retval = ((pGetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY) != 0);	WIN32_FILE_ATTRIBUTE_DATA file_info;	const BOOL res = GetFileAttributesExW(wpath, GetFileExInfoStandard, &file_info);	if (res) {		retval = ((file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0);	}	__PHYSFS_smallFree(wpath);	return(retval);} /* __PHYSFS_platformIsDirectory */