fs.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#ifdef CONFIG_OVE_FS
 
#include <ove/fs.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
 
namespace ove
{
 
namespace fs
{
 
[[nodiscard]] inline Result<void> mount(const char *dev_path, const char *mount_point) noexcept
{
    return from_rc(ove_fs_mount(dev_path, mount_point));
}
 
inline void unmount(const char *mount_point)
{
    ove_fs_unmount(mount_point);
}
 
[[nodiscard]] inline Result<void> unlink(const char *path) noexcept
{
    return from_rc(ove_fs_unlink(path));
}
 
[[nodiscard]] inline Result<void> rename(const char *old_path, const char *new_path) noexcept
{
    return from_rc(ove_fs_rename(old_path, new_path));
}
 
} /* namespace fs */
 
class File
{
      public:
    File() : handle_(nullptr)
    {
    }
 
    ~File() noexcept
    {
        close();
    }
 
    File(const File &) = delete;
    File &operator=(const File &) = delete;
 
    File(File &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    File &operator=(File &&other) noexcept
    {
        if (this != &other) {
            close();
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
 
    [[nodiscard]] Result<void> open(const char *path, int flags) noexcept
    {
        return from_rc(ove_fs_open(&handle_, path, flags));
    }
 
    void close() noexcept
    {
        if (handle_) {
            (void)ove_fs_close(handle_);
            handle_ = nullptr;
        }
    }
 
    [[nodiscard]] Result<size_t> read(void *buf, size_t count) noexcept
    {
        size_t bytes_read = 0;
        const int rc = ove_fs_read(handle_, buf, count, &bytes_read);
        return from_rc(rc, bytes_read);
    }
 
    [[nodiscard]] Result<size_t> write(const void *buf, size_t count) noexcept
    {
        size_t bytes_written = 0;
        const int rc = ove_fs_write(handle_, buf, count, &bytes_written);
        return from_rc(rc, bytes_written);
    }
 
    [[nodiscard]] Result<void> seek(long offset, int whence) noexcept
    {
        return from_rc(ove_fs_seek(handle_, offset, whence));
    }
 
    long tell()
    {
        return ove_fs_tell(handle_);
    }
 
    [[nodiscard]] Result<size_t> size() noexcept
    {
        size_t out_size = 0;
        const int rc = ove_fs_size(handle_, &out_size);
        return from_rc(rc, out_size);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_file_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_file_t handle_ = nullptr;
};
 
class Dir
{
      public:
    Dir() : handle_(nullptr)
    {
    }
 
    ~Dir() noexcept
    {
        close();
    }
 
    Dir(const Dir &) = delete;
    Dir &operator=(const Dir &) = delete;
 
    Dir(Dir &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Dir &operator=(Dir &&other) noexcept
    {
        if (this != &other) {
            close();
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
 
    [[nodiscard]] Result<void> open(const char *path) noexcept
    {
        return from_rc(ove_fs_opendir(&handle_, path));
    }
 
    void close() noexcept
    {
        if (handle_) {
            (void)ove_fs_closedir(handle_);
            handle_ = nullptr;
        }
    }
 
    [[nodiscard]] Result<bool> readdir(struct ove_dirent *entry) noexcept
    {
        const int rc = ove_fs_readdir(handle_, entry);
        if (rc == OVE_OK)
            return true;
        if (rc == OVE_ERR_EOF)
            return false;
        return std::unexpected{static_cast<Error>(rc)};
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_dir_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_dir_t handle_ = nullptr;
};
 
} /* namespace ove */
 
#endif /* CONFIG_OVE_FS */