OutputDeviceFile.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "CoreTypes.h"
#include "HAL/CriticalSection.h"
#include "HAL/Runnable.h"
#include "HAL/ThreadSafeCounter.h"
#include "Logging/LogVerbosity.h"
#include "Misc/OutputDevice.h"
#include "Misc/ScopeLock.h"
#include "Misc/SingleThreadRunnable.h"
#include "Serialization/Archive.h"
#include "Templates/Atomic.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
#include "UObject/NameTypes.h"
 
class FRunnableThread;
 
 
#define BACKUP_LOG_FILENAME_POSTFIX TEXT("-backup-")
 
class FAsyncWriter : public FRunnable, public FSingleThreadRunnable, public FArchive
{
    volatile FRunnableThread* Thread;
    FThreadSafeCounter StopTaskCounter;
 
    FArchive& Ar;
    TArray<uint8> Buffer;
    TAtomic<int32> BufferStartPos;
    TAtomic<int32> BufferEndPos;
    FCriticalSection BufferPosCritical;
    FThreadSafeCounter SerializeRequestCounter;
    FThreadSafeCounter WantsArchiveFlush;
    FCriticalSection RunCritical;
 
    double LastArchiveFlushTime;
 
    CORE_API void FlushArchiveAndResetTimer();
 
    CORE_API void SerializeBufferToArchive();
 
    CORE_API void FlushBuffer();
 
public:
 
    enum class EThreadNameOption : uint8
    {
        FileName,   // Appends the filename in the threadname: FAsyncWriter_FileName
        Sequential, // Uses a global sequential number to append to the threadname: FAsyncWriter_1
    };
 
    CORE_API FAsyncWriter(FArchive& InAr, FAsyncWriter::EThreadNameOption NameOption=FAsyncWriter::EThreadNameOption::FileName);
 
    CORE_API virtual ~FAsyncWriter();
 
    CORE_API virtual void Serialize(void* InData, int64 Length) override;
 
    CORE_API void Flush();
 
    //~ Begin FRunnable Interface.
    CORE_API virtual bool Init();
    CORE_API virtual uint32 Run();
    CORE_API virtual void Stop();
    virtual FSingleThreadRunnable* GetSingleThreadInterface() override { return this; }
    //~ End FRunnable Interface
 
protected:
    //~ Begin FSingleThreadRunnable Interface.
    CORE_API virtual void Tick() override;
    //~ End FSingleThreadRunnable Interface
 
};
 
enum class EByteOrderMark : int8
{
    UTF8,
    Unspecified,
};
 
class FOutputDeviceFile : public FOutputDevice
{
public:
    CORE_API FOutputDeviceFile(const TCHAR* InFilename = nullptr, bool bDisableBackup = false, bool bAppendIfExists = false, bool bCreateWriterLazily = true, TFunction<void(const TCHAR*)> FileOpenedCallback = TFunction<void(const TCHAR*)>());
 
    CORE_API ~FOutputDeviceFile();
 
    CORE_API void SetFilename(const TCHAR* InFilename);
 
    //~ Begin FOutputDevice Interface.
    CORE_API void TearDown() override;
 
    CORE_API void Flush() override;
 
    CORE_API virtual void Serialize(const TCHAR* Data, ELogVerbosity::Type Verbosity, const class FName& Category, const double Time) override;
    CORE_API virtual void Serialize(const TCHAR* Data, ELogVerbosity::Type Verbosity, const class FName& Category) override;
    virtual bool CanBeUsedOnAnyThread() const override
    {
        return true;
    }
    virtual bool CanBeUsedOnPanicThread() const override
    {
        return true;
    }
    //~ End FOutputDevice Interface.
 
    static CORE_API void CreateBackupCopy(const TCHAR* Filename);
 
    static CORE_API bool IsBackupCopy(const TCHAR* Filename);
 
    CORE_API void IncludeCategory(const class FName& InCategoryName);
 
    const TCHAR* GetFilename() const { return Filename; }
 
    CORE_API bool IsOpened() const;
 
private:
 
    FAsyncWriter* AsyncWriter;
    FArchive* WriterArchive;
    TFunction<void(const TCHAR*)> OnFileOpenedFn;
 
    TCHAR Filename[1024];
    bool AppendIfExists;
    bool Dead;
    bool bCreatingWriter;
 
    bool bDisableBackup;
 
    struct FCategoryInclusionInternal;
 
    TUniquePtr<FCategoryInclusionInternal> CategoryInclusionInternal;
 
    CORE_API void WriteRaw(const TCHAR* C);
 
    CORE_API bool CreateWriter(uint32 MaxAttempts = 32);
 
    CORE_API void WriteByteOrderMarkToArchive(EByteOrderMark ByteOrderMark);
};