Initial draft of FileStream

1 files changed, 248 insertions, 0 deletions

diff --git a/core/src/Utils/IO/FileStream.cpp b/core/src/Utils/IO/FileStream.cpp
new file mode 100644
index 0000000..bc95b7e
--- /dev/null
+++ b/core/src/Utils/IO/FileStream.cpp
@@ -0,0 +1,248 @@
+#include "FileStream.hpp"
+
+#include <cstring>
+#include <iostream>
+
+#if PLATFORM_WIN32
+
+// TODO
+
+#elif PLATFORM_MACOS || PLATFORM_LINUX
+#	include <fcntl.h>
+#	include <sys/stat.h>
+#	include <sys/types.h>
+#	include <unistd.h>
+
+InputFileStream::InputFileStream(const std::filesystem::path& path)
+	: mOsFileHandle{ 0 }
+{
+	auto fd = reinterpret_cast<int*>(mOsFileHandle);
+	*fd = open(path.c_str(), O_RDONLY);
+}
+
+InputFileStream::~InputFileStream()
+{
+	auto fd = reinterpret_cast<int*>(mOsFileHandle);
+	close(*fd);
+}
+
+OutputFileStream::OutputFileStream(const std::filesystem::path& path, WriteMode mode)
+	: mOsFileHandle{ 0 }
+{
+	auto fd = reinterpret_cast<int*>(mOsFileHandle);
+
+	int flags = O_WRONLY | O_CREAT;
+	switch (mode) {
+		case AppendFile: flags |= O_APPEND; break;
+		case TruncateFile: flags |= O_TRUNC; break;
+	}
+
+	*fd = open(path.c_str(), flags, 0644);
+}
+
+OutputFileStream::~OutputFileStream()
+{
+	auto fd = reinterpret_cast<int*>(mOsFileHandle);
+	close(*fd);
+}
+
+static IoResult::ErrorKind MapErrnoToIoResult(int err)
+{
+	switch (err) {
+		// TODO
+		case EFAULT: return IoResult::ERR_UnexpectedEof;
+		case EPERM: return IoResult::ERR_PermissionDenied;
+		case ENOSPC: return IoResult::ERR_OutOfSpace;
+		case EIO: return IoResult::ERR_Other;
+
+		default:
+			std::cerr << "Unimplemented POSIX errno " << err << ", report bug immediately.\n";
+			std::abort();
+	}
+}
+
+static IoResult ReadBytesDirect(const char* osFileHandle, size_t byteCount, std::byte* bytes)
+{
+	int fd = *reinterpret_cast<const int*>(osFileHandle);
+	int status = read(fd, bytes, byteCount);
+
+	if (status == -1) {
+		int err = errno;
+		return IoResult{
+			.Error = ::MapErrnoToIoResult(err),
+			.SystemError = err,
+			.BytesMoved = 0,
+		};
+	} else {
+		return IoResult{
+			.Error = IoResult::ERR_None,
+			.SystemError = 0,
+			.BytesMoved = (size_t)status, // Equal to number of bytes read
+		};
+	}
+}
+
+static IoResult WriteBytesDirect(const char* osFileHandle, size_t byteCount, const std::byte* bytes)
+{
+	int fd = *reinterpret_cast<const int*>(osFileHandle);
+	int status = write(fd, bytes, byteCount);
+
+	if (status == -1) {
+		int err = errno;
+		return IoResult{
+			.Error = ::MapErrnoToIoResult(err),
+			.SystemError = err,
+			.BytesMoved = 0,
+		};
+	} else {
+		return IoResult{
+			.Error = IoResult::ERR_None,
+			.SystemError = 0,
+			.BytesMoved = (size_t)status, // Equal to number of bytes read
+		};
+	}
+}
+
+#else
+#	error "Unsupported target platform."
+#endif
+
+int InputFileStream::GetReadInSize() const
+{
+	return mReadInSize;
+}
+
+void InputFileStream::SetReadInSize(int size)
+{
+	if (size > mReadInSize) {
+		mReadInSize = size;
+		mBuffer = std::make_unique<std::byte[]>(size);
+	}
+}
+
+bool InputFileStream::IsEof() const
+{
+	return mEof;
+}
+
+IoResult InputFileStream::ReadBytes(size_t bufferLength, std::byte* buffer)
+{
+	// TODO reduce duplicated code
+
+	auto bytesMoved = std::min<size_t>(mAvailableBytes, bufferLength);
+
+	// On first call after construction, mFirstByteIdx will equal to mReadInSize, i.e. bytesAvailable == 0
+	// and this call to std::memcpy will be no-op
+	std::memcpy(buffer, &mBuffer[mFirstByteIdx], bytesMoved);
+	mFirstByteIdx += (int)bytesMoved;
+	mAvailableBytes -= (int)bytesMoved;
+	buffer += bytesMoved;
+
+	size_t bytesLeft = bufferLength - bytesMoved;
+	if (bytesLeft > mReadInSize) {
+		// Our buffer can't handle rest of the request, just skip the buffering step
+
+		// Read rest of the data into buffer
+		{
+			auto result = ::ReadBytesDirect(mOsFileHandle, bytesLeft, buffer);
+			bytesMoved += result.BytesMoved;
+
+			if (result.Error == IoResult::ERR_None) {
+				if (result.BytesMoved < mReadInSize) {
+					mEof = true;
+				}
+			} else {
+				goto end;
+			}
+		}
+
+		// Refill our buffer
+		{
+			auto result = ::ReadBytesDirect(mOsFileHandle, mReadInSize, mBuffer.get());
+			mFirstByteIdx = 0;
+			mAvailableBytes = (int)result.BytesMoved;
+
+			if (result.Error == IoResult::ERR_None) {
+				if (result.BytesMoved < mReadInSize) {
+					mEof = true;
+				}
+			} else {
+				goto end;
+			}
+		}
+	} else if (bytesLeft > 0) {
+		// Our buffer can handle rest of the request, first buffer than supply the requested data
+
+		// Refill our buffer
+		{
+			auto result = ::ReadBytesDirect(mOsFileHandle, mReadInSize, mBuffer.get());
+			mFirstByteIdx = 0;
+			mAvailableBytes = (int)result.BytesMoved;
+
+			if (result.Error == IoResult::ERR_None) {
+				if (result.BytesMoved < mReadInSize) {
+					mEof = true;
+				}
+			} else {
+				goto end;
+			}
+		}
+
+		// Copy data into buffer
+		{
+			std::memcpy(buffer, &mBuffer[mFirstByteIdx], bytesLeft);
+			mFirstByteIdx += (int)bytesLeft;
+			bytesMoved += bytesLeft;
+			buffer += bytesLeft;
+		}
+	} else {
+		// Request completed already
+	}
+
+end:
+	return IoResult{
+		.Error = IoResult::ERR_None,
+		.SystemError = 0,
+		.BytesMoved = bytesMoved,
+	};
+}
+
+int OutputFileStream::GetMaxBufferSize() const
+{
+	return mMaxBufferSize;
+}
+
+void OutputFileStream::SetMaxBufferSize(int maxSize)
+{
+	FlushBuffer();
+	if (maxSize > mMaxBufferSize) {
+		mMaxBufferSize = maxSize;
+		mBuffer = std::make_unique<std::byte[]>(maxSize);
+	}
+}
+
+IoResult OutputFileStream::WriteBytes(size_t bufferLength, const std::byte* buffer)
+{
+	if (bufferLength + mCurrentBufferSize > mMaxBufferSize) {
+		FlushBuffer();
+
+		if (bufferLength > mMaxBufferSize) {
+			return ::WriteBytesDirect(mOsFileHandle, bufferLength, buffer);
+		}
+	}
+
+	std::memcpy(mBuffer.get() + mCurrentBufferSize, buffer, bufferLength);
+	mCurrentBufferSize += (int)bufferLength;
+
+	return IoResult{
+		.Error = IoResult::ERR_None,
+		.SystemError = 0,
+		.BytesMoved = bufferLength,
+	};
+}
+
+void OutputFileStream::FlushBuffer()
+{
+	::WriteBytesDirect(mOsFileHandle, mCurrentBufferSize, mBuffer.get());
+	mCurrentBufferSize = 0;
+}