Added utilty functions to read an entire file.

source/mijin/io/stream.cpp

@@ -63,6 +63,60 @@ StreamError Stream::writeString(std::string_view str)
     return writeSpan(str.begin(), str.end());
 }
 
+StreamError Stream::getTotalLength(std::size_t& outLength)
+{
+    const StreamFeatures features = getFeatures();
+    if (!features.tell || !features.seek) {
+        return StreamError::NOT_SUPPORTED;
+    }
+    const std::size_t origPos = tell();
+    if (StreamError error = seek(0, SeekMode::RELATIVE_TO_END); error != StreamError::SUCCESS)
+    {
+        return error;
+    }
+    outLength = tell();
+    if (StreamError error = seek(static_cast<std::intptr_t>(origPos)); error != StreamError::SUCCESS)
+    {
+        return error;
+    }
+    return StreamError::SUCCESS;
+}
+
+StreamError Stream::readRest(TypelessBuffer& outBuffer)
+{
+    // first try to allocate everything at once
+    std::size_t length = 0;
+    if (StreamError lengthError = getTotalLength(length); lengthError == StreamError::SUCCESS)
+    {
+        MIJIN_ASSERT(getFeatures().tell, "How did you find the length if you cannot tell()?");
+        length -= tell();
+        outBuffer.resize(length);
+        if (StreamError error = readRaw(outBuffer.data(), length); error != StreamError::SUCCESS)
+        {
+            return error;
+        }
+        return StreamError::SUCCESS;
+    }
+
+    // could not determine the size, read chunk-wise
+    static constexpr std::size_t CHUNK_SIZE = 4096;
+    std::array<std::byte, CHUNK_SIZE> chunk = {};
+
+    while (!isAtEnd())
+    {
+        std::size_t bytesRead = 0;
+        if (StreamError error = readRaw(chunk, true, &bytesRead); error != StreamError::SUCCESS)
+        {
+            return error;
+        }
+
+        outBuffer.resize(outBuffer.byteSize() + bytesRead);
+        std::span<std::byte> bufferBytes = outBuffer.makeSpan<std::byte>();
+        std::copy_n(chunk.begin(), bytesRead, bufferBytes.end() - static_cast<long>(bytesRead));
+    }
+    return StreamError::SUCCESS;
+}
+
 FileStream::~FileStream()
 {
     if (handle) {

source/mijin/io/stream.hpp

@@ -7,8 +7,10 @@
 #include <cassert>
 #include <cstdint>
 #include <optional>
+#include <ranges>
 #include <span>
 #include <string>
+#include "../container/typeless_buffer.hpp"
 
 namespace mijin
 {
@@ -76,12 +78,26 @@ public:
         return readRaw(std::span(ptr, ptr + bytes), partial, outBytesRead);
     }
 
+    template<std::ranges::contiguous_range TRange>
+    inline StreamError readRaw(TRange& range, bool partial = false, std::size_t* outBytesRead = nullptr)
+    {
+        const std::size_t bytes = std::distance(range.begin(), range.end()) * sizeof(std::ranges::range_value_t<TRange>);
+        return readRaw(&*range.begin(), bytes, partial, outBytesRead);
+    }
+
     inline StreamError writeRaw(const void* data, std::size_t bytes)
     {
         const std::uint8_t* ptr = static_cast<const std::uint8_t*>(data);
         return writeRaw(std::span(ptr, ptr + bytes));
     }
 
+    template<std::ranges::contiguous_range TRange>
+    inline StreamError writeRaw(const TRange& range)
+    {
+        const std::size_t bytes = std::distance(range.begin(), range.end()) * sizeof(std::ranges::range_value_t<TRange>);
+        return writeRaw(&*range.begin(), bytes);
+    }
+
     template<typename T>
     inline StreamError read(T& value)
     {
@@ -123,6 +139,12 @@ public:
 
     StreamError readString(std::string& outString);
     StreamError writeString(std::string_view str);
+
+    StreamError getTotalLength(std::size_t& outLength);
+    StreamError readRest(TypelessBuffer& outBuffer);
+
+    template<typename TChar = char>
+    StreamError readAsString(std::basic_string<TChar>& outString);
 };
 
 class FileStream : public Stream
@@ -180,6 +202,42 @@ public:
 // public functions
 //
 
+template<typename TChar>
+StreamError Stream::readAsString(std::basic_string<TChar>& outString)
+{
+    static_assert(sizeof(TChar) == 1, "Can only read to 8-bit character types (char, unsigned char or char8_t");
+
+    // first try to allocate everything at once
+    std::size_t length = 0;
+    if (StreamError lengthError = getTotalLength(length); lengthError == StreamError::SUCCESS)
+    {
+        MIJIN_ASSERT(getFeatures().tell, "How did you find the length if you cannot tell()?");
+        length -= tell();
+        outString.resize(length);
+        if (StreamError error = readRaw(outString.data(), length); error != StreamError::SUCCESS)
+        {
+            return error;
+        }
+        return StreamError::SUCCESS;
+    }
+
+    // could not determine the size, read chunk-wise
+    static constexpr std::size_t CHUNK_SIZE = 4096;
+    std::array<TChar, CHUNK_SIZE> chunk;
+
+    outString.clear();
+    while (!isAtEnd())
+    {
+        std::size_t bytesRead = 0;
+        if (StreamError error = readRaw(chunk, true, &bytesRead); error != StreamError::SUCCESS)
+        {
+            return error;
+        }
+        outString.append(chunk.data(), chunk.data() + bytesRead);
+    }
+    return StreamError::SUCCESS;
+}
+
 } // namespace mijin
 
 #endif // !defined(MIJIN_IO_STREAM_HPP_INCLUDED)

source/mijin/virtual_filesystem/filesystem.hpp

@@ -40,6 +40,21 @@ struct FileInfo
     bool isHidden : 1 = false;
 };
 
+// basically just a thin wrapper around adapter + path, for utility
+class PathReference
+{
+private:
+    class FileSystemAdapter* adapter_;
+    fs::path path_;
+public:
+    PathReference(class FileSystemAdapter* adapter, fs::path path) noexcept : adapter_(adapter), path_(std::move(path)) {}
+
+    [[nodiscard]] class FileSystemAdapter* getAdapter() const noexcept { return adapter_; }
+    [[nodiscard]] const fs::path& getPath() const noexcept { return path_; }
+    [[nodiscard]] inline FileInfo getInfo() const;
+    [[nodiscard]] inline StreamError open(FileOpenMode mode, std::unique_ptr<Stream>& outStream) const;
+};
+
 class FileSystemAdapter
 {
 public:
@@ -50,6 +65,8 @@ public:
     [[nodiscard]] virtual std::vector<FileInfo> listFiles(const fs::path& folder) = 0;
     [[nodiscard]] virtual FileInfo getFileInfo(const fs::path& file) = 0;
     [[nodiscard]] virtual StreamError open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) = 0;
+
+    [[nodiscard]] PathReference getPath(fs::path path) noexcept { return PathReference(this, std::move(path)); }
 };
 
 class OSFileSystemAdapter : public FileSystemAdapter
@@ -68,6 +85,16 @@ public:
 // public functions
 //
 
+inline FileInfo PathReference::getInfo() const
+{
+    return adapter_->getFileInfo(path_);
+}
+
+inline StreamError PathReference::open(FileOpenMode mode, std::unique_ptr<Stream>& outStream) const
+{
+    return adapter_->open(path_, mode, outStream);
+}
+
 inline std::string formatFileType(const FileInfo& info)
 {
     if (info.isFolder) {