CSVFile.cpp

Go to the documentation of this file.

// Copyright (c) 2024 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "CSVFile.h"
 
#include "Agrarsense/Game/AgrarsensePaths.h"
#include "Agrarsense/Utils/FileUtilities.h"
 
#include "Misc/Paths.h"
#include "HAL/PlatformFileManager.h"
#include "GenericPlatform/GenericPlatformFile.h"
 
UCSVFile* UCSVFile::CreateCSVFile(const FString& FileNameWithoutExtension, const FCSVFileSettings& Settings)
{
    UCSVFile* CSVFile = NewObject<UCSVFile>(UCSVFile::StaticClass());
    CSVFile->AddToRoot();
    if (CSVFile)
    {
        CSVFile->Create(FileNameWithoutExtension, Settings);
    }
    return CSVFile;
}
 
void UCSVFile::Create(const FString& FileNameWithoutExtension, const FCSVFileSettings& Settings)
{
    CurrentSettings = Settings;
 
    // Simulator data directory for this run. Returns SIMULATOR_ROOT/Data/Run_{NUM}
    FString DataDirectory = UAgrarsensePaths::GetDataFolder();
 
    FString BasePath = Settings.CustomPath.IsEmpty() ? DataDirectory + "/CSV/" : Settings.CustomPath;
    IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
    if (!PlatformFile.DirectoryExists(*BasePath))
    {
        PlatformFile.CreateDirectoryTree(*BasePath);
    }
 
    FString FullPath = FPaths::Combine(*BasePath, FileNameWithoutExtension + TEXT(".csv"));
    UE_LOG(LogTemp, Warning, TEXT("FullPath: %s"), *FullPath);
 
    if (Settings.CreateUnique)
    {
        int32 Counter = 0;
        while (FPaths::FileExists(FullPath))
        {
            FullPath = FPaths::Combine(*BasePath, FileNameWithoutExtension + FString::Printf(TEXT("_%d.csv"), Counter++));
        }
    }
 
    if (Settings.FileWriteOption == FCSVFileWriteOptions::Queue) 
    {
        PendingRows.Reserve(Settings.QueueSize);
    }
 
    FilePath = FullPath;
 
    OpenStream();
}
 
void UCSVFile::OpenStream()
{
    if (CSVStream.is_open())
    {
        CSVStream.close();
    }
 
    std::ios_base::openmode Mode = std::ios::out;
    if (CurrentSettings.Append)
    {
        Mode |= std::ios::app;
    }
 
    CSVStream.open(TCHAR_TO_UTF8(*FilePath), Mode);
}
 
void UCSVFile::WriteRow(const TArray<FString>& Cells)
{
    if (!CSVStream.is_open()) OpenStream();
    if (!CSVStream.is_open()) return;
 
    // Determine delimiter
    FString Delimiter = TEXT(",");
    if (CurrentSettings.Delimiter == ECSVDelimiter::Semicolon)
    {
        Delimiter = TEXT(";");
    }
    else if (CurrentSettings.Delimiter == ECSVDelimiter::Tab)
    {
        Delimiter = TEXT("\t");
    }
 
    // Join values using chosen delimiter
    FString Line = FString::Join(Cells, *Delimiter);
 
    if (CurrentSettings.FileWriteOption == FCSVFileWriteOptions::Immediate)
    {
        WriteRaw(Line);  // Write the line immediately
    }
    else if (CurrentSettings.FileWriteOption == FCSVFileWriteOptions::Queue)
    {
        // Queue the line for later
        PendingRows.Add(Line);
    }
}
 
void UCSVFile::WriteRaw(const FString& Line)
{
    if (!CSVStream.is_open()) OpenStream();
    if (!CSVStream.is_open()) return;
 
    CSVStream << TCHAR_TO_UTF8(*Line) << std::endl;
}
 
void UCSVFile::Close()
{
    if (CSVStream.is_open())
    {
        // If we have queued rows, write them out
        if (CurrentSettings.FileWriteOption == FCSVFileWriteOptions::Queue)
        {
            for (const FString& Row : PendingRows)
            {
                WriteRaw(Row);
            }
            PendingRows.Empty();
        }
 
        CSVStream.close();
    }
}
 
void UCSVFile::Destroy()
{
    Close();
    ConditionalBeginDestroy();
}