mirror of
https://github.com/0TheSpy/Seaside.git
synced 2025-01-04 00:23:31 +08:00
Add files via upload
This commit is contained in:
0TheSpy
GitHub
parent
41a13c2398
commit
a2fd672a3d
305
SpyCustom/filesystem_passthru.h
Normal file
305
SpyCustom/filesystem_passthru.h
Normal file
@ -0,0 +1,305 @@
|
||||
#ifndef FILESYSTEM_PASSTHRU_H
|
||||
#define FILESYSTEM_PASSTHRU_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
|
||||
#include "filesystem.h"
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#ifdef AsyncRead
|
||||
#undef AsyncRead
|
||||
#undef AsyncReadMutiple
|
||||
#endif
|
||||
|
||||
template<class Base>
|
||||
class CInternalFileSystemPassThru : public Base
|
||||
{
|
||||
public:
|
||||
CInternalFileSystemPassThru()
|
||||
{
|
||||
m_pBaseFileSystemPassThru = NULL;
|
||||
}
|
||||
virtual void InitPassThru(IBaseFileSystem* pBaseFileSystemPassThru)
|
||||
{
|
||||
m_pBaseFileSystemPassThru = pBaseFileSystemPassThru;
|
||||
}
|
||||
virtual int Read(void* pOutput, int size, FileHandle_t file) { return m_pBaseFileSystemPassThru->Read(pOutput, size, file); }
|
||||
virtual int Write(void const* pInput, int size, FileHandle_t file) { return m_pBaseFileSystemPassThru->Write(pInput, size, file); }
|
||||
virtual FileHandle_t Open(const char* pFileName, const char* pOptions, const char* pathID) { return m_pBaseFileSystemPassThru->Open(pFileName, pOptions, pathID); }
|
||||
virtual void Close(FileHandle_t file) { m_pBaseFileSystemPassThru->Close(file); }
|
||||
virtual void Seek(FileHandle_t file, int pos, FileSystemSeek_t seekType) { m_pBaseFileSystemPassThru->Seek(file, pos, seekType); }
|
||||
virtual unsigned int Tell(FileHandle_t file) { return m_pBaseFileSystemPassThru->Tell(file); }
|
||||
virtual unsigned int Size(FileHandle_t file) { return m_pBaseFileSystemPassThru->Size(file); }
|
||||
virtual unsigned int Size(const char* pFileName, const char* pPathID) { return m_pBaseFileSystemPassThru->Size(pFileName, pPathID); }
|
||||
virtual void Flush(FileHandle_t file) { m_pBaseFileSystemPassThru->Flush(file); }
|
||||
virtual bool Precache(const char* pFileName, const char* pPathID) { return m_pBaseFileSystemPassThru->Precache(pFileName, pPathID); }
|
||||
virtual bool FileExists(const char* pFileName, const char* pPathID) { return m_pBaseFileSystemPassThru->FileExists(pFileName, pPathID); }
|
||||
virtual bool IsFileWritable(char const* pFileName, const char* pPathID) { return m_pBaseFileSystemPassThru->IsFileWritable(pFileName, pPathID); }
|
||||
virtual bool SetFileWritable(char const* pFileName, bool writable, const char* pPathID) { return m_pBaseFileSystemPassThru->SetFileWritable(pFileName, writable, pPathID); }
|
||||
virtual long GetFileTime(const char* pFileName, const char* pPathID) { return m_pBaseFileSystemPassThru->GetFileTime(pFileName, pPathID); }
|
||||
virtual bool ReadFile(const char* pFileName, const char* pPath, CUtlBuffer& buf, int nMaxBytes = 0, int nStartingByte = 0, FSAllocFunc_t pfnAlloc = NULL) { return m_pBaseFileSystemPassThru->ReadFile(pFileName, pPath, buf, nMaxBytes, nStartingByte, pfnAlloc); }
|
||||
virtual bool WriteFile(const char* pFileName, const char* pPath, CUtlBuffer& buf) { return m_pBaseFileSystemPassThru->WriteFile(pFileName, pPath, buf); }
|
||||
virtual bool UnzipFile(const char* pFileName, const char* pPath, const char* pDestination) { return m_pBaseFileSystemPassThru->UnzipFile(pFileName, pPath, pDestination); }
|
||||
|
||||
protected:
|
||||
IBaseFileSystem* m_pBaseFileSystemPassThru;
|
||||
};
|
||||
|
||||
|
||||
class CBaseFileSystemPassThru : public CInternalFileSystemPassThru<IBaseFileSystem>
|
||||
{
|
||||
public:
|
||||
};
|
||||
|
||||
|
||||
class CFileSystemPassThru : public CInternalFileSystemPassThru<IFileSystem>
|
||||
{
|
||||
public:
|
||||
typedef CInternalFileSystemPassThru<IFileSystem> BaseClass;
|
||||
|
||||
CFileSystemPassThru()
|
||||
{
|
||||
m_pFileSystemPassThru = NULL;
|
||||
}
|
||||
virtual void InitPassThru(IFileSystem* pFileSystemPassThru, bool bBaseOnly)
|
||||
{
|
||||
if (!bBaseOnly)
|
||||
m_pFileSystemPassThru = pFileSystemPassThru;
|
||||
|
||||
BaseClass::InitPassThru(pFileSystemPassThru);
|
||||
}
|
||||
|
||||
virtual bool Connect(CreateInterfaceFn factory) { return m_pFileSystemPassThru->Connect(factory); }
|
||||
virtual void Disconnect() { m_pFileSystemPassThru->Disconnect(); }
|
||||
virtual void* QueryInterface(const char* pInterfaceName) { return m_pFileSystemPassThru->QueryInterface(pInterfaceName); }
|
||||
virtual InitReturnVal_t Init() { return m_pFileSystemPassThru->Init(); }
|
||||
virtual void Shutdown() { m_pFileSystemPassThru->Shutdown(); }
|
||||
virtual const AppSystemInfo_t* GetDependencies() { return m_pFileSystemPassThru->GetDependencies(); }
|
||||
virtual AppSystemTier_t GetTier() { return m_pFileSystemPassThru->GetTier(); }
|
||||
virtual void Reconnect(CreateInterfaceFn factory, const char* pInterfaceName) { m_pFileSystemPassThru->Reconnect(factory, pInterfaceName); }
|
||||
|
||||
virtual void RemoveAllSearchPaths(void) { m_pFileSystemPassThru->RemoveAllSearchPaths(); }
|
||||
virtual void AddSearchPath(const char* pPath, const char* pathID, SearchPathAdd_t addType) { m_pFileSystemPassThru->AddSearchPath(pPath, pathID, addType); }
|
||||
virtual bool RemoveSearchPath(const char* pPath, const char* pathID) { return m_pFileSystemPassThru->RemoveSearchPath(pPath, pathID); }
|
||||
virtual void RemoveFile(char const* pRelativePath, const char* pathID) { m_pFileSystemPassThru->RemoveFile(pRelativePath, pathID); }
|
||||
virtual bool RenameFile(char const* pOldPath, char const* pNewPath, const char* pathID) { return m_pFileSystemPassThru->RenameFile(pOldPath, pNewPath, pathID); }
|
||||
virtual void CreateDirHierarchy(const char* path, const char* pathID) { m_pFileSystemPassThru->CreateDirHierarchy(path, pathID); }
|
||||
virtual bool IsDirectory(const char* pFileName, const char* pathID) { return m_pFileSystemPassThru->IsDirectory(pFileName, pathID); }
|
||||
virtual void FileTimeToString(char* pStrip, int maxCharsIncludingTerminator, long fileTime) { m_pFileSystemPassThru->FileTimeToString(pStrip, maxCharsIncludingTerminator, fileTime); }
|
||||
virtual void SetBufferSize(FileHandle_t file, unsigned nBytes) { m_pFileSystemPassThru->SetBufferSize(file, nBytes); }
|
||||
virtual bool IsOk(FileHandle_t file) { return m_pFileSystemPassThru->IsOk(file); }
|
||||
virtual bool EndOfFile(FileHandle_t file) { return m_pFileSystemPassThru->EndOfFile(file); }
|
||||
virtual char* ReadLine(char* pOutput, int maxChars, FileHandle_t file) { return m_pFileSystemPassThru->ReadLine(pOutput, maxChars, file); }
|
||||
virtual int FPrintf(FileHandle_t file, const char* pFormat, ...)
|
||||
{
|
||||
char str[8192];
|
||||
va_list marker;
|
||||
va_start(marker, pFormat);
|
||||
_vsnprintf(str, sizeof(str), pFormat, marker);
|
||||
va_end(marker);
|
||||
return m_pFileSystemPassThru->FPrintf(file, "%s", str);
|
||||
}
|
||||
virtual CSysModule* LoadModule(const char* pFileName, const char* pPathID, bool bValidatedDllOnly) { return m_pFileSystemPassThru->LoadModule(pFileName, pPathID, bValidatedDllOnly); }
|
||||
virtual void UnloadModule(CSysModule* pModule) { m_pFileSystemPassThru->UnloadModule(pModule); }
|
||||
virtual const char* FindFirst(const char* pWildCard, FileFindHandle_t* pHandle) { return m_pFileSystemPassThru->FindFirst(pWildCard, pHandle); }
|
||||
virtual const char* FindNext(FileFindHandle_t handle) { return m_pFileSystemPassThru->FindNext(handle); }
|
||||
virtual bool FindIsDirectory(FileFindHandle_t handle) { return m_pFileSystemPassThru->FindIsDirectory(handle); }
|
||||
virtual void FindClose(FileFindHandle_t handle) { m_pFileSystemPassThru->FindClose(handle); }
|
||||
virtual void FindFileAbsoluteList(CUtlVector< CUtlString >& outAbsolutePathNames, const char* pWildCard, const char* pPathID) { m_pFileSystemPassThru->FindFileAbsoluteList(outAbsolutePathNames, pWildCard, pPathID); }
|
||||
virtual const char* GetLocalPath(const char* pFileName, char* pLocalPath, int localPathBufferSize) { return m_pFileSystemPassThru->GetLocalPath(pFileName, pLocalPath, localPathBufferSize); }
|
||||
virtual bool FullPathToRelativePath(const char* pFullpath, char* pRelative, int maxlen) { return m_pFileSystemPassThru->FullPathToRelativePath(pFullpath, pRelative, maxlen); }
|
||||
virtual bool GetCurrentDirectory(char* pDirectory, int maxlen) { return m_pFileSystemPassThru->GetCurrentDirectory(pDirectory, maxlen); }
|
||||
virtual void PrintOpenedFiles(void) { m_pFileSystemPassThru->PrintOpenedFiles(); }
|
||||
virtual void PrintSearchPaths(void) { m_pFileSystemPassThru->PrintSearchPaths(); }
|
||||
virtual void SetWarningFunc(void (*pfnWarning)(const char* fmt, ...)) { m_pFileSystemPassThru->SetWarningFunc(pfnWarning); }
|
||||
virtual void SetWarningLevel(FileWarningLevel_t level) { m_pFileSystemPassThru->SetWarningLevel(level); }
|
||||
virtual void AddLoggingFunc(void (*pfnLogFunc)(const char* fileName, const char* accessType)) { m_pFileSystemPassThru->AddLoggingFunc(pfnLogFunc); }
|
||||
virtual void RemoveLoggingFunc(FileSystemLoggingFunc_t logFunc) { m_pFileSystemPassThru->RemoveLoggingFunc(logFunc); }
|
||||
virtual FSAsyncStatus_t AsyncReadMultiple(const FileAsyncRequest_t* pRequests, int nRequests, FSAsyncControl_t* pControls) { return m_pFileSystemPassThru->AsyncReadMultiple(pRequests, nRequests, pControls); }
|
||||
virtual FSAsyncStatus_t AsyncReadMultipleCreditAlloc(const FileAsyncRequest_t* pRequests, int nRequests, const char* pszFile, int line, FSAsyncControl_t* pControls) { return m_pFileSystemPassThru->AsyncReadMultipleCreditAlloc(pRequests, nRequests, pszFile, line, pControls); }
|
||||
virtual FSAsyncStatus_t AsyncDirectoryScan(const char* pSearchSpec, bool recurseFolders, void* pContext, FSAsyncScanAddFunc_t pfnAdd, FSAsyncScanCompleteFunc_t pfnDone, FSAsyncControl_t* pControl = NULL) { return m_pFileSystemPassThru->AsyncDirectoryScan(pSearchSpec, recurseFolders, pContext, pfnAdd, pfnDone, pControl); }
|
||||
virtual FSAsyncStatus_t AsyncFinish(FSAsyncControl_t hControl, bool wait) { return m_pFileSystemPassThru->AsyncFinish(hControl, wait); }
|
||||
virtual FSAsyncStatus_t AsyncGetResult(FSAsyncControl_t hControl, void** ppData, int* pSize) { return m_pFileSystemPassThru->AsyncGetResult(hControl, ppData, pSize); }
|
||||
virtual FSAsyncStatus_t AsyncAbort(FSAsyncControl_t hControl) { return m_pFileSystemPassThru->AsyncAbort(hControl); }
|
||||
virtual FSAsyncStatus_t AsyncStatus(FSAsyncControl_t hControl) { return m_pFileSystemPassThru->AsyncStatus(hControl); }
|
||||
virtual FSAsyncStatus_t AsyncFlush() { return m_pFileSystemPassThru->AsyncFlush(); }
|
||||
virtual void AsyncAddRef(FSAsyncControl_t hControl) { m_pFileSystemPassThru->AsyncAddRef(hControl); }
|
||||
virtual void AsyncRelease(FSAsyncControl_t hControl) { m_pFileSystemPassThru->AsyncRelease(hControl); }
|
||||
virtual FSAsyncStatus_t AsyncBeginRead(const char* pszFile, FSAsyncFile_t* phFile) { return m_pFileSystemPassThru->AsyncBeginRead(pszFile, phFile); }
|
||||
virtual FSAsyncStatus_t AsyncEndRead(FSAsyncFile_t hFile) { return m_pFileSystemPassThru->AsyncEndRead(hFile); }
|
||||
virtual const FileSystemStatistics* GetFilesystemStatistics() { return m_pFileSystemPassThru->GetFilesystemStatistics(); }
|
||||
|
||||
|
||||
#if defined( _PS3 )
|
||||
virtual Ps3FileType_t GetPs3FileType(const char* path) { return PS3_FILETYPE_UNKNOWN; }
|
||||
virtual void LogFileAccess(const char* pFullFileName) { }
|
||||
|
||||
virtual bool PrefetchFile(const char* pFileName, int nPriority, bool bPersist) { return m_pFileSystemPassThru->PrefetchFile(pFileName, nPriority, bPersist); }
|
||||
virtual bool PrefetchFile(const char* pFileName, int nPriority, bool bPersist, int64 nOffset, int64 nSize) { return m_pFileSystemPassThru->PrefetchFile(pFileName, nPriority, bPersist, nOffset, nSize); }
|
||||
virtual void FlushCache() { m_pFileSystemPassThru->FlushCache(); }
|
||||
virtual void SuspendPrefetches(const char* pWhy) { m_pFileSystemPassThru->SuspendPrefetches(pWhy); }
|
||||
virtual void ResumePrefetches(const char* pWhy) { m_pFileSystemPassThru->ResumePrefetches(pWhy); }
|
||||
virtual void OnSaveStateChanged(bool bSaving) { m_pFileSystemPassThru->OnSaveStateChanged(bSaving); }
|
||||
virtual bool IsPrefetchingDone() { return m_pFileSystemPassThru->IsPrefetchingDone(); }
|
||||
#endif
|
||||
|
||||
virtual WaitForResourcesHandle_t WaitForResources(const char* resourcelist) { return m_pFileSystemPassThru->WaitForResources(resourcelist); }
|
||||
virtual bool GetWaitForResourcesProgress(WaitForResourcesHandle_t handle,
|
||||
float* progress, bool* complete) {
|
||||
return m_pFileSystemPassThru->GetWaitForResourcesProgress(handle, progress, complete);
|
||||
}
|
||||
virtual void CancelWaitForResources(WaitForResourcesHandle_t handle) { m_pFileSystemPassThru->CancelWaitForResources(handle); }
|
||||
virtual int HintResourceNeed(const char* hintlist, int forgetEverything) { return m_pFileSystemPassThru->HintResourceNeed(hintlist, forgetEverything); }
|
||||
virtual bool IsFileImmediatelyAvailable(const char* pFileName) { return m_pFileSystemPassThru->IsFileImmediatelyAvailable(pFileName); }
|
||||
virtual void GetLocalCopy(const char* pFileName) { m_pFileSystemPassThru->GetLocalCopy(pFileName); }
|
||||
virtual FileNameHandle_t FindOrAddFileName(char const* pFileName) { return m_pFileSystemPassThru->FindOrAddFileName(pFileName); }
|
||||
virtual FileNameHandle_t FindFileName(char const* pFileName) { return m_pFileSystemPassThru->FindFileName(pFileName); }
|
||||
virtual bool String(const FileNameHandle_t& handle, char* buf, int buflen) { return m_pFileSystemPassThru->String(handle, buf, buflen); }
|
||||
virtual bool IsOk2(FileHandle_t file) { return IsOk(file); }
|
||||
virtual void RemoveSearchPaths(const char* szPathID) { m_pFileSystemPassThru->RemoveSearchPaths(szPathID); }
|
||||
virtual bool IsSteam() const { return m_pFileSystemPassThru->IsSteam(); }
|
||||
virtual FilesystemMountRetval_t MountSteamContent(int nExtraAppId = -1) { return m_pFileSystemPassThru->MountSteamContent(nExtraAppId); }
|
||||
|
||||
virtual const char* FindFirstEx(
|
||||
const char* pWildCard,
|
||||
const char* pPathID,
|
||||
FileFindHandle_t* pHandle
|
||||
) {
|
||||
return m_pFileSystemPassThru->FindFirstEx(pWildCard, pPathID, pHandle);
|
||||
}
|
||||
virtual void MarkPathIDByRequestOnly(const char* pPathID, bool bRequestOnly) { m_pFileSystemPassThru->MarkPathIDByRequestOnly(pPathID, bRequestOnly); }
|
||||
virtual bool IsFileInReadOnlySearchPath(const char* pPath, const char* pathID) { return m_pFileSystemPassThru->IsFileInReadOnlySearchPath(pPath, pathID); }
|
||||
|
||||
virtual bool AddPackFile(const char* fullpath, const char* pathID) { return m_pFileSystemPassThru->AddPackFile(fullpath, pathID); }
|
||||
virtual FSAsyncStatus_t AsyncAppend(const char* pFileName, const void* pSrc, int nSrcBytes, bool bFreeMemory, FSAsyncControl_t* pControl) { return m_pFileSystemPassThru->AsyncAppend(pFileName, pSrc, nSrcBytes, bFreeMemory, pControl); }
|
||||
virtual FSAsyncStatus_t AsyncWrite(const char* pFileName, const void* pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend, FSAsyncControl_t* pControl) { return m_pFileSystemPassThru->AsyncWrite(pFileName, pSrc, nSrcBytes, bFreeMemory, bAppend, pControl); }
|
||||
virtual FSAsyncStatus_t AsyncWriteFile(const char* pFileName, const CUtlBuffer* pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend, FSAsyncControl_t* pControl) { return m_pFileSystemPassThru->AsyncWriteFile(pFileName, pSrc, nSrcBytes, bFreeMemory, bAppend, pControl); }
|
||||
virtual FSAsyncStatus_t AsyncAppendFile(const char* pDestFileName, const char* pSrcFileName, FSAsyncControl_t* pControl) { return m_pFileSystemPassThru->AsyncAppendFile(pDestFileName, pSrcFileName, pControl); }
|
||||
virtual void AsyncFinishAll(int iToPriority) { m_pFileSystemPassThru->AsyncFinishAll(iToPriority); }
|
||||
virtual void AsyncFinishAllWrites() { m_pFileSystemPassThru->AsyncFinishAllWrites(); }
|
||||
virtual FSAsyncStatus_t AsyncSetPriority(FSAsyncControl_t hControl, int newPriority) { return m_pFileSystemPassThru->AsyncSetPriority(hControl, newPriority); }
|
||||
virtual bool AsyncSuspend() { return m_pFileSystemPassThru->AsyncSuspend(); }
|
||||
virtual bool AsyncResume() { return m_pFileSystemPassThru->AsyncResume(); }
|
||||
virtual const char* RelativePathToFullPath(const char* pFileName, const char* pPathID, char* pLocalPath, int localPathBufferSize, PathTypeFilter_t pathFilter = FILTER_NONE, PathTypeQuery_t* pPathType = NULL) { return m_pFileSystemPassThru->RelativePathToFullPath(pFileName, pPathID, pLocalPath, localPathBufferSize, pathFilter, pPathType); }
|
||||
#if IsGameConsole()
|
||||
virtual bool GetPackFileInfoFromRelativePath(const char* pFileName, const char* pPathID, char* pPackPath, int nPackPathBufferSize, int64& nPosition, int64& nLength) { return m_pFileSystemPassThru->GetPackFileInfoFromRelativePath(pFileName, pPathID, pPackPath, nPackPathBufferSize, nPosition, nLength); }
|
||||
#endif
|
||||
|
||||
virtual int GetSearchPath(const char* pathID, bool bGetPackFiles, char* pPath, int nMaxLen) { return m_pFileSystemPassThru->GetSearchPath(pathID, bGetPackFiles, pPath, nMaxLen); }
|
||||
|
||||
virtual FileHandle_t OpenEx(const char* pFileName, const char* pOptions, unsigned flags = 0, const char* pathID = 0, char** ppszResolvedFilename = NULL) { return m_pFileSystemPassThru->OpenEx(pFileName, pOptions, flags, pathID, ppszResolvedFilename); }
|
||||
virtual int ReadEx(void* pOutput, int destSize, int size, FileHandle_t file) { return m_pFileSystemPassThru->ReadEx(pOutput, destSize, size, file); }
|
||||
virtual int ReadFileEx(const char* pFileName, const char* pPath, void** ppBuf, bool bNullTerminate, bool bOptimalAlloc, int nMaxBytes = 0, int nStartingByte = 0, FSAllocFunc_t pfnAlloc = NULL) { return m_pFileSystemPassThru->ReadFileEx(pFileName, pPath, ppBuf, bNullTerminate, bOptimalAlloc, nMaxBytes, nStartingByte, pfnAlloc); }
|
||||
|
||||
#if defined( TRACK_BLOCKING_IO )
|
||||
virtual void EnableBlockingFileAccessTracking(bool state) { m_pFileSystemPassThru->EnableBlockingFileAccessTracking(state); }
|
||||
virtual bool IsBlockingFileAccessEnabled() const { return m_pFileSystemPassThru->IsBlockingFileAccessEnabled(); }
|
||||
|
||||
virtual IBlockingFileItemList* RetrieveBlockingFileAccessInfo() { return m_pFileSystemPassThru->RetrieveBlockingFileAccessInfo(); }
|
||||
#endif
|
||||
virtual void SetupPreloadData() {}
|
||||
virtual void DiscardPreloadData() {}
|
||||
|
||||
virtual KeyValues* LoadKeyValues(KeyValuesPreloadType_t type, char const* filename, char const* pPathID = 0) { return m_pFileSystemPassThru->LoadKeyValues(type, filename, pPathID); }
|
||||
virtual bool LoadKeyValues(KeyValues& head, KeyValuesPreloadType_t type, char const* filename, char const* pPathID = 0) { return m_pFileSystemPassThru->LoadKeyValues(head, type, filename, pPathID); }
|
||||
|
||||
virtual bool GetFileTypeForFullPath(char const* pFullPath, OUT_Z_BYTECAP(bufSizeInBytes) wchar_t* buf, size_t bufSizeInBytes) { return m_pFileSystemPassThru->GetFileTypeForFullPath(pFullPath, buf, bufSizeInBytes); }
|
||||
|
||||
virtual bool GetOptimalIOConstraints(FileHandle_t hFile, unsigned* pOffsetAlign, unsigned* pSizeAlign, unsigned* pBufferAlign) { return m_pFileSystemPassThru->GetOptimalIOConstraints(hFile, pOffsetAlign, pSizeAlign, pBufferAlign); }
|
||||
virtual void* AllocOptimalReadBuffer(FileHandle_t hFile, unsigned nSize, unsigned nOffset) { return m_pFileSystemPassThru->AllocOptimalReadBuffer(hFile, nOffset, nSize); }
|
||||
virtual void FreeOptimalReadBuffer(void* p) { m_pFileSystemPassThru->FreeOptimalReadBuffer(p); }
|
||||
|
||||
virtual void BeginMapAccess() { m_pFileSystemPassThru->BeginMapAccess(); }
|
||||
virtual void EndMapAccess() { m_pFileSystemPassThru->EndMapAccess(); }
|
||||
|
||||
virtual bool ReadToBuffer(FileHandle_t hFile, CUtlBuffer& buf, int nMaxBytes = 0, FSAllocFunc_t pfnAlloc = NULL) { return m_pFileSystemPassThru->ReadToBuffer(hFile, buf, nMaxBytes, pfnAlloc); }
|
||||
virtual bool FullPathToRelativePathEx(const char* pFullPath, const char* pPathId, char* pRelative, int nMaxLen) { return m_pFileSystemPassThru->FullPathToRelativePathEx(pFullPath, pPathId, pRelative, nMaxLen); }
|
||||
virtual int GetPathIndex(const FileNameHandle_t& handle) { return m_pFileSystemPassThru->GetPathIndex(handle); }
|
||||
virtual long GetPathTime(const char* pPath, const char* pPathID) { return m_pFileSystemPassThru->GetPathTime(pPath, pPathID); }
|
||||
|
||||
virtual DVDMode_t GetDVDMode() { return m_pFileSystemPassThru->GetDVDMode(); }
|
||||
|
||||
virtual void EnableWhitelistFileTracking(bool bEnable, bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes)
|
||||
{
|
||||
m_pFileSystemPassThru->EnableWhitelistFileTracking(bEnable, bCacheAllVPKHashes, bRecalculateAndCheckHashes);
|
||||
}
|
||||
|
||||
virtual void RegisterFileWhitelist(IFileList* pForceMatchList, IFileList* pAllowFromDiskList, IFileList** pFilesToReload)
|
||||
{
|
||||
m_pFileSystemPassThru->RegisterFileWhitelist(pForceMatchList, pAllowFromDiskList, pFilesToReload);
|
||||
}
|
||||
virtual void MarkAllCRCsUnverified()
|
||||
{
|
||||
m_pFileSystemPassThru->MarkAllCRCsUnverified();
|
||||
}
|
||||
virtual void CacheFileCRCs(const char* pPathname, ECacheCRCType eType, IFileList* pFilter)
|
||||
{
|
||||
return m_pFileSystemPassThru->CacheFileCRCs(pPathname, eType, pFilter);
|
||||
}
|
||||
virtual EFileCRCStatus CheckCachedFileHash(const char* pPathID, const char* pRelativeFilename, int nFileFraction, FileHash_t* pFileHash)
|
||||
{
|
||||
return m_pFileSystemPassThru->CheckCachedFileHash(pPathID, pRelativeFilename, nFileFraction, pFileHash);
|
||||
}
|
||||
virtual int GetUnverifiedFileHashes(CUnverifiedFileHash* pFiles, int nMaxFiles)
|
||||
{
|
||||
return m_pFileSystemPassThru->GetUnverifiedFileHashes(pFiles, nMaxFiles);
|
||||
}
|
||||
virtual int GetWhitelistSpewFlags()
|
||||
{
|
||||
return m_pFileSystemPassThru->GetWhitelistSpewFlags();
|
||||
}
|
||||
virtual void SetWhitelistSpewFlags(int spewFlags)
|
||||
{
|
||||
m_pFileSystemPassThru->SetWhitelistSpewFlags(spewFlags);
|
||||
}
|
||||
virtual void InstallDirtyDiskReportFunc(FSDirtyDiskReportFunc_t func) { m_pFileSystemPassThru->InstallDirtyDiskReportFunc(func); }
|
||||
|
||||
virtual bool IsLaunchedFromXboxHDD() { return m_pFileSystemPassThru->IsLaunchedFromXboxHDD(); }
|
||||
virtual bool IsInstalledToXboxHDDCache() { return m_pFileSystemPassThru->IsInstalledToXboxHDDCache(); }
|
||||
virtual bool IsDVDHosted() { return m_pFileSystemPassThru->IsDVDHosted(); }
|
||||
virtual bool IsInstallAllowed() { return m_pFileSystemPassThru->IsInstallAllowed(); }
|
||||
virtual int GetSearchPathID(char* pPath, int nMaxLen) { return m_pFileSystemPassThru->GetSearchPathID(pPath, nMaxLen); }
|
||||
virtual bool FixupSearchPathsAfterInstall() { return m_pFileSystemPassThru->FixupSearchPathsAfterInstall(); }
|
||||
|
||||
virtual FSDirtyDiskReportFunc_t GetDirtyDiskReportFunc() { return m_pFileSystemPassThru->GetDirtyDiskReportFunc(); }
|
||||
|
||||
virtual void AddVPKFile(char const* pPkName, SearchPathAdd_t addType = PATH_ADD_TO_TAIL) { m_pFileSystemPassThru->AddVPKFile(pPkName, addType); }
|
||||
virtual void RemoveVPKFile(char const* pPkName) { m_pFileSystemPassThru->RemoveVPKFile(pPkName); }
|
||||
virtual void GetVPKFileNames(CUtlVector<CUtlString>& destVector) { m_pFileSystemPassThru->GetVPKFileNames(destVector); }
|
||||
|
||||
virtual void RemoveAllMapSearchPaths(void) { m_pFileSystemPassThru->RemoveAllMapSearchPaths(); }
|
||||
|
||||
virtual void SyncDvdDevCache(void) { m_pFileSystemPassThru->SyncDvdDevCache(); }
|
||||
|
||||
virtual bool GetStringFromKVPool(CRC32_t poolKey, unsigned int key, char* pOutBuff, int buflen) { return m_pFileSystemPassThru->GetStringFromKVPool(poolKey, key, pOutBuff, buflen); }
|
||||
|
||||
virtual bool DiscoverDLC(int iController) { return m_pFileSystemPassThru->DiscoverDLC(iController); }
|
||||
virtual int IsAnyDLCPresent(bool* pbDLCSearchPathMounted = NULL) { return m_pFileSystemPassThru->IsAnyDLCPresent(pbDLCSearchPathMounted); }
|
||||
virtual bool GetAnyDLCInfo(int iDLC, unsigned int* pLicenseMask, wchar_t* pTitleBuff, int nOutTitleSize) { return m_pFileSystemPassThru->GetAnyDLCInfo(iDLC, pLicenseMask, pTitleBuff, nOutTitleSize); }
|
||||
virtual int IsAnyCorruptDLC() { return m_pFileSystemPassThru->IsAnyCorruptDLC(); }
|
||||
virtual bool GetAnyCorruptDLCInfo(int iCorruptDLC, wchar_t* pTitleBuff, int nOutTitleSize) { return m_pFileSystemPassThru->GetAnyCorruptDLCInfo(iCorruptDLC, pTitleBuff, nOutTitleSize); }
|
||||
virtual bool AddDLCSearchPaths() { return m_pFileSystemPassThru->AddDLCSearchPaths(); }
|
||||
virtual bool IsSpecificDLCPresent(unsigned int nDLCPackage) { return m_pFileSystemPassThru->IsSpecificDLCPresent(nDLCPackage); }
|
||||
virtual void SetIODelayAlarm(float flThreshhold) { m_pFileSystemPassThru->SetIODelayAlarm(flThreshhold); }
|
||||
virtual bool AddXLSPUpdateSearchPath(const void* pData, int nSize) { return m_pFileSystemPassThru->AddXLSPUpdateSearchPath(pData, nSize); }
|
||||
virtual IIoStats* GetIoStats() { return m_pFileSystemPassThru->GetIoStats(); }
|
||||
|
||||
virtual void CacheAllVPKFileHashes(bool bCacheAllVPKHashes, bool bRecalculateAndCheckHashes)
|
||||
{
|
||||
return m_pFileSystemPassThru->CacheAllVPKFileHashes(bCacheAllVPKHashes, bRecalculateAndCheckHashes);
|
||||
}
|
||||
virtual bool CheckVPKFileHash(int PackFileID, int nPackFileNumber, int nFileFraction, MD5Value_t& md5Value)
|
||||
{
|
||||
return m_pFileSystemPassThru->CheckVPKFileHash(PackFileID, nPackFileNumber, nFileFraction, md5Value);
|
||||
}
|
||||
virtual void GetVPKFileStatisticsKV(KeyValues* pKV) { m_pFileSystemPassThru->GetVPKFileStatisticsKV(pKV); }
|
||||
|
||||
protected:
|
||||
IFileSystem* m_pFileSystemPassThru;
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
Loading…
x
Reference in New Issue
Block a user