large organizational & cleanup refactor

src/streams/bufferstream.cpp

@@ -42,7 +42,7 @@ BufferStream::~BufferStream()
 	delete[] m_buffer;
 }
 
-i64 BufferStream::read_into(void* ptr, i64 len)
+size_t BufferStream::read_into(void* ptr, size_t len)
 {
 	if (m_buffer == nullptr || ptr == nullptr)
 		return 0;
@@ -58,7 +58,7 @@ i64 BufferStream::read_into(void* ptr, i64 len)
 	return len;
 }
 
-i64 BufferStream::write_from(const void* ptr, i64 len)
+size_t BufferStream::write_from(const void* ptr, size_t len)
 {
 	if (len < 0)
 		return 0;
@@ -78,7 +78,7 @@ i64 BufferStream::write_from(const void* ptr, i64 len)
 	return len;
 }
 
-void BufferStream::resize(i64 length)
+void BufferStream::resize(size_t length)
 {
 	if (m_capacity > length)
 	{

src/streams/filestream.cpp

@@ -1,5 +1,5 @@
 #include <blah/streams/filestream.h>
-#include <blah/core/common.h>
+#include <blah/common.h>
 #include "../internal/platform_backend.h"
 #include <cstring>
 
@@ -7,105 +7,90 @@ using namespace Blah;
 
 FileStream::FileStream()
 {
-	m_handle = nullptr;
 	m_mode = FileMode::OpenRead;
 }
 
 FileStream::FileStream(const FilePath& path, FileMode mode)
 	: m_mode(mode)
+	, m_file(File::open(path, mode))
 {
-	if (!PlatformBackend::file_open(path, &m_handle, mode))
-		m_handle = nullptr;
+
 }
 
 FileStream::FileStream(FileStream&& src) noexcept
 {
-	m_handle = src.m_handle;
+	m_file = src.m_file;
 	m_mode = src.m_mode;
-	src.m_handle = nullptr;
 }
 
 FileStream& FileStream::operator=(FileStream&& src) noexcept
 {
-	m_handle = src.m_handle;
+	m_file = src.m_file;
 	m_mode = src.m_mode;
-	src.m_handle = nullptr;
 	return *this;
 }
 
-FileStream::~FileStream()
+size_t FileStream::length() const
 {
-	if (m_handle != nullptr)
-		PlatformBackend::file_close(m_handle);
+	if (m_file)
+		return m_file->length();
+	return 0;
 }
 
-i64 FileStream::length() const
+size_t FileStream::position() const
 {
-	if (m_handle == nullptr)
-		return 0;
-
-	return PlatformBackend::file_length(m_handle);
+	if (m_file)
+		return m_file->position();
+	return 0;
 }
 
-i64 FileStream::position() const
+size_t FileStream::seek(size_t seek_to)
 {
-	if (m_handle == nullptr)
-		return 0;
-
-	return PlatformBackend::file_position(m_handle);
-}
-
-i64 FileStream::seek(i64 seek_to)
-{
-	if (m_handle == nullptr)
-		return 0;
-
-	return PlatformBackend::file_seek(m_handle, seek_to);
+	if (m_file)
+		return m_file->seek(seek_to);
+	return 0;
 }
 
 bool FileStream::is_open() const
 {
-	return m_handle != nullptr;
+	return m_file.get();
 }
 
 bool FileStream::is_readable() const
 {
-	return m_handle != nullptr && (m_mode != FileMode::CreateWrite);
+	return m_file.get() && (m_mode != FileMode::CreateWrite);
 }
 
 bool FileStream::is_writable() const
 {
-	return m_handle != nullptr && (m_mode != FileMode::OpenRead);
+	return m_file.get() && (m_mode != FileMode::OpenRead);
 }
 
-i64 FileStream::read_into(void* ptr, i64 length)
-{
-	if (m_handle == nullptr)
-	{
-		BLAH_ERROR("Unable to read from Stream");
-		return 0;
-	}
-
-	return PlatformBackend::file_read(m_handle, ptr, length);
-}
-
-i64 FileStream::write_from(const void* ptr, i64 length)
+size_t FileStream::read_into(void* ptr, size_t length)
 {
 	if (length <= 0)
 		return 0;
 
-	if (m_handle == nullptr)
-	{
-		BLAH_ERROR("Unable to write to Stream");
-		return 0;
-	}
+	if (m_file)
+		return m_file->read((unsigned char*)ptr, length);
 
-	return PlatformBackend::file_write(m_handle, ptr, length);
+	BLAH_ASSERT(false, "Unable to read from Stream");
+	return 0;
+}
+
+size_t FileStream::write_from(const void* ptr, size_t length)
+{
+	if (length <= 0)
+		return 0;
+
+	if (m_file)
+		return m_file->write((const unsigned char*)ptr, length);
+
+	BLAH_ASSERT(false, "Unable to write to Stream");
+	return 0;
 }
 
 void FileStream::close()
 {
-	if (m_handle != nullptr)
-		PlatformBackend::file_close(m_handle);
-	m_handle = nullptr;
+	m_file.reset();
 }

src/streams/memorystream.cpp

@@ -6,7 +6,7 @@ using namespace Blah;
 MemoryStream::MemoryStream()
 	: m_data(nullptr), m_length(0), m_position(0) {}
 
-MemoryStream::MemoryStream(char* data, i64 length)
+MemoryStream::MemoryStream(char* data, size_t length)
 	: m_data(data), m_length(length), m_position(0) {}
 
 MemoryStream::MemoryStream(MemoryStream&& src) noexcept
@@ -28,7 +28,7 @@ MemoryStream& MemoryStream::operator=(MemoryStream&& src) noexcept
 	return *this;
 }
 
-i64 MemoryStream::read_into(void* ptr, i64 len)
+size_t MemoryStream::read_into(void* ptr, size_t len)
 {
 	if (len < 0 || ptr == nullptr)
 		return 0;
@@ -41,7 +41,7 @@ i64 MemoryStream::read_into(void* ptr, i64 len)
 	return len;
 }
 
-i64 MemoryStream::write_from(const void* ptr, i64 len)
+size_t MemoryStream::write_from(const void* ptr, size_t len)
 {
 	if (len < 0 || ptr == nullptr)
 		return 0;

src/streams/stream.cpp

@@ -4,10 +4,10 @@
 
 using namespace Blah;
 
-i64 Stream::pipe(Stream& stream, i64 length)
+size_t Stream::pipe(Stream& stream, size_t length)
 {
 	const int BUFFER_LENGTH = 4096;
-	i64 result = 0;
+	size_t result = 0;
 
 	char buffer[BUFFER_LENGTH];
 	while (length > 0)
@@ -59,12 +59,12 @@ String Stream::read_line()
 	return result;
 }
 
-i64 Stream::write(const void* buffer, i64 length) 
+size_t Stream::write(const void* buffer, size_t length) 
 { 
 	return write_from(buffer, length);
 }
 
-i64 Stream::write(const String& string)
+size_t Stream::write(const String& string)
 {
 	return write_from(string.begin(), string.length());
 }