FileManagerGeneric.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "GenericPlatform/GenericPlatformFile.h"
#include "HAL/FileManager.h"
#include "HAL/PlatformFileManager.h"
#include "Misc/DateTime.h"
#include "Serialization/Archive.h"
#include "Templates/UniquePtr.h"
 
#ifndef PLATFORM_FILE_READER_BUFFER_SIZE
 #define PLATFORM_FILE_READER_BUFFER_SIZE 1024
#endif
 
#ifndef PLATFORM_FILE_WRITER_BUFFER_SIZE
 #define PLATFORM_FILE_WRITER_BUFFER_SIZE 4096
#endif 
 
#ifndef PLATFORM_DEBUG_FILE_WRITER_BUFFER_SIZE
 #define PLATFORM_DEBUG_FILE_WRITER_BUFFER_SIZE 4096
#endif 
 
class FFileManagerGeneric
    : public IFileManager
{
    // instead of caching the LowLevel, we call the singleton each time to never be incorrect
    UE_FORCEINLINE_HINT IPlatformFile& GetLowLevel() const
    {
        return FPlatformFileManager::Get().GetPlatformFile();
    }
 
public:
 
    FFileManagerGeneric( ) { }
 
    virtual ~FFileManagerGeneric( ) { }
 
public:
 
    // IFileManager interface
 
    CORE_API virtual void ProcessCommandLineOptions() override;
 
    virtual void SetSandboxEnabled(bool bInEnabled) override
    {
        GetLowLevel().SetSandboxEnabled(bInEnabled);
    }
 
    virtual bool IsSandboxEnabled() const override
    {
        return GetLowLevel().IsSandboxEnabled();
    }
 
    FArchive* CreateFileReader( const TCHAR* Filename, uint32 ReadFlags=0 ) override
    {
        return CreateFileReaderInternal( Filename, ReadFlags, PLATFORM_FILE_READER_BUFFER_SIZE );
    }
 
    FArchive* CreateFileWriter( const TCHAR* Filename, uint32 WriteFlags=0 ) override
    {
        return CreateFileWriterInternal( Filename, WriteFlags, PLATFORM_FILE_WRITER_BUFFER_SIZE );
    }
 
#if ALLOW_DEBUG_FILES
    FArchive* CreateDebugFileWriter( const TCHAR* Filename, uint32 WriteFlags=0 ) override
    {
        return CreateFileWriterInternal( Filename, WriteFlags, PLATFORM_DEBUG_FILE_WRITER_BUFFER_SIZE );
    }
#endif
 
    CORE_API bool Delete( const TCHAR* Filename, bool RequireExists=0, bool EvenReadOnly=0, bool Quiet=0 ) override;
    CORE_API bool IsReadOnly( const TCHAR* Filename ) override;
    CORE_API bool Move( const TCHAR* Dest, const TCHAR* Src, bool Replace=1, bool EvenIfReadOnly=0, bool Attributes=0, bool bDoNotRetryOrError=0 ) override;
    CORE_API bool FileExists( const TCHAR* Filename ) override;
    CORE_API bool DirectoryExists(const TCHAR* InDirectory) override;
    CORE_API void FindFiles( TArray<FString>& Result, const TCHAR* Filename, bool Files, bool Directories ) override;
    CORE_API void FindFilesRecursive( TArray<FString>& FileNames, const TCHAR* StartDirectory, const TCHAR* Filename, bool Files, bool Directories, bool bClearFileNames=true) override;
    CORE_API double GetFileAgeSeconds( const TCHAR* Filename ) override;
    CORE_API FDateTime GetTimeStamp( const TCHAR* Filename ) override;
    CORE_API FDateTime GetAccessTimeStamp( const TCHAR* Filename ) override;
    CORE_API void GetTimeStampPair(const TCHAR* PathA, const TCHAR* PathB, FDateTime& OutTimeStampA, FDateTime& OutTimeStampB);
    CORE_API bool SetTimeStamp( const TCHAR* Filename, FDateTime Timestamp ) override;
    CORE_API virtual FString GetFilenameOnDisk(const TCHAR* Filename) override;
 
    CORE_API virtual uint32 Copy( const TCHAR* Dest, const TCHAR* Src, bool Replace = 1, bool EvenIfReadOnly = 0, bool Attributes = 0, FCopyProgress* Progress = nullptr, EFileRead ReadFlags = FILEREAD_None, EFileWrite WriteFlags = FILEWRITE_None ) override;
    CORE_API virtual bool   MakeDirectory( const TCHAR* Path, bool Tree=0 ) override;
    CORE_API virtual bool   DeleteDirectory( const TCHAR* Path, bool RequireExists=0, bool Tree=0 ) override;
 
    CORE_API virtual FFileStatData GetStatData(const TCHAR* FilenameOrDirectory) override;
 
    CORE_API virtual void FindFiles(TArray<FString>& FoundFiles, const TCHAR* Directory, const TCHAR* FileExtension = nullptr) override;
 
    CORE_API bool IterateDirectory(const TCHAR* Directory, IPlatformFile::FDirectoryVisitor& Visitor) override;
    CORE_API bool IterateDirectory(const TCHAR* Directory, IPlatformFile::FDirectoryVisitorFunc Visitor) override;
 
    CORE_API bool IterateDirectoryRecursively(const TCHAR* Directory, IPlatformFile::FDirectoryVisitor& Visitor) override;
    CORE_API bool IterateDirectoryRecursively(const TCHAR* Directory, IPlatformFile::FDirectoryVisitorFunc Visitor) override;
 
    CORE_API bool IterateDirectoryStat(const TCHAR* Directory, IPlatformFile::FDirectoryStatVisitor& Visitor) override;
    CORE_API bool IterateDirectoryStat(const TCHAR* Directory, IPlatformFile::FDirectoryStatVisitorFunc Visitor) override;
 
    CORE_API bool IterateDirectoryStatRecursively(const TCHAR* Directory, IPlatformFile::FDirectoryStatVisitor& Visitor) override;
    CORE_API bool IterateDirectoryStatRecursively(const TCHAR* Directory, IPlatformFile::FDirectoryStatVisitorFunc Visitor) override;
 
    static CORE_API FString DefaultConvertToRelativePath( const TCHAR* Filename );
 
    CORE_API FString ConvertToRelativePath( const TCHAR* Filename ) override;
 
    CORE_API FString ConvertToAbsolutePathForExternalAppForRead( const TCHAR* Filename ) override;
 
    CORE_API FString ConvertToAbsolutePathForExternalAppForWrite( const TCHAR* Filename ) override;
 
    CORE_API int64 FileSize( const TCHAR* Filename ) override;
 
    virtual bool SendMessageToServer(const TCHAR* Message, IPlatformFile::IFileServerMessageHandler* Handler) override
    {
        return GetLowLevel().SendMessageToServer(Message, Handler);
    }
 
private:
    CORE_API FArchive * CreateFileReaderInternal(const TCHAR* Filename, uint32 ReadFlags, uint32 BufferSize);
    CORE_API FArchive* CreateFileWriterInternal(const TCHAR* Filename, uint32 WriteFlags, uint32 BufferSize);
 
    CORE_API uint32 CopyWithProgress(const TCHAR* InDestFile, const TCHAR* InSrcFile, bool ReplaceExisting, bool EvenIfReadOnly, bool Attributes, FCopyProgress* Progress, EFileRead ReadFlags, EFileWrite WriteFlags);
 
    CORE_API void FindFilesRecursiveInternal( TArray<FString>& FileNames, const TCHAR* StartDirectory, const TCHAR* Filename, bool Files, bool Directories);
};
 
 
/*-----------------------------------------------------------------------------
    FArchiveFileReaderGeneric
-----------------------------------------------------------------------------*/
 
class FArchiveFileReaderGeneric : public FArchive
{
public:
    CORE_API FArchiveFileReaderGeneric( IFileHandle* InHandle, const TCHAR* InFilename, int64 InSize, uint32 InBufferSize = PLATFORM_FILE_READER_BUFFER_SIZE, uint32 InFlags = FILEREAD_None );
    CORE_API ~FArchiveFileReaderGeneric();
 
    CORE_API virtual void Seek( int64 InPos ) override final;
    virtual int64 Tell() override final
    {
        return Pos;
    }
    virtual int64 TotalSize() override final
    {
        return Size;
    }
    CORE_API virtual bool Close() override final;
    CORE_API virtual void Serialize( void* V, int64 Length ) override final;
    virtual FString GetArchiveName() const override
    {
        return Filename;
    }
    CORE_API virtual void FlushCache() override final;
 
    CORE_API virtual bool Precache(int64 PrecacheOffset, int64 PrecacheSize) override;
 
protected:
    CORE_API bool InternalPrecache( int64 PrecacheOffset, int64 PrecacheSize );
    CORE_API virtual bool SeekLowLevel(int64 InPos);
    CORE_API virtual void CloseLowLevel();
    CORE_API virtual void ReadLowLevel(uint8* Dest, int64 CountToRead, int64& OutBytesRead);
 
    bool IsSilent() const
    {
        return !!(Flags & FILEREAD_Silent);
    }
 
    FString Filename;
    int64 Size;
    int64 Pos;
    int64 BufferBase;
    TUniquePtr<IFileHandle> Handle;
    TArray64<uint8> BufferArray;
    int64 BufferSize;
    uint32 Flags;
    bool bFirstReadAfterSeek;
 
    enum
    {
        bPrecacheAsSoonAsPossible = 0 // Setting this to true makes it more likely bytes will be available without waiting due to external Precache calls, but at the cost of a larger number of read requests.
    };
 
    friend class FArchiveFileReaderGenericTest;
};
 
 
/*-----------------------------------------------------------------------------
    FArchiveFileWriterGeneric
-----------------------------------------------------------------------------*/
 
class FArchiveFileWriterGeneric : public FArchive
{
public:
    CORE_API FArchiveFileWriterGeneric( IFileHandle* InHandle, const TCHAR* InFilename, int64 InPos, uint32 InBufferSize = PLATFORM_FILE_WRITER_BUFFER_SIZE, uint32 InFlags = FILEWRITE_None);
    CORE_API ~FArchiveFileWriterGeneric();
 
    CORE_API virtual void Seek( int64 InPos ) override final;
    virtual int64 Tell() override final
    {
        return Pos;
    }
    CORE_API virtual int64 TotalSize() override;
    CORE_API virtual bool Close() override final;
    CORE_API virtual void Serialize( void* V, int64 Length ) override final;
    CORE_API virtual void Flush() override final;
    virtual FString GetArchiveName() const override
    {
        return Filename;
    }
 
protected:
    CORE_API bool FlushBuffer();
    CORE_API virtual bool SeekLowLevel(int64 InPos);
    CORE_API virtual bool CloseLowLevel();
    CORE_API virtual bool WriteLowLevel(const uint8* Src, int64 CountToWrite);
 
    UE_DEPRECATED(5.6, "Pass in LastError from FPlatformMisc::GetLastError")
    CORE_API void LogWriteError(const TCHAR* Message);
    CORE_API void LogWriteError(const TCHAR* Message, uint32 LastError);
 
    bool IsSilent() const
    {
        return !!(Flags & FILEWRITE_Silent);
    }
 
    FString Filename;
    uint32 Flags;
    int64 Pos;
    TUniquePtr<IFileHandle> Handle;
    TArray64<uint8> BufferArray;
    int64 BufferSize;
    bool bLoggingError;
};