PlatformIoDispatcher.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "IO/IoDispatcherPriority.h"
#include "IO/IoStatus.h"
#include "IO/IoBuffer.h"
#include "Logging/LogMacros.h"
#include "Math/NumericLimits.h"
#include "Memory/MemoryFwd.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/Function.h"
#include "UObject/NameTypes.h"
 
#if !defined(PLATFORM_IMPLEMENTS_IO)
#define PLATFORM_IMPLEMENTS_IO 0
#endif
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogPlatformIoDispatcher, Log, All);
 
namespace UE
{
 
struct FIoFileHandle
{
            FIoFileHandle() = default;
            explicit FIoFileHandle(uint64 InHandle)
                : Handle(InHandle)
            { }
 
    uint64  Value() const { return Handle; }
    bool    IsValid() const { return Handle != 0; }
 
    friend uint32 GetTypeHash(FIoFileHandle FileHandle) { return GetTypeHash(FileHandle.Handle); }
    friend  bool operator==(FIoFileHandle LHS, FIoFileHandle RHS) { return LHS.Handle == RHS.Handle; }
    friend  bool operator!=(FIoFileHandle LHS, FIoFileHandle RHS) { return LHS.Handle != RHS.Handle; }
    friend  bool operator<(FIoFileHandle LHS, FIoFileHandle RHS) { return LHS.Handle < RHS.Handle; }
 
private:
    uint64 Handle = 0;
};
 
struct FIoFileStat
{
    uint64 FileSize = 0;
};
 
enum class EIoFilePropertyFlags : uint8
{
    None        = 0,
    Encrypted   = (1 << 0),
    Signed      = (1 << 1)
};
ENUM_CLASS_FLAGS(EIoFilePropertyFlags);
 
struct FIoFileProperties
{
    TConstArrayView<FName>  CompressionMethods;
    uint32                  CompressionBlockSize = 0; 
    EIoFilePropertyFlags    Flags = EIoFilePropertyFlags::None;
};
 
struct FIoFileReadRequest
{
            FIoFileReadRequest() = default;
            explicit FIoFileReadRequest(uint64 InHandle)
                : Handle(InHandle)
            { }
 
    uint64  Value() const { return Handle; }
    bool    IsValid() const { return Handle != 0; }
 
private:
    uint64 Handle = 0;
};
 
class FIoScatterGatherRequestParams
{
public:
    struct FScatterParams
    {
        uint64      BlockFileOffset         = 0;
        uint32      BlockCompressedSize     = 0;
        uint32      BlockUncompresedSize    = 0;
        uint64      ScatterOffset           = 0;
        uint64      ScatterSize             = 0;
        uint64      DestinationOffset       = 0;
        uint32      BlockIndex              = MAX_uint32;
        FName       CompressionMethod       = NAME_None;
        FMemoryView EncryptionKey;
        FMemoryView BlockHash;
    };
 
    using FScatterParamsArray = TArray<FScatterParams, TInlineAllocator<4>>;
 
    FIoScatterGatherRequestParams(
        FIoFileHandle InFileHandle,
        FIoBuffer& InDestination,
        uint64 InDestinationSize,
        void* InUserData,
        int32 InPriority)
            : FileHandle(InFileHandle)
            , Destination(InDestination)
            , DestinationSize(InDestinationSize)
            , UserData(InUserData)
            , Priority(InPriority)
    { }
 
    void Scatter(
        uint64 BlockFileOffset,
        uint32 BlockIndex,
        uint32 BlockCompressedSize,
        uint32 BlockUncompresedSize,
        uint64 ScatterOffset,
        uint64 ScatterSize,
        uint64 DestinationOffset,
        FName CompressionMethod,
        FMemoryView EncryptionKey,
        FMemoryView BlockHash)
    {
        Params.Add(FScatterParams
        {
            .BlockFileOffset        = BlockFileOffset,
            .BlockCompressedSize    = BlockCompressedSize,
            .BlockUncompresedSize   = BlockUncompresedSize,
            .ScatterOffset          = ScatterOffset,
            .ScatterSize            = ScatterSize,
            .DestinationOffset      = DestinationOffset,
            .BlockIndex             = BlockIndex,
            .CompressionMethod      = CompressionMethod,
            .EncryptionKey          = EncryptionKey,
            .BlockHash              = BlockHash
        });
    }
 
    FIoFileHandle           FileHandle;
    FIoBuffer&              Destination;
    uint64                  DestinationSize;
    void*                   UserData;
    int32                   Priority;
    FScatterParamsArray     Params;
};
 
struct FIoFileReadResult
{
    void*           UserData        = nullptr;
    uint32          FailedBlockId   = MAX_uint32;
    EIoErrorCode    ErrorCode       = EIoErrorCode::Unknown;
};
 
using FIoFileReadRequestCompleted = TUniqueFunction<void(FIoFileReadResult&&)>;
 
struct FIoDirectReadRequestParams
{
    FIoFileHandle   FileHandle;
    FIoBuffer&      Dst;
    uint64          Offset      = MAX_uint64;
    uint64          Size        = 0;
    void*           UserData    = nullptr;
};
 
struct FPlatformIoDispatcherCreateParams
{
    bool bMultithreaded = true;
    bool bForceGeneric  = false;
};
 
class IPlatformIoDispatcher
{
public:
    virtual                                     ~IPlatformIoDispatcher() = default;
    virtual FIoStatus                           Initialize() = 0;
    virtual TIoStatusOr<FIoFileHandle>          OpenFile(const TCHAR* Filename, const FIoFileProperties& FileProperties, FIoFileStat* OutStat = nullptr) = 0;
    virtual FIoStatus                           CloseFile(FIoFileHandle FileHandle) = 0;
    [[nodiscard]] virtual FIoFileReadRequest    ScatterGather(FIoScatterGatherRequestParams&& Params, FIoFileReadRequestCompleted&& OnCompleted) = 0;
    [[nodiscard]] virtual FIoFileReadRequest    ReadDirect(FIoDirectReadRequestParams&& Params, FIoFileReadRequestCompleted&& OnCompleted) = 0;
    virtual bool                                Tick() = 0;
    virtual void                                UpdatePriority(FIoFileReadRequest Request, int32 NewPriority) = 0;
    virtual void                                CancelRequest(FIoFileReadRequest Request) = 0;
    virtual void                                CancelAllRequests(FIoFileHandle FileHandle) = 0;
    virtual void                                DeleteRequest(FIoFileReadRequest Request) = 0;
};
 
class FPlatformIoDispatcher
{
public:
    CORE_API static void                    Create(FPlatformIoDispatcherCreateParams&& Config);
    CORE_API static void                    Initialize();
    CORE_API static void                    Shutdown();
    CORE_API static IPlatformIoDispatcher&  Get();
    CORE_API static IPlatformIoDispatcher*  TryGet();
};
 
} // namespace UE