SCR_FileIOHelper.c

Go to the documentation of this file.

class SCR_FileIOHelper
{
    protected static const string PATH_DELIMITER = SCR_StringHelper.SLASH; // accepted under Windows too
    protected static const string FORBIDDEN_FILENAME_CHARS_WINDOWS = "*/\\<>:|?\t\r\n\"";
    protected static const string FORBIDDEN_FILENAME_CHARS_LINUX = SCR_StringHelper.SLASH;
 
    protected static const ref array<ref SCR_FileInfo> FOUND_FILEINFOS = {};
 
    //------------------------------------------------------------------------------------------------
    [Obsolete("Use FileIO.MakeDirectory instead")]
    static bool CreateDirectory(string absoluteDirectory)
    {
        if (SCR_StringHelper.IsEmptyOrWhiteSpace(absoluteDirectory))
            return false;
 
        if (FileIO.FileExists(absoluteDirectory))
            return true;
 
        absoluteDirectory.Replace("\\", PATH_DELIMITER);
        absoluteDirectory = SCR_StringHelper.ReplaceRecursive(absoluteDirectory, PATH_DELIMITER + PATH_DELIMITER, PATH_DELIMITER);
 
        if (FileIO.FileExists(absoluteDirectory))
            return true;
 
        array<string> pieces = {};
        absoluteDirectory.Split(PATH_DELIMITER, pieces, true);
 
        if (pieces.Count() < 2)
        {
            Print("Cannot create directory " + absoluteDirectory + "; not enough directories", LogLevel.DEBUG);
            return false;
        }
 
        string path = pieces[0]; // C: part on Windows
        for (int i = 1, count = pieces.Count(); i < count; i++)
        {
            path += PATH_DELIMITER + pieces[i];
 
            if (FileIO.FileExists(path))
                continue;
 
            if (!FileIO.MakeDirectory(path))
            {
                Print("Cannot create directory " + absoluteDirectory + "; blocked at " + path, LogLevel.DEBUG);
                return false;
            }
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<string> FindFiles(string directoryPath, string extension)
    {
        array<string> result = {};
        FileIO.FindFiles(result.Insert, directoryPath, extension);
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    [Obsolete("Use CopyFile instead")] // 2025-05-14
    static bool Copy(string source, string destination, bool overwrite = true)
    {
        array<string> content = ReadFileContent(source);
        if (!content)
        {
            Print("Cannot get file content - " + source, LogLevel.ERROR);
            return false;
        }
 
#ifdef WORKBENCH
        string absolutePath;
        if (!FilePath.IsAbsolutePath(destination) && !Workbench.GetAbsolutePath(destination, absolutePath, false))
        {
            Print("Cannot get destination's absolute file path - " + destination, LogLevel.WARNING);
            return false;
        }
#endif // WORKBENCH
 
        if (!overwrite && FileIO.FileExists(destination))
        {
            Print("Not allowed to overwrite file - " + destination, LogLevel.WARNING);
            return false;
        }
 
        if (!WriteFileContent(destination, content))
        {
            Print("Cannot write file - " + destination, LogLevel.ERROR);
            return false;
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool CopyFile(string sourceFile, string destinationFile)
    {
        if (!FileIO.FileExists(sourceFile))
            return false;
 
        if (FileIO.CopyFile(sourceFile, destinationFile))
            return true;
 
        if (!FileIO.MakeDirectory(FilePath.StripFileName(destinationFile)))
            return false;
 
        return FileIO.CopyFile(sourceFile, destinationFile);
    }
 
    //------------------------------------------------------------------------------------------------
    static bool CopyDirectory(string sourceDirectory, string destinationDirectory)
    {
#ifdef WORKBENCH
        if (!Workbench.GetAbsolutePath(sourceDirectory, sourceDirectory, true))
        {
            Print("Wrong sourceDirectory provided", LogLevel.WARNING);
            return false;
        }
 
        if (!Workbench.GetAbsolutePath(destinationDirectory, destinationDirectory, false))
        {
            Print("Wrong destinationDirectory provided", LogLevel.WARNING);
            return false;
        }
#else // WORKBENCH
        if (!FileIO.FileExists(sourceDirectory))
        {
            Print("Wrong sourceDirectory provided", LogLevel.WARNING);
            return false;
        }
 
        if (!FileIO.FileExists(destinationDirectory))
        {
            Print("Wrong destinationDirectory provided", LogLevel.WARNING);
            return false;
        }
#endif // WORKBENCH
 
        array<ref SCR_FileInfo> directoryContent = GetDirectoryContent(sourceDirectory);
        if (!directoryContent)
        {
            Print("Cannot get files from directory " + sourceDirectory, LogLevel.WARNING);
            return false;
        }
 
        if (directoryContent.IsEmpty())
        {
            if (FileIO.FileExists(destinationDirectory))
                return true;
 
            return FileIO.MakeDirectory(destinationDirectory);
        }
 
        if (!FileIO.MakeDirectory(destinationDirectory))
        {
            Print("Cannot create " + destinationDirectory, LogLevel.ERROR);
            return false;
        }
 
        bool result = true;
 
        int sourceDirectoryLength = sourceDirectory.Length();
        array<string> isDirCheck = {};
        foreach (SCR_FileInfo fileInfo : directoryContent)
        {
            string newAbsPath = destinationDirectory + fileInfo.m_sFilePath.Substring(sourceDirectoryLength, fileInfo.m_sFilePath.Length() - sourceDirectoryLength);
 
            if ((fileInfo.m_eAttributes | FileAttribute.DIRECTORY) == fileInfo.m_eAttributes)
            {
                if (!FileIO.MakeDirectory(fileInfo.m_sFilePath)) // returns true if the directory exists
                {
                    PrintFormat("Cannot create directory %1", fileInfo.m_sFilePath, level: LogLevel.ERROR);
                    result = false;
                }
 
                continue;
            }
 
            // it is a file
 
            string newAbsFileDir = FilePath.StripFileName(newAbsPath);
            if (!FileIO.MakeDirectory(newAbsFileDir)) // returns true if the directory exists
            {
                PrintFormat("Cannot create directory %1", newAbsFileDir, level: LogLevel.ERROR);
                result = false;
            }
 
            if (!FileIO.CopyFile(fileInfo.m_sFilePath, newAbsPath)) // CopyFile requires the directory to exist
            {
                PrintFormat("Cannot copy '%1' to '%2'", fileInfo.m_sFilePath, newAbsPath, level: LogLevel.ERROR);
                result = false;
            }
        }
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool RenameFile(string sourceFile, string destinationFile)
    {
        return FileIO.CopyFile(sourceFile, destinationFile) && FileIO.DeleteFile(sourceFile);
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetFileStringContent(string filePath, bool printWarning = true)
    {
        FileHandle fileHandle = FileIO.OpenFile(filePath, FileMode.READ);
        if (!fileHandle)
        {
            if (printWarning)
                Print("Cannot open/read " + filePath, LogLevel.WARNING);
 
            return string.Empty;
        }
 
        string result;
        fileHandle.Read(result, -1);
        fileHandle.Close();
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<ref SCR_FileInfo> GetDirectoryContent(string directory, string extension = "")
    {
        if (!FileIO.FindFiles(FindFilesCallbackMethod, directory, extension))
            return null;
 
        array<ref SCR_FileInfo> result = SCR_ArrayHelperRefT<SCR_FileInfo>.GetCopy(FOUND_FILEINFOS);
        FOUND_FILEINFOS.Clear();
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<string> ReadFileContent(string filePath, bool printWarning = true)
    {
        FileHandle fileHandle = FileIO.OpenFile(filePath, FileMode.READ);
        if (!fileHandle)
        {
            if (printWarning)
                Print("Cannot open/read " + filePath, LogLevel.WARNING);
 
            return null;
        }
 
        string lineContent;
        array<string> result = {};
        while (fileHandle.ReadLine(lineContent) > -1)
        {
            result.Insert(lineContent);
        }
 
        fileHandle.Close();
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool WriteFileContent(string filePath, notnull array<string> lines)
    {
        FileHandle fileHandle = FileIO.OpenFile(filePath, FileMode.WRITE);
        if (!fileHandle)
        {
            Print("Cannot open/write " + filePath, LogLevel.WARNING);
            return false;
        }
 
        int linesCountMinusOne = lines.Count() - 1;
        if (linesCountMinusOne == -1)
        {
            fileHandle.Write(string.Empty); // needed?
        }
        else
        {
            foreach (int lineNumber, string line : lines)
            {
                if (lineNumber < linesCountMinusOne)
                    fileHandle.WriteLine(line);
            }
 
            // avoid final line return due to WriteLine
            fileHandle.Write(lines[linesCountMinusOne]);
        }
 
        fileHandle.Close();
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool AppendFileContent(string filePath, notnull array<string> lines)
    {
        if (!FileIO.FileExists(filePath))
            return WriteFileContent(filePath, lines);
 
        FileHandle fileHandle = FileIO.OpenFile(filePath, FileMode.APPEND);
        if (!fileHandle)
        {
            Print("Cannot open/append " + filePath, LogLevel.WARNING);
            return false;
        }
 
        int linesCountMinusOne = lines.Count() - 1;
        if (linesCountMinusOne == -1)
        {
            fileHandle.Write(string.Empty); // needed?
        }
        else
        {
            // add a line return before appending the provided lines
            fileHandle.Write("\n");
 
            foreach (int lineNumber, string line : lines)
            {
                if (lineNumber < linesCountMinusOne)
                    fileHandle.WriteLine(line);
            }
 
            // avoid final line return due to WriteLine
            fileHandle.Write(lines[linesCountMinusOne]);
        }
 
        fileHandle.Close();
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool IsValidFileName(string fileName)
    {
        bool isWindowsBased = IsWindowsBased();
        if (isWindowsBased)
        {
            if (fileName.EndsWith("."))
                return false;
 
            if (fileName.EndsWith(" "))
                return false;
        }
 
        string forbiddenCharacters;
        if (isWindowsBased)
            forbiddenCharacters = FORBIDDEN_FILENAME_CHARS_WINDOWS;
        else
            forbiddenCharacters = FORBIDDEN_FILENAME_CHARS_LINUX;
 
        for (int i, len = forbiddenCharacters.Length(); i < len; i++)
        {
            if (fileName.Contains(forbiddenCharacters[i]))
                return false;
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    static string SanitiseFileName(string fileName)
    {
        string forbiddenCharacters;
        bool isWindowsBased = IsWindowsBased();
        if (isWindowsBased)
            forbiddenCharacters = FORBIDDEN_FILENAME_CHARS_WINDOWS;
        else
            forbiddenCharacters = FORBIDDEN_FILENAME_CHARS_LINUX;
 
        fileName = FilePath.StripPath(fileName);
        fileName = SCR_StringHelper.Filter(fileName, forbiddenCharacters, true);
 
        fileName.TrimInPlace();
        if (fileName.IsEmpty())
            return string.Empty;
 
        if (isWindowsBased)
        {
            int originalLength = fileName.Length();
            int properLength = originalLength;
            string lastChar = fileName[properLength - 1];
 
            while (lastChar == "." || lastChar == " " || lastChar == "\t")
            {
                --properLength;
                if (properLength < 1)
                    break;
 
                lastChar = fileName[properLength - 1];
            }
 
            if (properLength < 1)
                return string.Empty;
 
            if (properLength != originalLength)
                fileName = fileName.Substring(0, properLength);
        }
 
        fileName.TrimInPlace();
 
        return fileName;
    }
 
    //------------------------------------------------------------------------------------------------
    protected static bool IsWindowsBased()
    {
        EPlatform platform = System.GetPlatform();
 
        return platform == EPlatform.WINDOWS
            || platform == EPlatform.XBOX_ONE
            || platform == EPlatform.XBOX_ONE_S
            || platform == EPlatform.XBOX_ONE_X
            || platform == EPlatform.XBOX_SERIES_S
            || platform == EPlatform.XBOX_SERIES_X;
    }
 
    //------------------------------------------------------------------------------------------------
    // FindFilesCallback
    protected static void FindFilesCallbackMethod(string fileName, FileAttribute attributes = 0, string filesystem = string.Empty)
    {
        SCR_FileInfo fileInfo = new SCR_FileInfo();
        fileInfo.m_sFilePath = fileName;
        fileInfo.m_eAttributes = attributes;
        fileInfo.m_sFileSystem = filesystem;
        FOUND_FILEINFOS.Insert(fileInfo);
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetShortResourceName(ResourceName rn)
    {
        return rn.Substring(0, rn.IndexOf("}") + 1) + FilePath.StripPath(rn.GetPath());
    }
 
    //------------------------------------------------------------------------------------------------
    // constructor
    protected void SCR_FileIOHelper();
}
 
class SCR_FileInfo
{
    string m_sFilePath;
    FileAttribute m_eAttributes;
    string m_sFileSystem;
}