OSFile.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Communication/Event.h>
#include <Foundation/IO/FileEnums.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Strings/StringBuilder.h>
#include <Foundation/Threading/AtomicInteger.h>
#include <Foundation/Threading/Mutex.h>
#include <Foundation/Time/Timestamp.h>
 
struct plOSFileData;
 
#if PL_ENABLED(PL_USE_POSIX_FILE_API)
#  include <Foundation/IO/Implementation/Posix/OSFileDeclarations_posix.h>
#elif PL_ENABLED(PL_PLATFORM_WINDOWS)
#  include <Foundation/IO/Implementation/Win/OSFileDeclarations_win.h>
#endif
 
struct plFileOpenMode
{
  enum Enum
  {
    None,   
    Read,   
    Write,  
    Append, 
  };
};
 
struct PL_FOUNDATION_DLL plFileStats
{
  plFileStats();
  ~plFileStats();
 
  void GetFullPath(plStringBuilder& ref_sPath) const;
 
  plStringBuilder m_sParentPath;
 
  plString m_sName;
 
  plTimestamp m_LastModificationTime;
 
  plUInt64 m_uiFileSize = 0;
 
  bool m_bIsDirectory = false;
};
 
#if PL_ENABLED(PL_SUPPORTS_FILE_ITERATORS) || defined(PL_DOCS)
 
struct plFileIterationData;
 
struct plFileSystemIteratorFlags
{
  using StorageType = plUInt8;
 
  enum Enum : plUInt8
  {
    Recursive = PL_BIT(0),
    ReportFiles = PL_BIT(1),
    ReportFolders = PL_BIT(2),
 
    ReportFilesRecursive = Recursive | ReportFiles,
    ReportFoldersRecursive = Recursive | ReportFolders,
    ReportFilesAndFoldersRecursive = Recursive | ReportFiles | ReportFolders,
 
    Default = ReportFilesAndFoldersRecursive,
  };
 
  struct Bits
  {
    StorageType Recursive : 1;
    StorageType ReportFiles : 1;
    StorageType ReportFolders : 1;
  };
};
 
PL_DECLARE_FLAGS_OPERATORS(plFileSystemIteratorFlags);
 
class PL_FOUNDATION_DLL plFileSystemIterator
{
  PL_DISALLOW_COPY_AND_ASSIGN(plFileSystemIterator);
 
public:
  plFileSystemIterator();
  ~plFileSystemIterator();
 
  void StartSearch(plStringView sSearchTerm, plBitflags<plFileSystemIteratorFlags> flags = plFileSystemIteratorFlags::Default); // [tested]
 
  void StartMultiFolderSearch(plArrayPtr<plString> startFolders, plStringView sSearchTerm, plBitflags<plFileSystemIteratorFlags> flags = plFileSystemIteratorFlags::Default);
 
  const plStringView GetCurrentSearchTerm() const { return m_sSearchTerm; }
 
  const plStringBuilder& GetCurrentPath() const { return m_sCurPath; } // [tested]
 
  const plFileStats& GetStats() const { return m_CurFile; } // [tested]
 
  void Next(); // [tested]
 
  void SkipFolder(); // [tested]
 
  bool IsValid() const;
 
private:
  plInt32 InternalNext();
 
  plStringBuilder m_sCurPath;
 
  plBitflags<plFileSystemIteratorFlags> m_Flags;
 
  plFileStats m_CurFile;
 
  plFileIterationData m_Data;
 
  plString m_sSearchTerm;
  plString m_sMultiSearchTerm;
  plUInt32 m_uiCurrentStartFolder = 0;
  plHybridArray<plString, 8> m_StartFolders;
};
 
#endif
 
class PL_FOUNDATION_DLL plOSFile
{
  PL_DISALLOW_COPY_AND_ASSIGN(plOSFile);
 
public:
  plOSFile();
  ~plOSFile();
 
  plResult Open(plStringView sFile, plFileOpenMode::Enum openMode, plFileShareMode::Enum fileShareMode = plFileShareMode::Default); // [tested]
 
  bool IsOpen() const; // [tested]
 
  void Close(); // [tested]
 
  plResult Write(const void* pBuffer, plUInt64 uiBytes); // [tested]
 
  plUInt64 Read(void* pBuffer, plUInt64 uiBytes); // [tested]
 
  plUInt64 ReadAll(plDynamicArray<plUInt8>& out_fileContent); // [tested]
 
  plStringView GetOpenFileName() const { return m_sFileName; } // [tested]
 
  plUInt64 GetFilePosition() const; // [tested]
 
  void SetFilePosition(plInt64 iDistance, plFileSeekMode::Enum pos) const; // [tested]
 
  plUInt64 GetFileSize() const; // [tested]
 
  const plOSFileData& GetFileData() const { return m_FileData; }
 
  static const plString GetCurrentWorkingDirectory(); // [tested]
 
  static const plString MakePathAbsoluteWithCWD(plStringView sPath); // [tested]
 
  static bool ExistsFile(plStringView sFile); // [tested]
 
  static bool ExistsDirectory(plStringView sDirectory); // [tested]
 
  static void FindFreeFilename(plStringBuilder& inout_sPath, plStringView sSuffix = "-");
 
  static plResult DeleteFile(plStringView sFile); // [tested]
 
  static plResult CreateDirectoryStructure(plStringView sDirectory); // [tested]
 
  static plResult MoveFileOrDirectory(plStringView sFrom, plStringView sTo);
 
  static plResult CopyFile(plStringView sSource, plStringView sDestination); // [tested]
 
#if PL_ENABLED(PL_SUPPORTS_FILE_STATS) || defined(PL_DOCS)
  static plResult GetFileStats(plStringView sFileOrFolder, plFileStats& out_stats); // [tested]
 
#  if (PL_ENABLED(PL_SUPPORTS_CASE_INSENSITIVE_PATHS) && PL_ENABLED(PL_SUPPORTS_UNRESTRICTED_FILE_ACCESS)) || defined(PL_DOCS)
  static plResult GetFileCasing(plStringView sFileOrFolder, plStringBuilder& out_sCorrectSpelling); // [tested]
#  endif
 
#endif
 
#if (PL_ENABLED(PL_SUPPORTS_FILE_ITERATORS) && PL_ENABLED(PL_SUPPORTS_FILE_STATS)) || defined(PL_DOCS)
 
  static void GatherAllItemsInFolder(plDynamicArray<plFileStats>& out_itemList, plStringView sFolder, plBitflags<plFileSystemIteratorFlags> flags = plFileSystemIteratorFlags::Default);
 
  static plResult CopyFolder(plStringView sSourceFolder, plStringView sDestinationFolder, plDynamicArray<plString>* out_pFilesCopied = nullptr);
 
  static plResult DeleteFolder(plStringView sFolder);
 
#endif
 
  static plStringView GetApplicationPath();
 
  static plStringView GetApplicationDirectory();
 
  static plString GetUserDataFolder(plStringView sSubFolder = {});
 
  static plString GetTempDataFolder(plStringView sSubFolder = {});
 
  static plString GetUserDocumentsFolder(plStringView sSubFolder = {});
 
 
public:
  struct EventType
  {
    enum Enum
    {
      None,
      FileOpen,        
      FileClose,       
      FileExists,      
      DirectoryExists, 
      FileDelete,      
      FileRead,        
      FileWrite,       
      MakeDir,         
      FileCopy,        
      FileStat,        
      FileCasing,      
    };
  };
 
  struct EventData
  {
    EventType::Enum m_EventType = EventType::None;
 
    plInt32 m_iFileID = 0;
 
    plStringView m_sFile;
 
    plStringView m_sFile2;
 
    plFileOpenMode::Enum m_FileMode = plFileOpenMode::None;
 
    bool m_bSuccess = true;
 
    plTime m_Duration;
 
    plUInt64 m_uiBytesAccessed = 0;
  };
 
  using Event = plEvent<const EventData&, plMutex>;
 
  static void AddEventHandler(Event::Handler handler) { s_FileEvents.AddEventHandler(handler); }
 
  static void RemoveEventHandler(Event::Handler handler) { s_FileEvents.RemoveEventHandler(handler); }
 
private:
  static Event s_FileEvents;
 
  // *** Internal Functions that do the platform specific work ***
 
  plResult InternalOpen(plStringView sFile, plFileOpenMode::Enum OpenMode, plFileShareMode::Enum FileShareMode);
  void InternalClose();
  plResult InternalWrite(const void* pBuffer, plUInt64 uiBytes);
  plUInt64 InternalRead(void* pBuffer, plUInt64 uiBytes);
  plUInt64 InternalGetFilePosition() const;
  void InternalSetFilePosition(plInt64 iDistance, plFileSeekMode::Enum Pos) const;
 
  static bool InternalExistsFile(plStringView sFile);
  static bool InternalExistsDirectory(plStringView sDirectory);
  static plResult InternalDeleteFile(plStringView sFile);
  static plResult InternalDeleteDirectory(plStringView sDirectory);
  static plResult InternalCreateDirectory(plStringView sFile);
  static plResult InternalMoveFileOrDirectory(plStringView sDirectoryFrom, plStringView sDirectoryTo);
 
#if PL_ENABLED(PL_SUPPORTS_FILE_STATS)
  static plResult InternalGetFileStats(plStringView sFileOrFolder, plFileStats& out_Stats);
#endif
 
  // *************************************************************
 
  plFileOpenMode::Enum m_FileMode;
 
  bool m_bRetryOnSharingViolation = true;
 
  plStringBuilder m_sFileName;
 
  plInt32 m_iFileID;
 
  plOSFileData m_FileData;
 
  static plString64 s_sApplicationPath;
 
  static plString64 s_sUserDataPath;
 
  static plString64 s_sTempDataPath;
 
  static plString64 s_sUserDocumentsPath;
 
  static plAtomicInteger32 s_iFileCounter;
};