everything everywhere

all at once

1 files changed, 149 insertions, 0 deletions

diff --git a/source/core/StarFile.hpp b/source/core/StarFile.hpp
new file mode 100644
index 0000000..c75dd4c
--- /dev/null
+++ b/source/core/StarFile.hpp
@@ -0,0 +1,149 @@
+#ifndef STAR_FILE_HPP
+#define STAR_FILE_HPP
+
+#include "StarIODevice.hpp"
+#include "StarString.hpp"
+
+namespace Star {
+
+STAR_CLASS(File);
+
+// All file methods are thread safe.
+class File : public IODevice {
+public:
+  // Converts the passed in path to use the platform specific directory
+  // separators only (Windows supports '/' just fine, this is mostly for
+  // uniform appearance).  Does *nothing else* (no validity checks, etc).
+  static String convertDirSeparators(String const& path);
+
+  // All static file operations here throw IOException on error.
+  // get the current working directory
+  static String currentDirectory();
+  // set the current working directory.
+  static void changeDirectory(String const& dirName);
+  static void makeDirectory(String const& dirName);
+  static void makeDirectoryRecursive(String const& dirName);
+
+  // List all files or directories under given directory.  skipDots skips the
+  // special '.' and '..' entries.  Bool value is true for directories.
+  static List<pair<String, bool>> dirList(String const& dirName, bool skipDots = true);
+
+  // Returns the final component of the given path with no directory separators
+  static String baseName(String const& fileName);
+  // All components of the given path minus the final component, separated by
+  // the directory separator
+  static String dirName(String const& fileName);
+
+  // Resolve a path relative to another path.  If the given path is absolute,
+  // then the given path is returned unmodified.
+  static String relativeTo(String const& relativeTo, String const& path);
+
+  // Resolve the given possibly relative path into an absolute path.
+  static String fullPath(String const& path);
+
+  static String temporaryFileName();
+
+  // Creates and opens a new ReadWrite temporary file with a real path that can
+  // be closed and re-opened.  Will not be removed automatically.
+  static FilePtr temporaryFile();
+
+  // Creates and opens new ReadWrite temporary file and opens it.  This file
+  // has no filename and will be removed on close.
+  static FilePtr ephemeralFile();
+
+  // Creates a new temporary directory and reutrns the path.  Will not be
+  // removed automatically.
+  static String temporaryDirectory();
+
+  static bool exists(String const& path);
+
+  // Does the file exist and is it a regular file (not a directory or special
+  // file)?
+  static bool isFile(String const& path);
+  // Is the file a directory?
+  static bool isDirectory(String const& path);
+
+  static void remove(String const& filename);
+  static void removeDirectoryRecursive(String const& filename);
+
+  // Moves the source file to the target path, overwriting the target path if
+  // it already exists.
+  static void rename(String const& source, String const& target);
+
+  // Copies the source file to the target, overwriting the target path if it
+  // already exists.
+  static void copy(String const& source, String const& target);
+
+  static ByteArray readFile(String const& filename);
+  static String readFileString(String const& filename);
+  static StreamOffset fileSize(String const& filename);
+
+  static void writeFile(char const* data, size_t len, String const& filename);
+  static void writeFile(ByteArray const& data, String const& filename);
+  static void writeFile(String const& data, String const& filename);
+
+  // Write a new file, potentially overwriting an existing file, in the safest
+  // way possible while preserving the old file in the same directory until the
+  // operation completes.  Writes to the same path as the existing file to
+  // avoid different partition copying.  This may clobber anything in the given
+  // path that matches filename + newSuffix.
+  static void overwriteFileWithRename(char const* data, size_t len, String const& filename, String const& newSuffix = ".new");
+  static void overwriteFileWithRename(ByteArray const& data, String const& filename, String const& newSuffix = ".new");
+  static void overwriteFileWithRename(String const& data, String const& filename, String const& newSuffix = ".new");
+
+  static void backupFileInSequence(String const& targetFile, unsigned maximumBackups, String const& backupExtensionPrefix = ".");
+
+  static FilePtr open(String const& filename, IOMode mode);
+
+  File();
+  File(String filename);
+  virtual ~File();
+
+  String fileName() const;
+  void setFilename(String filename);
+
+  // File is closed before removal.
+  void remove();
+
+  StreamOffset pos() override;
+  void seek(StreamOffset pos, IOSeek seek = IOSeek::Absolute) override;
+  void resize(StreamOffset size) override;
+  StreamOffset size() override;
+  bool atEnd() override;
+  size_t read(char* data, size_t len) override;
+  size_t write(char const* data, size_t len) override;
+
+  // Do an immediate read / write of an absolute location in the file, without
+  // modifying the current file cursor.  Safe to call in a threaded context
+  // with other reads and writes, but not safe vs changing the File state like
+  // open and close.
+  size_t readAbsolute(StreamOffset readPosition, char* data, size_t len) override;
+  size_t writeAbsolute(StreamOffset writePosition, char const* data, size_t len) override;
+
+  void open(IOMode mode) override;
+  void close() override;
+
+  void sync() override;
+
+  String deviceName() const override;
+
+private:
+  static void* fopen(char const* filename, IOMode mode);
+  static void fseek(void* file, StreamOffset offset, IOSeek seek);
+  static StreamOffset ftell(void* file);
+  static size_t fread(void* file, char* data, size_t len);
+  static size_t fwrite(void* file, char const* data, size_t len);
+  static void fsync(void* file);
+  static void fclose(void* file);
+  static StreamOffset fsize(void* file);
+  static size_t pread(void* file, char* data, size_t len, StreamOffset absPosition);
+  static size_t pwrite(void* file, char const* data, size_t len, StreamOffset absPosition);
+  static void resize(void* file, StreamOffset size);
+
+  String m_filename;
+  void* m_file;
+};
+
+}
+
+#endif