mirror of
https://github.com/Mauler125/r5sdk.git
synced 2025-02-09 19:15:03 +01:00
295 lines
16 KiB
C++
295 lines
16 KiB
C++
#ifndef FILESYSTEM_H
|
|
#define FILESYSTEM_H
|
|
#include <tier1/keyvalues.h>
|
|
#include "ifilesystem.h"
|
|
|
|
class CBaseFileSystem : public CTier1AppSystem<IFileSystem>
|
|
{
|
|
public:
|
|
// Stub implementation of IAppSystem.
|
|
//virtual ~CBaseFileSystem() {};
|
|
virtual bool Connect(const CreateInterfaceFn factory) { return false; };
|
|
virtual void Disconnect() {};
|
|
virtual void* QueryInterface(const char* const pInterfaceName) { return nullptr; };
|
|
virtual InitReturnVal_t Init() { return InitReturnVal_t::INIT_FAILED; };
|
|
virtual void Shutdown() {};
|
|
virtual AppSystemTier_t GetTier() { return AppSystemTier_t::APP_SYSTEM_TIER_OTHER; };
|
|
virtual void Reconnect(const CreateInterfaceFn factory, const char* const pInterfaceName) {};
|
|
|
|
|
|
//--------------------------------------------------------
|
|
virtual bool IsSteam() const { return false; };
|
|
virtual FilesystemMountRetval_t MountSteamContent(int nExtraAppId = -1) { return FilesystemMountRetval_t::FILESYSTEM_MOUNT_FAILED; };
|
|
|
|
virtual bool InitFeatureFlags() { return false; };
|
|
virtual bool InitFeatureFlags(const char* pszFlagSetFile) { return false; };
|
|
|
|
virtual void AddSearchPath(const char* pPath, const char* pPathID, SearchPathAdd_t addType) {};
|
|
virtual bool RemoveSearchPath(const char* pPath, const char* pPathID) { return false; };
|
|
virtual void RemoveAllSearchPaths(void) {};
|
|
virtual void RemoveSearchPaths(const char* szPathID) {};
|
|
virtual void MarkPathIDByRequestOnly(const char* pPathID, bool bRequestOnly) {}
|
|
virtual const char* RelativePathToFullPath(const char* pFileName, const char* pPathID, char* pLocalPath, ssize_t localPathBufferSize, PathTypeFilter_t pathFilter = FILTER_NONE, PathTypeQuery_t* pPathType = NULL) { return nullptr; };
|
|
#if IsGameConsole()
|
|
virtual bool GetPackFileInfoFromRelativePath(const char* pFileName, const char* pPathID, char* pPackPath, ssize_t nPackPathBufferSize, ptrdiff_t& nPosition, ssize_t& nLength) { return false; };
|
|
#endif
|
|
virtual ssize_t GetSearchPath(const char* pathID, bool bGetPackFiles, char* pPath, ssize_t nMaxLen) { return NULL; };
|
|
virtual bool AddPackFile(const char* fullpath, const char* pathID) { return false; };
|
|
|
|
//--------------------------------------------------------
|
|
// File manipulation operations
|
|
//--------------------------------------------------------
|
|
virtual void RemoveFile(char const* pRelativePath, const char* pathID = 0) {}; // Deletes a file (on the WritePath)
|
|
virtual bool RenameFile(char const* pOldPath, char const* pNewPath, const char* pathID = 0) { return false; }; // Renames a file (on the WritePath)
|
|
virtual int CreateDirHierarchy(const char* path, const char* pathID = 0); // create a local directory structure
|
|
virtual bool IsDirectory(const char* pFileName, const char* pathID = 0); // File I/O and info
|
|
virtual ssize_t FileTimeToString(char* pStrip, ssize_t maxCharsIncludingTerminator, long fileTime) { return NULL; }; // Returns the string size
|
|
|
|
//--------------------------------------------------------
|
|
// Open file operations
|
|
//--------------------------------------------------------
|
|
|
|
virtual void SetBufferSize(FileHandle_t file/*, ssize_t nBytes*/) {};
|
|
virtual bool IsOk(FileHandle_t file) { return false; };
|
|
virtual bool EndOfFile(FileHandle_t file) { return false; };
|
|
virtual char* ReadLine(char* pOutput, size_t maxChars, FileHandle_t file) { return nullptr; };
|
|
#if ! defined(SWIG)
|
|
// Don't let SWIG see the PRINTF_FORMAT_STRING attribute or it will complain.
|
|
virtual ssize_t FPrintf(FileHandle_t file, PRINTF_FORMAT_STRING const char* pFormat, ...) FMTFUNCTION(3, 4) { return NULL; };
|
|
#else
|
|
virtual ssize_t FPrintf(FileHandle_t file, const char* pFormat, ...) FMTFUNCTION(3, 4) { return NULL; };
|
|
#endif
|
|
|
|
//--------------------------------------------------------
|
|
// Dynamic library operations
|
|
//--------------------------------------------------------
|
|
// load/unload modules
|
|
virtual CSysModule* LoadModule(const char* pFileName, const char* pPathID = 0, bool bValidatedDllOnly = true) { return nullptr; };
|
|
virtual void UnloadModule(CSysModule* pModule) {};
|
|
|
|
//--------------------------------------------------------
|
|
// File searching operations
|
|
//--------------------------------------------------------
|
|
// FindFirst/FindNext. Also see FindFirstEx.
|
|
virtual const char* FindFirst(const char* pWildCard, FileFindHandle_t* pHandle) { return nullptr; };
|
|
virtual const char* FindNext(FileFindHandle_t handle) { return nullptr; };
|
|
virtual bool FindIsDirectory(FileFindHandle_t handle) { return false; };
|
|
virtual void FindClose(FileFindHandle_t handle) {};
|
|
|
|
// Same as FindFirst, but you can filter by path ID, which can make it faster.
|
|
virtual const char* FindFirstEx(
|
|
const char* pWildCard,
|
|
const char* pPathID,
|
|
FileFindHandle_t* pHandle
|
|
) { return nullptr; };
|
|
|
|
// Searches for a file in all paths and results absolute path names for the file, works in pack files (zip and vpk) too
|
|
// Lets you search for something like sound/sound.cache and get a list of every sound cache
|
|
virtual void FindFileAbsoluteList(CUtlVector<CUtlString>& outAbsolutePathNames, const char* pWildCard, const char* pPathID) {};
|
|
|
|
//--------------------------------------------------------
|
|
// File name and directory operations
|
|
//--------------------------------------------------------
|
|
|
|
// FIXME: This method is obsolete! Use RelativePathToFullPath instead!
|
|
// converts a partial path into a full path
|
|
virtual const char* GetLocalPath(const char* pFileName, char* pLocalPath, ssize_t localPathBufferSize) { return nullptr; };
|
|
|
|
// Returns true on success ( based on current list of search paths, otherwise false if
|
|
// it can't be resolved )
|
|
virtual bool FullPathToRelativePath(const char* pFullpath, char* pRelative, ssize_t maxlen) { return false; };
|
|
|
|
// Gets the current working directory
|
|
virtual bool GetCurrentDirectory(char* pDirectory, unsigned int maxlen) { return false; }; // Last parameter is a DWORD passed to 'GetCurrentDirectoryA()' internally.
|
|
|
|
//--------------------------------------------------------
|
|
// Filename dictionary operations
|
|
//--------------------------------------------------------
|
|
|
|
virtual FileNameHandle_t FindOrAddFileName(char const* pFileName) { return nullptr; };
|
|
virtual bool String(const FileNameHandle_t& handle, char* buf, ssize_t buflen) { return NULL; };
|
|
|
|
//--------------------------------------------------------
|
|
// Asynchronous file operations
|
|
//--------------------------------------------------------
|
|
|
|
//--------------- [ !!! AMOS: !!! ALL ASYNC METHODS ARE UNIMPLEMENTED !!! PURECALL !!! ] ---------------//
|
|
//------------------------------------
|
|
// Global operations
|
|
//------------------------------------
|
|
virtual void PureCall0() {};
|
|
virtual void PureCall1() {};
|
|
virtual void PureCall2() {};
|
|
virtual void PureCall3() {};
|
|
virtual void PureCall4() {};
|
|
virtual void PureCall5() {};
|
|
|
|
//--------------------------------------------------------
|
|
// Debugging operations
|
|
//--------------------------------------------------------
|
|
|
|
// Dump to printf/OutputDebugString the list of files that have not been closed
|
|
virtual void PrintOpenedFiles(void) {};
|
|
virtual void PrintSearchPaths(void) {};
|
|
|
|
// output
|
|
virtual void SetWarningFunc(void (*pfnWarning)(const char* fmt, ...)) {};
|
|
virtual void SetWarningLevel(FileWarningLevel_t level) {};
|
|
virtual void AddLoggingFunc(void (*pfnLogFunc)(const char* fileName, const char* accessType)) {};
|
|
virtual void RemoveLoggingFunc(FileSystemLoggingFunc_t logFunc) {};
|
|
|
|
virtual __int64 __fastcall sub_14038C240(__int64 a1) { return NULL; };
|
|
virtual __int64 __fastcall sub_14038C380(__int64 a1) { return NULL; };
|
|
virtual __int64 __fastcall sub_14038C400(__int64 a1, __int64 a2) { return NULL; };
|
|
|
|
// Returns the file system statistics retrieved by the implementation. Returns NULL if not supported.
|
|
virtual const FileSystemStatistics* GetFilesystemStatistics() { return nullptr; };
|
|
|
|
//--------------------------------------------------------
|
|
// Start of new functions after Lost Coast release (7/05)
|
|
//--------------------------------------------------------
|
|
|
|
virtual FileHandle_t OpenEx(const char* pFileName, const char* pOptions, unsigned flags = 0, const char* pathID = 0/*, char** ppszResolvedFilename = NULL*/) { return nullptr; };
|
|
|
|
// Extended version of read provides more context to allow for more optimal reading
|
|
virtual ssize_t ReadEx(void* pOutput, ssize_t sizeDest, ssize_t size, FileHandle_t file);
|
|
virtual ssize_t ReadFileEx(const char* pFileName, const char* pPath, void** ppBuf, bool bNullTerminate = false, bool bOptimalAlloc = false, ssize_t nMaxBytes = 0, ptrdiff_t nStartingByte = 0, FSAllocFunc_t pfnAlloc = NULL) { return NULL; };
|
|
|
|
virtual FileNameHandle_t FindFileName(char const* pFileName) { return nullptr; };
|
|
|
|
#if defined( TRACK_BLOCKING_IO )
|
|
virtual void EnableBlockingFileAccessTracking(bool state) {};
|
|
virtual bool IsBlockingFileAccessEnabled() { return false; };
|
|
|
|
virtual IBlockingFileItemList* RetrieveBlockingFileAccessInfo() { return nullptr; };
|
|
#endif
|
|
|
|
virtual void SetupPreloadData() {};
|
|
virtual void DiscardPreloadData() {};
|
|
|
|
// If the "PreloadedData" hasn't been purged, then this'll try and instance the KeyValues using the fast path of compiled keyvalues loaded during startup.
|
|
// Otherwise, it'll just fall through to the regular KeyValues loading routines
|
|
virtual KeyValues* LoadKeyValues(KeyValuesPreloadType_t type, char const* filename, char const* pPathID = 0) { return nullptr; };
|
|
virtual bool LoadKeyValues(KeyValues& head, KeyValuesPreloadType_t type, char const* filename, char const* pPathID = 0) { return false; };
|
|
|
|
virtual bool GetFileTypeForFullPath(char const* pFullPath, wchar_t* buf, size_t bufSizeInBytes) { return false; };
|
|
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
virtual bool ReadToBuffer(FileHandle_t hFile, CUtlBuffer& buf, ssize_t nMaxBytes = 0, FSAllocFunc_t pfnAlloc = NULL);
|
|
|
|
//--------------------------------------------------------
|
|
// Optimal IO operations
|
|
//--------------------------------------------------------
|
|
virtual bool GetOptimalIOConstraints(FileHandle_t hFile, uint64_t* pOffsetAlign, uint64_t* pSizeAlign, uint64_t* pBufferAlign);
|
|
virtual void* AllocOptimalReadBuffer(ptrdiff_t nOffset = 0/*!!! UNUSED !!!*/, ssize_t nSize = 0) { return nullptr; };
|
|
virtual void FreeOptimalReadBuffer(void*) {};
|
|
|
|
|
|
virtual bool __fastcall sub_140383E00(__int64 a2) { return false; };
|
|
virtual bool sub_1403836A0() { return false; };
|
|
virtual __int64 __fastcall sub_140384310(int a1) { return NULL; };
|
|
virtual __int64 __fastcall CheckVPKMode(int nMode) { return NULL; }; // Checks if the VPK mode equals the mode input.
|
|
|
|
|
|
//--------------------------------------------------------
|
|
// Cache/VPK operations
|
|
//--------------------------------------------------------
|
|
virtual bool ReadFromCache(const char* pPath, FileSystemCache* pCache) { return false; };
|
|
|
|
virtual bool __fastcall sub_14037FFA0(__int64 a1, unsigned int a2, __int64 a3) { return false; };
|
|
|
|
virtual void SetVPKCacheModeClient() {}; // g_nVPKCacheMode = 1;
|
|
virtual void SetVPKCacheModeServer() {}; // g_nVPKCacheMode = 2;
|
|
virtual bool IsVPKCacheEnabled() { return false; }; // g_nVPKCacheMode != 0;
|
|
|
|
virtual __int64 __fastcall PrecacheTaskItem(__int64 a1) { return NULL; };
|
|
|
|
virtual void ResetItemCacheSize(int edx) {};
|
|
virtual void __fastcall sub_140380100(__int64 a1) {};
|
|
virtual void __fastcall sub_140380230(char a2) {};
|
|
virtual void* __fastcall sub_1403801F0(const void* a1, unsigned int a2) { return nullptr; };
|
|
virtual void __fastcall sub_140380220(__int64 a1) {};
|
|
virtual bool ResetItemCache() { return false; };
|
|
virtual char __fastcall sub_1403836D0(int a1, char* a2, unsigned int a3) { return false; };
|
|
virtual __int64 __fastcall sub_140383840(unsigned int a1, __int64 a2, char* a3, unsigned int BufferCount) { return NULL; };
|
|
virtual const char** __fastcall sub_140383760(unsigned int a1) { return nullptr; };
|
|
virtual __int64 __fastcall sub_140383A20(const char* a1) { return NULL; };
|
|
|
|
virtual VPKData_t* MountVPKFile(const char* pVpkPath) { return nullptr; };
|
|
virtual const char* UnmountVPKFile(const char* pBasename) { return nullptr; };
|
|
|
|
virtual void __fastcall sub_140383370() {};
|
|
virtual void __fastcall sub_140383560() {};
|
|
|
|
virtual unsigned __int64 __fastcall PnpCtxRegQueryInfoKey(__int64 a1, char* a2, unsigned int* a3, unsigned __int64 a4, unsigned __int64 a5, void(__fastcall* a6)(unsigned __int64)) { return NULL; };
|
|
virtual char* sub_1403842B0() { return nullptr; };
|
|
virtual __int64 __fastcall sub_1403842C0(__int64 a1, unsigned int a2, __int64 a3) { return NULL; };
|
|
|
|
virtual char __fastcall LoadMainVPK(const char* pszVPKFile) { return NULL; };
|
|
|
|
virtual __int64 sub_140380080() { return NULL; };
|
|
virtual char __fastcall sub_14038B530(const char* a1, unsigned __int8* a2, char* a3, __int64 Count) { return NULL; };
|
|
virtual __int64 __fastcall sub_14038C830(unsigned __int16* a1) { return NULL; };
|
|
virtual __int64 __fastcall sub_140388360(char* a1, __int64 a2) { return NULL; };
|
|
virtual __int64 __fastcall sub_140384C60(char* a1, unsigned __int64 a2) { return NULL; };
|
|
virtual void __fastcall sub_140382A80() { };
|
|
virtual __int64 __fastcall sub_14038CC90(int a1, unsigned int a2, __int64 a3, __int64 a4) { return NULL; };
|
|
virtual __int64 __fastcall UserMathErrorFunction() { return NULL; };
|
|
|
|
virtual ssize_t Read(void* pOutput, ssize_t size, FileHandle_t file);
|
|
virtual ssize_t Write(void const* pInput, ssize_t size, FileHandle_t file);
|
|
|
|
// if pathID is NULL, all paths will be searched for the file
|
|
virtual FileHandle_t Open(const char* pFileName, const char* pOptions, const char* pPathID = 0, int64_t unknown = 0);
|
|
virtual void Close(FileHandle_t file);
|
|
|
|
virtual void Seek(FileHandle_t file, ptrdiff_t pos, FileSystemSeek_t seekType);
|
|
virtual ptrdiff_t Tell(FileHandle_t file);
|
|
virtual ssize_t FSize(const char* pFileName, const char* pPathID = 0); // Gets optimized away if it isn't named differently or used.
|
|
virtual ssize_t Size(FileHandle_t file);
|
|
|
|
virtual void Flush(FileHandle_t file);
|
|
virtual bool Precache(const char* pFileName, const char* pPathID = 0);
|
|
|
|
virtual bool FileExists(const char* pFileName, const char* pPathID = 0);
|
|
virtual bool IsFileWritable(char const* pFileName, const char* pPathID = 0);
|
|
virtual bool SetFileWritable(char const* pFileName, bool writable, const char* pPathID = 0);
|
|
|
|
virtual long long GetFileTime(const char* pFileName, const char* pPathID = 0);
|
|
|
|
virtual bool ReadFile(const char* pFileName, const char* pPath, CUtlBuffer& buf, ssize_t nMaxBytes = 0, ptrdiff_t nStartingByte = 0, FSAllocFunc_t pfnAlloc = NULL);
|
|
virtual bool WriteFile(const char* pFileName, const char* pPath, CUtlBuffer& buf);
|
|
virtual bool UnzipFile(const char* pFileName, const char* pPath, const char* pDestination) { return false; };
|
|
|
|
char* ReadLine(char* maxChars, ssize_t maxOutputLength, FileHandle_t file);
|
|
CUtlString ReadString(FileHandle_t pFile);
|
|
};
|
|
|
|
class CFileSystem_Stdio : public CBaseFileSystem
|
|
{
|
|
protected:
|
|
// implementation of CBaseFileSystem virtual functions
|
|
virtual FILE* FS_fopen(const char* filename, const char* options, unsigned flags, int64* size) { return nullptr; };
|
|
virtual void FS_setbufsize(FILE* fp, unsigned nBytes) {};
|
|
virtual void FS_fclose(FILE* fp) {};
|
|
virtual void FS_fseek(FILE* fp, int64 pos, int seekType) {};
|
|
virtual long FS_ftell(FILE* fp) { return NULL; };
|
|
virtual int FS_feof(FILE* fp) { return NULL; };
|
|
virtual size_t FS_fread(void* dest, size_t destSize, size_t size, FILE* fp) { return NULL; };
|
|
virtual size_t FS_fwrite(const void* src, size_t size, FILE* fp) { return NULL; };
|
|
virtual bool FS_setmode(FILE* fp, FileMode_t mode) { return false; };
|
|
virtual size_t FS_vfprintf(FILE* fp, const char* fmt, va_list list) { return NULL; };
|
|
virtual int FS_ferror(FILE* fp) { return NULL; };
|
|
virtual int FS_fflush(FILE* fp) { return NULL; };
|
|
virtual char* FS_fgets(char* dest, unsigned int destSize) { return nullptr; };
|
|
virtual int FS_stat(const char* path, struct _stat* buf, bool* pbLoadedFromSteamCache = NULL) { return NULL; };
|
|
virtual int FS_chmod(const char* path, int pmode) { return NULL; };
|
|
virtual HANDLE FS_FindFirstFile(const char* findname, WIN32_FIND_DATA* dat) { return NULL; };
|
|
virtual bool FS_FindNextFile(HANDLE handle, WIN32_FIND_DATA* dat) { return false; };
|
|
virtual bool FS_FindClose(HANDLE handle) { return false; };
|
|
virtual int FS_GetSectorSize(FILE*) { return NULL; };
|
|
};
|
|
|
|
#endif // FILESYSTEM_H
|