Fixed draft FS coroutines example #17

Author: ValentiWorkLearning

Firmware/3rdparty/littlefs_lib/CMakeLists.txt

@@ -14,4 +14,4 @@ target_include_directories(littlefs PUBLIC
 	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/littlefs>
 )
 
-target_compile_definitions(littlefs PUBLIC LFS_YES_TRACE)
+target_compile_definitions(littlefs PUBLIC LFS_YES_TRACE )

Firmware/firmware_tests/coroutine/coroutine_thoughts.cpp

@@ -24,32 +24,24 @@
 #include "wrapper/heap_block_device.hpp"
 #include <spdlog/spdlog.h>
 
-CoroUtils::Task<int> coroutineTask()
-{
-    int b = 32;
-
-    co_return b;
-}
-
-void showFlashDeviceId()
-{
-    CoroUtils::Task<int> task = coroutineTask();
-    int testValue = co_await task;
-}
 using TFilesystem = Platform::Fs::Holder<Wrapper::HeapBlockDevice<
     Wrapper::kBlockSize,
     Wrapper::kSectorsCount,
     Wrapper::kReadSize,
     Wrapper::kEraseSize>>;
 
-CoroUtils::VoidTask simpleRwTest(TFilesystem& filesystem, std::string_view fileName, std::string_view fileData)
+CoroUtils::VoidTask simpleRwTest(
+    TFilesystem& filesystem,
+    std::string_view fileName,
+    std::string_view fileData)
 {
     spdlog::warn("simpleRwTest begin");
     auto lfs = filesystem.fsInstance();
     {
         spdlog::warn("FILE open begin");
-        auto holdedFile = filesystem.openFile(fileName);
-        co_await holdedFile.write(std::span(reinterpret_cast<const std::uint8_t*>(fileData.data()), fileData.size()));
+        auto filename{filesystem.openFile(fileName)};
+        co_await filename.write(
+            std::span(reinterpret_cast<const std::uint8_t*>(fileData.data()), fileData.size()));
         spdlog::warn("FILE open finalize");
     }
 
@@ -59,18 +51,17 @@ CoroUtils::VoidTask simpleRwTest(TFilesystem& filesystem, std::string_view fileN
     {
         spdlog::warn("FILE read begin");
         auto holdedFile = filesystem.openFile(fileName);
-        //co_await holdedFile.read(std::span(readFrom.data(), fileData.size()));
+        co_await holdedFile.read(std::span(readFrom.data(), fileData.size()));
         spdlog::warn("FILE read finalize");
     }
 
-    auto kCompareStringView{std::string_view{reinterpret_cast<const char*>(readFrom.data()), readFrom.size()}};
+    auto kCompareStringView{
+        std::string_view{reinterpret_cast<const char*>(readFrom.data()), readFrom.size()}};
     assert(fileData == kCompareStringView);
     spdlog::warn("simpleRwTest finalize");
 }
 CoroUtils::VoidTask fileTest(TFilesystem& filesystem)
 {
-
-    /*   auto fileWrapped = filesystem.openFile("test");*/
     constexpr auto kFileData = std::string_view("Hello world!");
     simpleRwTest(filesystem, "helloworld.txt", kFileData);
 
@@ -109,10 +100,6 @@ CoroUtils::VoidTask fileTest(TFilesystem& filesystem)
     };
     co_await simpleRwTest(filesystem, "nmeaData.txt", kNmeaDataExample);
 
-    /*co_await file.write(
-        {reinterpret_cast<const std::uint8_t*>(kFileData.data()), kFileData.size()});
-    auto data = co_await file.read(kFileData.size());*/
-
     co_return;
 }
 
@@ -140,8 +127,6 @@ int main()
     //};
     // displayCoro.fillRectangle(0, 0, 0, 0, nullptr);
 
-    showFlashDeviceId();
-
     while (true)
     {
         using namespace std::chrono_literals;

Firmware/firmware_tests/coroutine/fs_ideas/filesystem_holder.hpp

@@ -36,7 +36,7 @@ template <typename TBlockDeviceEntity> class Holder
     using This_t = Holder<TBlockDeviceEntity>;
 
 public:
-    constexpr Holder()noexcept
+    constexpr Holder() noexcept
     {
         m_fsConfig = createLfsConfig();
         auto error = lfs_mount(&m_fsInstance, &m_fsConfig);
@@ -46,18 +46,24 @@ template <typename TBlockDeviceEntity> class Holder
             lfs_mount(&m_fsInstance, &m_fsConfig);
         }
     }
-    constexpr auto fsInstance() noexcept
+
+    constexpr decltype(auto) fsInstance() noexcept
     {
-        return m_fsInstance;
+        return &m_fsInstance;
     }
-    File<This_t> openFile(std::string_view path)noexcept
+    File<This_t> openFile(std::string_view path) noexcept
     {
-        lfs_file_t file{};
-        lfs_file_open(&m_fsInstance, &file, path.data(), LFS_O_RDWR | LFS_O_CREAT);
-        return File<This_t>{std::move(file), &m_fsInstance };
+        File<This_t> retFile{&m_fsInstance};
+        lfs_file_open(
+            &m_fsInstance,
+            retFile.nativeHandle(FilesystemPasskey{}),
+            path.data(),
+            LFS_O_RDWR | LFS_O_CREAT);
+
+        return retFile;
     }
 
-    constexpr TBlockDeviceEntity& getBlockDevice()noexcept
+    constexpr TBlockDeviceEntity& getBlockDevice() noexcept
     {
         return m_blockDeviceHolder;
     }
@@ -69,7 +75,7 @@ template <typename TBlockDeviceEntity> class Holder
         lfs_block_t block,
         lfs_off_t off,
         void* buffer,
-        lfs_size_t size)noexcept
+        lfs_size_t size) noexcept
     {
         auto pThis = reinterpret_cast<This_t*>(c->context);
         pThis->getBlockDevice().read(
@@ -82,7 +88,7 @@ template <typename TBlockDeviceEntity> class Holder
         lfs_block_t block,
         lfs_off_t off,
         const void* buffer,
-        lfs_size_t size)noexcept
+        lfs_size_t size) noexcept
     {
         auto pThis = reinterpret_cast<This_t*>(c->context);
         pThis->getBlockDevice().write(
@@ -91,13 +97,13 @@ template <typename TBlockDeviceEntity> class Holder
         return LFS_ERR_OK;
     }
 
-    constexpr static int eraseCall(const struct lfs_config* c, lfs_block_t block)noexcept
+    constexpr static int eraseCall(const struct lfs_config* c, lfs_block_t block) noexcept
     {
         auto pThis = reinterpret_cast<This_t*>(c->context);
         return LFS_ERR_OK;
     }
 
-    constexpr static int syncCall(const struct lfs_config* c)noexcept
+    constexpr static int syncCall(const struct lfs_config* c) noexcept
     {
         auto pThis = reinterpret_cast<This_t*>(c->context);
         return LFS_ERR_OK;
@@ -145,37 +151,54 @@ template <typename TBlockDeviceEntity> class Holder
 template <typename TFilesystemHolder> class File
 {
 public:
-    explicit constexpr File()noexcept = default;
-    explicit constexpr File(lfs_file_t&& fileHandle, lfs_t* pFsHolder)noexcept
-        : m_pFileHandle{ std::move( fileHandle )}, m_pFsHolder{ pFsHolder }
+    explicit constexpr File(lfs_t* pFsHolder) noexcept
+        : m_pFileHandle{std::make_unique<lfs_file_t>()}, m_pFsHolder{pFsHolder}
+    {
+    }
+
+    constexpr File(File&& otherHandle) noexcept
+        : m_pFileHandle{std::move(otherHandle.m_pFileHandle)}
+        , m_pFsHolder{std::exchange(otherHandle.m_pFsHolder, nullptr)}
     {
-        spdlog::warn("File::File()");
     }
+
     ~File()
     {
-        lfs_file_close(m_pFsHolder, &m_pFileHandle);
+        if (!m_pFsHolder)
+            return;
+
+        lfs_file_close(m_pFsHolder, m_pFileHandle.get());
         spdlog::warn("~File::File()");
     }
-    CoroUtils::VoidTask write(std::span<const std::uint8_t> dataHolder)noexcept
+
+    CoroUtils::VoidTask write(std::span<const std::uint8_t> dataHolder) noexcept
     {
-        lfs_file_write(m_pFsHolder, &m_pFileHandle, dataHolder.data(), static_cast<lfs_size_t>(dataHolder.size()));
+        lfs_file_write(
+            m_pFsHolder,
+            m_pFileHandle.get(),
+            dataHolder.data(),
+            static_cast<lfs_size_t>(dataHolder.size()));
         co_return;
     }
 
-    CoroUtils::Task<std::span<std::uint8_t>> read(std::span<std::uint8_t> outBuffer)noexcept
+    CoroUtils::Task<std::span<std::uint8_t>> read(std::span<std::uint8_t> outBuffer) noexcept
     {
-        lfs_file_read(m_pFsHolder, &m_pFileHandle, outBuffer.data(), static_cast<lfs_size_t>(outBuffer.size()));
+        lfs_file_read(
+            m_pFsHolder,
+            m_pFileHandle.get(),
+            outBuffer.data(),
+            static_cast<lfs_size_t>(outBuffer.size()));
         co_return outBuffer;
     }
 
-    lfs_file_t nativeHandle(const FilesystemPasskey& passkey)noexcept
+    lfs_file_t* nativeHandle(const FilesystemPasskey& passkey) noexcept
     {
         Meta::UnuseVar(passkey);
-        return m_pFileHandle;
+        return m_pFileHandle.get();
     }
 
 private:
-    lfs_file_t m_pFileHandle;
+    std::unique_ptr<lfs_file_t> m_pFileHandle;
     lfs_t* m_pFsHolder;
 };
 } // namespace Platform::Fs

Firmware/firmware_tests/coroutine/wrapper/heap_block_device.hpp

@@ -52,7 +52,7 @@ class HeapBlockDevice : public BlockDeviceEntity<HeapBlockDevice<BlockSize, Sect
     constexpr void write(
         std::uint32_t _address,
         const std::uint8_t* _blockData,
-        std::size_t _blockSize) noexcept
+        std::uint32_t _blockSize) noexcept
     {
         spdlog::info(
             "HeapBlockDevice::WRITE to: address:{0} blockData:{1} blockSize: {2}",

Firmware/firmware_tests/coroutine/wrapper/ih_block_device.hpp

@@ -27,7 +27,7 @@ template <typename TImpl> class BlockDeviceEntity
         return offspring()->getEraseSize();
     }
 
-    constexpr void write(std::uint32_t _address, const std::uint8_t* _blockData, std::size_t _blockSize) noexcept
+    constexpr void write(std::uint32_t _address, const std::uint8_t* _blockData, std::uint32_t _blockSize) noexcept
     {
         offspring()->write(_address, _blockData, _blockSize);
     }