ULogFile Class Reference

#include <LogFile.h>

Inheritance diagram for ULogFile:

Collaboration diagram for ULogFile:

Public Member Functions
	ULogFile ()
	~ULogFile ()
void	Create (const FString &FileNameWithoutExtension, FLogFileSettings Settings)
void	Write (const FString &Text)
void	Close ()
void	Clear ()
void	Destroy ()
void	OpenFilePath ()
FString	GetLogFilePath ()

Static Public Member Functions
static ULogFile *	CreateLogFile (const FString &FileNameWithoutExtension, FLogFileSettings Settings=FLogFileSettings())

Private Member Functions
void	WriteQueuedMessages ()
void	WriteToFile (const FString &Text, bool UseTimestamp)

Private Attributes
TArray< FString >	MessageQueue
FLogFileSettings	CurrentSettings
FString	FilePath
std::ofstream	LogFileStream

Detailed Description

LogFile is a Blueprintable class that allows .txt file creation and writing into it. The .txt file is created in the ROOT/Data/ directory.

Definition at line 62 of file LogFile.h.

Constructor & Destructor Documentation

ULogFile()

ULogFile::ULogFile

(

)

Definition at line 29 of file LogFile.cpp.

{
 
}

~ULogFile()

ULogFile::~ULogFile

(

)

Definition at line 34 of file LogFile.cpp.

{
    WriteQueuedMessages();
    Close();
}

References Close(), and WriteQueuedMessages().

Member Function Documentation

Clear()

void ULogFile::Clear

(

)

Clear the file if it exists.

Definition at line 165 of file LogFile.cpp.

{
    if (std::filesystem::exists(TCHAR_TO_UTF8(*FilePath)))
    {
        std::ofstream clearFile(TCHAR_TO_UTF8(*FilePath), std::ofstream::out | std::ofstream::trunc);
        clearFile.close();
    }
}

References FilePath.

Referenced by Create().

Close()

void ULogFile::Close

(

)

Close the file if it's open.

Definition at line 157 of file LogFile.cpp.

{
    if (LogFileStream.is_open())
    {
        LogFileStream.close();
    }
}

References LogFileStream.

Referenced by Destroy(), and ~ULogFile().

Create()

void ULogFile::Create	(	const FString &	FileNameWithoutExtension,
		FLogFileSettings	Settings
	)

Create the log file.

Parameters

FileNameWithoutExtension	The name of the log file without extension.
Settings	The settings for creating the log file.

Definition at line 40 of file LogFile.cpp.

{
    CurrentSettings = Settings;
 
    FString ProjectPath = UAgrarsensePaths::GetDataFolder();
    FString Folder = FString("/Logs/");
    FString LogDirPath = FPaths::Combine(*ProjectPath, *Folder);
 
    if (!std::filesystem::exists(TCHAR_TO_UTF8(*LogDirPath)))
    {
        if (!std::filesystem::create_directory(TCHAR_TO_UTF8(*LogDirPath)))
        {
            // Failed to create the directory, return
            return;
        }
    }
 
    FString LogFilePath;
 
    if (Settings.OverrideFilePath && !Settings.FilePath.IsEmpty()) 
    {
        if (!std::filesystem::exists(TCHAR_TO_UTF8(*Settings.FilePath)))
        {
            bool created = std::filesystem::create_directories(TCHAR_TO_UTF8(*Settings.FilePath));
        }
        LogFilePath = FPaths::Combine(*Settings.FilePath, *FileNameWithoutExtension) + TEXT(".txt");
    }
    else 
    {
        LogFilePath = FPaths::Combine(*LogDirPath, *FileNameWithoutExtension) + TEXT(".txt");
    }
 
    FilePath = LogFilePath;
 
    switch (CurrentSettings.FileCreationOptions)
    {
    case FFileCreationOptions::Overwrite:
        // Clear file if it exists
        Clear();
        break;
 
    case FFileCreationOptions::Append:
        // Append to existing file if it exists
        break;
 
    case FFileCreationOptions::CreateUnique:
    {
        // Create unique file by adding number to the end until we find unique filename
        int suffix = 0;
        FString UniqueFileName = FileNameWithoutExtension + TEXT("_") + FString::FromInt(suffix++);
        FString UniqueLogFilePath = FPaths::Combine(*LogDirPath, *UniqueFileName) + TEXT(".txt");
 
        while (std::filesystem::exists(TCHAR_TO_UTF8(*UniqueLogFilePath)))
        {
            UniqueFileName = FileNameWithoutExtension + TEXT("_") + FString::FromInt(suffix++) + TEXT(".txt");
            UniqueLogFilePath = FPaths::Combine(*LogDirPath, *UniqueFileName);
        }
 
        LogFilePath = UniqueLogFilePath;
        break;
    }
 
    default:
        break;
    }
 
    // Try to create the .txt file
    std::ofstream newFile(TCHAR_TO_UTF8(*LogFilePath), std::ios::app);
    if (newFile.is_open())
    {
        newFile.close();
    }
    else
    {
        std::ifstream file(TCHAR_TO_UTF8(*LogFilePath));
        if (file.good())
        {
            // The file already exists, return
            file.close();
        }
    }
}

References Append, Clear(), CreateUnique, CurrentSettings, FLogFileSettings::FileCreationOptions, FLogFileSettings::FilePath, FilePath, UAgrarsensePaths::GetDataFolder(), FLogFileSettings::OverrideFilePath, and Overwrite.

Referenced by ASensor::CreateLogFile(), ACamera::CreateLogFile(), ACollisionSensor::CreateLogFile(), ALidar::CreateLogFile(), AOverlapSensor::CreateLogFile(), ATransformSensor::CreateLogFile(), and CreateLogFile().

CreateLogFile()

ULogFile * ULogFile::CreateLogFile ( const FString &  FileNameWithoutExtension, FLogFileSettings  Settings = FLogFileSettings()  )

static

Static way of creating a ULogFile instance and creating the file at the same time.

Parameters

FileNameWithoutExtension	The name of the log file without extension.
Settings	(Optional) The settings for creating the log file. Default is an empty settings object.

Returns

A pointer to the created ULogFile instance or nullptr.

Definition at line 17 of file LogFile.cpp.

{
    ULogFile* LogFile = NewObject<ULogFile>(ULogFile::StaticClass());
    LogFile->AddToRoot();
    if (LogFile)
    {
        LogFile->Create(FileNameWithoutExtension, Settings);
    }
 
    return LogFile;
}

References Create().

Referenced by SimulatorLog::Create().

Destroy()

void ULogFile::Destroy

(

)

Start destroying this UObject.

Definition at line 174 of file LogFile.cpp.

{
    if (IsValid(this))
    {
        WriteQueuedMessages();
        Close();
        ConditionalBeginDestroy();
    }
}

References Close(), and WriteQueuedMessages().

Referenced by ASensor::EndPlay(), and SimulatorLog::Shutdown().

GetLogFilePath()

FString ULogFile::GetLogFilePath ( )

inline

Get the full file path as an FString.

Definition at line 123 of file LogFile.h.

    {
        return FilePath;
    }

OpenFilePath()

void ULogFile::OpenFilePath

(

)

Open the file explorer at the path of the file.

Definition at line 184 of file LogFile.cpp.

{
    UFileUtilities::OpenFileExplorer(FilePath);
}

References FilePath, and UFileUtilities::OpenFileExplorer().

Write()

void ULogFile::Write

(

const FString &

Text

)

Write a message to the file.

Parameters

Text	The text message to write to the log file.

Definition at line 123 of file LogFile.cpp.

{
    if (FilePath.IsEmpty() || !IsValid(this))
    {
        return;
    }
 
    if (CurrentSettings.FileWriteOptions == FFileWriteOptions::Queue)
    {
        if (MessageQueue.Num() == CurrentSettings.QueueLength)
        {
            WriteQueuedMessages();
        }
        else
        {
            // Add message to queue (with timestamp if CurrentSettings.Timestamp) and return
            FString MessageToAdd = Text;
            if (CurrentSettings.Timestamp)
            {
                std::time_t now = std::time(nullptr);
                std::tm tm_time = *std::localtime(&now);
                char timestamp[12];
                std::strftime(timestamp, sizeof(timestamp), "[%H:%M:%S] ", &tm_time);
                MessageToAdd = FString(timestamp) + Text;
            }
            MessageQueue.Add(MessageToAdd);
        }
 
        return;
    }
 
    WriteToFile(Text, true);
}

References CurrentSettings, FilePath, FLogFileSettings::FileWriteOptions, MessageQueue, Queue, FLogFileSettings::QueueLength, FLogFileSettings::Timestamp, WriteQueuedMessages(), and WriteToFile().

Referenced by SimulatorLog::Log(), and ASensor::WriteToLogFile().

WriteQueuedMessages()

void ULogFile::WriteQueuedMessages ( )

private

Write any queued messages to .txt file.

Definition at line 189 of file LogFile.cpp.

{
    if (MessageQueue.IsEmpty() || FilePath.IsEmpty())
    {
        return;
    }
 
    if (!LogFileStream.is_open())
    {
        std::string filePathString(TCHAR_TO_UTF8(*FilePath));
        LogFileStream.open(filePathString, std::ios::app);
        if (!LogFileStream.is_open())
        {
            // Failed to open the file, return
            return;
        }
    }
 
    for (const FString& Message : MessageQueue)
    {
        WriteToFile(Message, false);
    }
 
    MessageQueue.Empty();
 
    if (!CurrentSettings.KeepFileOpen)
    {
        LogFileStream.close();
    }
}

References CurrentSettings, FilePath, FLogFileSettings::KeepFileOpen, LogFileStream, MessageQueue, and WriteToFile().

Referenced by Destroy(), Write(), and ~ULogFile().

WriteToFile()

void ULogFile::WriteToFile ( const FString &  Text, bool  UseTimestamp  )

private

Actual method where text is written to the .txt file.

Parameters

Text	The text message to write to the log file.
UseTimestamp	Indicates whether to include a timestamp in the log message.

Definition at line 220 of file LogFile.cpp.

{
    if (FilePath.IsEmpty() || !IsValid(this))
    {
        return;
    }
 
    if (!LogFileStream.is_open())
    {
        std::string filePathString(TCHAR_TO_UTF8(*FilePath));
        LogFileStream.open(filePathString, std::ios::app);
        if (!LogFileStream.is_open())
        {
            // Failed to open the file, return
            return;
        }
    }
 
    if (UseTimestamp && CurrentSettings.Timestamp)
    {
        std::time_t now = std::time(nullptr);
        std::tm tm_time = *std::localtime(&now);
        char timestamp[12];
        std::strftime(timestamp, sizeof(timestamp), "[%H:%M:%S] ", &tm_time);
 
        LogFileStream << timestamp << TCHAR_TO_UTF8(*Text) << std::endl;
    }
    else
    {
        LogFileStream << TCHAR_TO_UTF8(*Text) << std::endl;
    }
 
    if (!CurrentSettings.KeepFileOpen)
    {
        LogFileStream.close();
    }
}

References CurrentSettings, FilePath, FLogFileSettings::KeepFileOpen, LogFileStream, and FLogFileSettings::Timestamp.

Referenced by Write(), and WriteQueuedMessages().

Member Data Documentation

CurrentSettings

FLogFileSettings ULogFile::CurrentSettings

private

Definition at line 145 of file LogFile.h.

Referenced by Create(), Write(), WriteQueuedMessages(), and WriteToFile().

FilePath

FString ULogFile::FilePath

private

Definition at line 147 of file LogFile.h.

Referenced by Clear(), Create(), OpenFilePath(), Write(), WriteQueuedMessages(), and WriteToFile().

LogFileStream

std::ofstream ULogFile::LogFileStream

private

Definition at line 149 of file LogFile.h.

Referenced by Close(), WriteQueuedMessages(), and WriteToFile().

MessageQueue

TArray<FString> ULogFile::MessageQueue

private

Definition at line 143 of file LogFile.h.

Referenced by Write(), and WriteQueuedMessages().

---

The documentation for this class was generated from the following files:

• Unreal/Agrarsense/Source/Agrarsense/Logging/LogFile.h
• Unreal/Agrarsense/Source/Agrarsense/Logging/LogFile.cpp