Changing cdrom-loader API to use buffers.

Author: nicolasnoble

src/mips/psyqo-paths/cdrom-loader.hh

@@ -27,12 +27,11 @@ SOFTWARE.
 #pragma once
 
 #include <EASTL/string_view.h>
-#include <EASTL/vector.h>
 #include <stdint.h>
 
 #include <coroutine>
 
-#include "psyqo/gpu.hh"
+#include "psyqo/buffer.hh"
 #include "psyqo/iso9660-parser.hh"
 #include "psyqo/task.hh"
 
@@ -44,7 +43,7 @@ namespace psyqo::paths {
  * @details This class provides a PSYQo path to read files from the CDRom.
  * The way to use it is to instantiate the class somewhere persistent, and
  * then call readFile() with a callback. The callback will be called with
- * the data of the file, or an empty vector if the file could not be read.
+ * the data of the file, or an empty buffer if the file could not be read.
  * This is going to allocate memory in different places. Only one file can
  * be read at a time, but it is safe to call readFile() again from the
  * callback. If preferred, the loader can be cascaded into another `TaskQueue`.
@@ -54,59 +53,70 @@ namespace psyqo::paths {
 
 class CDRomLoader {
     struct ReadFileAwaiter {
-        ReadFileAwaiter(eastl::string_view path, GPU &gpu, ISO9660Parser &parser, CDRomLoader &loader)
-            : m_path(path), m_gpu(gpu), m_parser(parser), m_loader(loader) {}
+        ReadFileAwaiter(eastl::string_view path, ISO9660Parser &parser, CDRomLoader &loader)
+            : m_path(path), m_parser(parser), m_loader(loader) {}
         ~ReadFileAwaiter() {}
         constexpr bool await_ready() const { return false; }
         template <typename U>
         void await_suspend(std::coroutine_handle<U> handle) {
-            m_loader.readFile(m_path, m_gpu, m_parser, [handle, this](eastl::vector<uint8_t> &&data) {
+            m_loader.readFile(m_path, m_parser, [handle, this](Buffer<uint8_t> &&data) {
                 m_data = eastl::move(data);
                 handle.resume();
             });
         }
-        eastl::vector<uint8_t> await_resume() { return eastl::move(m_data); }
+        Buffer<uint8_t> await_resume() { return eastl::move(m_data); }
 
       private:
         eastl::string_view m_path;
-        GPU &m_gpu;
         ISO9660Parser &m_parser;
         CDRomLoader &m_loader;
-        eastl::vector<uint8_t> m_data;
+        Buffer<uint8_t> m_data;
     };
 
   public:
+    /**
+     * @brief Set the Buffer object for the next read operation.
+     *
+     * @details This function sets the buffer to be used for the next read
+     * operation. By default, the archive manager will allocate a buffer of the
+     * appropriate size for the file being read. However, if the user wants to
+     * use an already allocated buffer, they can use this function to set the buffer
+     * to be used.
+     *
+     * @param buffer The buffer to be used for the next read operation.
+     */
+    void setBuffer(Buffer<uint8_t> &&buffer) { m_data = eastl::move(buffer); }
+
     /**
      * @brief Reads a file from the CDRom.
      *
      * @param path The path to the file to read. The view must be persistent
      * until the callback is called.
-     * @param gpu The GPU class used by the application, in order to set timers.
      * @param parser The ISO9660Parser to use for reading the file.
      * @param callback The callback to call when the file is read. The callback
-     * will be called with the data of the file, or an empty vector if the file
+     * will be called with the data of the file, or an empty buffer if the file
      * could not be read.
      */
-    void readFile(eastl::string_view path, GPU &gpu, ISO9660Parser &parser,
-                  eastl::function<void(eastl::vector<uint8_t> &&)> &&callback) {
-        setupQueue(path, gpu, parser, eastl::move(callback));
+    void readFile(eastl::string_view path, ISO9660Parser &parser,
+                  eastl::function<void(Buffer<uint8_t> &&)> &&callback) {
+        setupQueue(path, parser, eastl::move(callback));
         m_queue.run();
     }
-    psyqo::TaskQueue::Task scheduleReadFile(eastl::string_view path, GPU &gpu, ISO9660Parser &parser) {
-        setupQueue(path, gpu, parser, {});
+    psyqo::TaskQueue::Task scheduleReadFile(eastl::string_view path, ISO9660Parser &parser) {
+        setupQueue(path, parser, {});
         return m_queue.schedule();
     }
-    ReadFileAwaiter readFile(eastl::string_view path, GPU &gpu, ISO9660Parser &parser) {
-        return {path, gpu, parser, *this};
+    ReadFileAwaiter readFile(eastl::string_view path, ISO9660Parser &parser) {
+        return {path, parser, *this};
     }
 
   private:
-    void setupQueue(eastl::string_view path, GPU &gpu, ISO9660Parser &parser,
-                    eastl::function<void(eastl::vector<uint8_t> &&)> &&callback);
-    eastl::function<void(eastl::vector<uint8_t> &&)> m_callback;
+    void setupQueue(eastl::string_view path, ISO9660Parser &parser,
+                    eastl::function<void(Buffer<uint8_t> &&)> &&callback);
+    eastl::function<void(Buffer<uint8_t> &&)> m_callback;
     psyqo::TaskQueue m_queue;
     ISO9660Parser::ReadRequest m_request;
-    eastl::vector<uint8_t> m_data;
+    Buffer<uint8_t> m_data;
     bool m_pending = false;
 };
 

src/mips/psyqo-paths/examples/cdrom-loader/cdrom-loader.cpp

@@ -44,7 +44,7 @@ class CDRomLoaderExample final : public psyqo::Application {
     psyqo::CDRomDevice m_cdrom;
     psyqo::ISO9660Parser m_isoParser = psyqo::ISO9660Parser(&m_cdrom);
     psyqo::paths::CDRomLoader m_cdromLoader;
-    eastl::vector<uint8_t> m_buffer;
+    psyqo::Buffer<uint8_t> m_buffer;
     bool m_callbackCalled = false;
 };
 
@@ -70,8 +70,8 @@ void CDRomLoaderExample::prepare() {
 void CDRomLoaderExample::createScene() {
     m_font.uploadSystemFont(gpu());
     pushScene(&cdromLoaderExampleScene);
-    m_cdromLoader.readFile("SYSTEM.CNF;1", cdromLoaderExample.gpu(), cdromLoaderExample.m_isoParser,
-                           [this](eastl::vector<uint8_t>&& buffer) {
+    m_cdromLoader.readFile("SYSTEM.CNF;1", cdromLoaderExample.m_isoParser,
+                           [this](psyqo::Buffer<uint8_t>&& buffer) {
                                m_buffer = eastl::move(buffer);
                                m_callbackCalled = true;
                            });

src/mips/psyqo-paths/src/cdrom-loader.cpp

@@ -28,8 +28,8 @@ SOFTWARE.
 
 #include "psyqo/kernel.hh"
 
-void psyqo::paths::CDRomLoader::setupQueue(eastl::string_view path, GPU& gpu, psyqo::ISO9660Parser& parser,
-                                           eastl::function<void(eastl::vector<uint8_t>&&)>&& callback) {
+void psyqo::paths::CDRomLoader::setupQueue(eastl::string_view path, psyqo::ISO9660Parser& parser,
+                                           eastl::function<void(Buffer<uint8_t>&&)>&& callback) {
     Kernel::assert(!m_pending, "Only one file can be read at a time");
     m_queue.reset();
     m_pending = true;