move BasicFile to zenutil to remove zenstore dependency from zen command (#190)

1 files changed, 113 insertions, 0 deletions

diff --git a/zenutil/include/zenutil/basicfile.h b/zenutil/include/zenutil/basicfile.h
new file mode 100644
index 000000000..877df0f92
--- /dev/null
+++ b/zenutil/include/zenutil/basicfile.h
@@ -0,0 +1,113 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/iobuffer.h>
+
+#include <filesystem>
+#include <functional>
+
+namespace zen {
+
+class CbObject;
+
+/**
+ * Probably the most basic file abstraction in the universe
+ *
+ * One thing of note is that there is no notion of a "current file position"
+ * in this API -- all reads and writes are done from explicit offsets in
+ * the file. This avoids concurrency issues which can occur otherwise.
+ *
+ */
+
+class BasicFile
+{
+public:
+	BasicFile() = default;
+	~BasicFile();
+
+	BasicFile(const BasicFile&) = delete;
+	BasicFile& operator=(const BasicFile&) = delete;
+
+	enum class Mode : uint32_t
+	{
+		kRead	  = 0,	// Opens a existing file for read only
+		kWrite	  = 1,	// Opens (or creates) a file for read and write
+		kTruncate = 2,	// Opens (or creates) a file for read and write and sets the size to zero
+		kDelete	  = 3,	// Opens (or creates) a file for read and write allowing .DeleteFile file disposition to be set
+		kTruncateDelete =
+			4  // Opens (or creates) a file for read and write and sets the size to zero allowing .DeleteFile file disposition to be set
+	};
+
+	void	 Open(const std::filesystem::path& FileName, Mode Mode);
+	void	 Open(const std::filesystem::path& FileName, Mode Mode, std::error_code& Ec);
+	void	 Close();
+	void	 Read(void* Data, uint64_t Size, uint64_t FileOffset);
+	void	 StreamFile(std::function<void(const void* Data, uint64_t Size)>&& ChunkFun);
+	void	 StreamByteRange(uint64_t FileOffset, uint64_t Size, std::function<void(const void* Data, uint64_t Size)>&& ChunkFun);
+	void	 Write(MemoryView Data, uint64_t FileOffset);
+	void	 Write(MemoryView Data, uint64_t FileOffset, std::error_code& Ec);
+	void	 Write(const void* Data, uint64_t Size, uint64_t FileOffset);
+	void	 Write(const void* Data, uint64_t Size, uint64_t FileOffset, std::error_code& Ec);
+	void	 Flush();
+	uint64_t FileSize();
+	void	 SetFileSize(uint64_t FileSize);
+	IoBuffer ReadAll();
+	void	 WriteAll(IoBuffer Data, std::error_code& Ec);
+	void*	 Detach();
+
+	inline void* Handle() { return m_FileHandle; }
+
+protected:
+	void* m_FileHandle = nullptr;  // This is either null or valid
+private:
+};
+
+/**
+ * Simple abstraction for a temporary file
+ *
+ * Works like a regular BasicFile but implements a simple mechanism to allow creating
+ * a temporary file for writing in a directory which may later be moved atomically
+ * into the intended location after it has been fully written to.
+ *
+ */
+
+class TemporaryFile : public BasicFile
+{
+public:
+	TemporaryFile() = default;
+	~TemporaryFile();
+
+	TemporaryFile(const TemporaryFile&) = delete;
+	TemporaryFile& operator=(const TemporaryFile&) = delete;
+
+	void						 Close();
+	void						 CreateTemporary(std::filesystem::path TempDirName, std::error_code& Ec);
+	void						 MoveTemporaryIntoPlace(std::filesystem::path FinalFileName, std::error_code& Ec);
+	const std::filesystem::path& GetPath() const { return m_TempPath; }
+
+private:
+	std::filesystem::path m_TempPath;
+
+	using BasicFile::Open;
+};
+
+/** Lock file abstraction
+
+ */
+
+class LockFile : protected BasicFile
+{
+public:
+	LockFile();
+	~LockFile();
+
+	void Create(std::filesystem::path FileName, CbObject Payload, std::error_code& Ec);
+	void Update(CbObject Payload, std::error_code& Ec);
+
+private:
+};
+
+ZENCORE_API void basicfile_forcelink();
+
+}  // namespace zen