Added clang-tidy config and cleaned up the code a little.

source/mijin/io/stream.cpp

@@ -3,7 +3,6 @@
 
 #include <algorithm>
 #include <array>
-#include <cassert>
 #include <limits>
 
 namespace mijin
@@ -327,25 +326,25 @@ StreamError FileStream::open(const char* path, FileOpenMode mode_)
     }
 
     int result = std::fseek(handle, 0, SEEK_END);
-    assert(result == 0);
+    MIJIN_ASSERT(result == 0, "fseek failed.");
     length = std::ftell(handle);
     result = std::fseek(handle, 0, SEEK_SET);
-    assert(result == 0);
+    MIJIN_ASSERT(result == 0, "fseek failed.");
 
     return StreamError::SUCCESS;
 }
 
 void FileStream::close()
 {
-    assert(handle);
+    MIJIN_ASSERT(handle != nullptr, "FileStream is not open.");
     const int result = std::fclose(handle); // NOLINT(cppcoreguidelines-owning-memory)
-    assert(result == 0);
+    MIJIN_ASSERT(result == 0, "fclose failed.");
 }
 
 StreamError FileStream::readRaw(std::span<std::uint8_t> buffer, const ReadOptions& options, std::size_t* outBytesRead)
 {
-    assert(handle);
-    assert(mode == FileOpenMode::READ || mode == FileOpenMode::READ_WRITE);
+    MIJIN_ASSERT(handle != nullptr, "FileStream is not open.");
+    MIJIN_ASSERT(mode == FileOpenMode::READ || mode == FileOpenMode::READ_WRITE, "Cannot read from this stream");
 
     const std::size_t readBytes = std::fread(buffer.data(), 1, buffer.size(), handle);
     if (std::ferror(handle)) {
@@ -369,8 +368,9 @@ StreamError FileStream::readRaw(std::span<std::uint8_t> buffer, const ReadOption
 
 StreamError FileStream::writeRaw(std::span<const std::uint8_t> buffer)
 {
-    assert(handle);
-    assert(mode == FileOpenMode::WRITE || mode == FileOpenMode::APPEND || mode == FileOpenMode::READ_WRITE);
+    MIJIN_ASSERT(handle != nullptr, "FileStream is not open.");
+    MIJIN_ASSERT(mode == FileOpenMode::WRITE || mode == FileOpenMode::READ_WRITE || mode == FileOpenMode::APPEND,
+                 "Cannot write to this stream");
 
     const std::size_t written = std::fwrite(buffer.data(), 1, buffer.size(), handle);
     if (written != buffer.size() || std::ferror(handle)) {
@@ -383,15 +383,13 @@ StreamError FileStream::writeRaw(std::span<const std::uint8_t> buffer)
 
 std::size_t FileStream::tell()
 {
-    assert(handle);
-
+    MIJIN_ASSERT(handle != nullptr, "FileStream is not open.");
     return std::ftell(handle);
 }
 
 StreamError FileStream::seek(std::intptr_t pos, SeekMode seekMode)
 {
-    assert(handle);
-    
+    MIJIN_ASSERT(handle != nullptr, "FileStream is not open.");
     int origin; // NOLINT(cppcoreguidelines-init-variables)
     switch (seekMode)
     {
@@ -405,7 +403,7 @@ StreamError FileStream::seek(std::intptr_t pos, SeekMode seekMode)
             origin = SEEK_END;
             break;
         default:
-            assert(!"Invalid value passed as seekMode!");
+            MIJIN_ERROR("Invalid value passed as seekMode!");
             return StreamError::UNKNOWN_ERROR;
     }
     const int result = std::fseek(handle, static_cast<long>(pos), origin);
@@ -418,19 +416,19 @@ StreamError FileStream::seek(std::intptr_t pos, SeekMode seekMode)
 void FileStream::flush()
 {
     const int result = std::fflush(handle);
-    assert(result == 0);
+    MIJIN_ASSERT(result == 0, "fflush failed.");
 }
 
 bool FileStream::isAtEnd()
 {
-    assert(handle);
+    MIJIN_ASSERT(handle != nullptr, "FileStream is not open.");
 
     (void) std::fgetc(handle);
     if (std::feof(handle)) {
         return true;
     }
     const int result = std::fseek(handle, -1, SEEK_CUR);
-    assert(result == 0);
+    MIJIN_ASSERT(result == 0, "fseek failed.");
     return false;
 }
 
@@ -454,7 +452,7 @@ StreamFeatures FileStream::getFeatures()
 
 void MemoryStream::openRW(std::span<std::uint8_t> data)
 {
-    assert(!isOpen());
+    MIJIN_ASSERT(!isOpen(), "MemoryStream is already open.");
     data_ = data;
     pos_ = 0;
     canWrite_ = true;
@@ -462,7 +460,7 @@ void MemoryStream::openRW(std::span<std::uint8_t> data)
 
 void MemoryStream::openROImpl(const void* data, std::size_t bytes)
 {
-    assert(!isOpen());
+    MIJIN_ASSERT(!isOpen(), "MemoryStream is already open.");
     data_ = std::span<std::uint8_t>(const_cast<std::uint8_t*>(static_cast<const std::uint8_t*>(data)), bytes); // NOLINT(cppcoreguidelines-pro-type-const-cast) we'll be fine
     pos_ = 0;
     canWrite_ = false;
@@ -470,13 +468,13 @@ void MemoryStream::openROImpl(const void* data, std::size_t bytes)
 
 void MemoryStream::close()
 {
-    assert(isOpen());
+    MIJIN_ASSERT(isOpen(), "MemoryStream is not open.");
     data_ = {};
 }
 
 StreamError MemoryStream::readRaw(std::span<std::uint8_t> buffer, const ReadOptions& options, std::size_t* outBytesRead)
 {
-    assert(isOpen());
+    MIJIN_ASSERT(isOpen(), "MemoryStream is not open.");
     if (!options.partial && availableBytes() < buffer.size()) {
         return StreamError::IO_ERROR; // TODO: need more errors?
     }
@@ -493,8 +491,11 @@ StreamError MemoryStream::readRaw(std::span<std::uint8_t> buffer, const ReadOpti
 
 StreamError MemoryStream::writeRaw(std::span<const std::uint8_t> buffer)
 {
-    assert(isOpen());
-    assert(canWrite_);
+    MIJIN_ASSERT(isOpen(), "MemoryStream is not open.");
+
+    if (!canWrite_) {
+        return StreamError::NOT_SUPPORTED;
+    }
 
     if (availableBytes() < buffer.size()) {
         return StreamError::IO_ERROR;
@@ -506,13 +507,13 @@ StreamError MemoryStream::writeRaw(std::span<const std::uint8_t> buffer)
 
 std::size_t MemoryStream::tell()
 {
-    assert(isOpen());
+    MIJIN_ASSERT(isOpen(), "MemoryStream is not open.");
     return pos_;
 }
 
 StreamError MemoryStream::seek(std::intptr_t pos, SeekMode seekMode)
 {
-    assert(isOpen());
+    MIJIN_ASSERT(isOpen(), "MemoryStream is not open.");
     std::intptr_t newPos = -1;
     switch (seekMode)
     {
@@ -535,7 +536,7 @@ StreamError MemoryStream::seek(std::intptr_t pos, SeekMode seekMode)
 
 bool MemoryStream::isAtEnd()
 {
-    assert(isOpen());
+    MIJIN_ASSERT(isOpen(), "MemoryStream is not open.");
     return pos_ == data_.size();
 }