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>
 
namespace ove {
 
namespace fs {
 
[[nodiscard]] inline int mount(const char *dev_path,
                const char *mount_point) {
    return ove_fs_mount(dev_path, mount_point);
}
 
inline void unmount(const char *mount_point) {
    ove_fs_unmount(mount_point);
}
 
[[nodiscard]] inline int unlink(const char *path) {
    return ove_fs_unlink(path);
}
 
[[nodiscard]] inline int rename(const char *old_path,
                 const char *new_path) {
    return ove_fs_rename(old_path, new_path);
}
 
} /* namespace fs */
 
class File {
public:
    File() : handle_(nullptr) {}
 
    ~File() { 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]] int open(const char *path, int flags) {
        return ove_fs_open(&handle_, path, flags);
    }
 
    int close() {
        int ret = OVE_OK;
        if (handle_) {
            ret = ove_fs_close(handle_);
            handle_ = nullptr;
        }
        return ret;
    }
 
    [[nodiscard]] int read(void *buf, size_t count, size_t *bytes_read) {
        return ove_fs_read(handle_, buf, count, bytes_read);
    }
 
    [[nodiscard]] int write(const void *buf, size_t count,
                 size_t *bytes_written) {
        return ove_fs_write(handle_, buf, count, bytes_written);
    }
 
    [[nodiscard]] int seek(long offset, int whence) {
        return ove_fs_seek(handle_, offset, whence);
    }
 
    long tell() {
        return ove_fs_tell(handle_);
    }
 
    [[nodiscard]] int size(size_t *out_size) {
        return ove_fs_size(handle_, out_size);
    }
 
    bool valid() const { return handle_ != nullptr; }
 
    ove_file_t handle() const { return handle_; }
 
private:
    ove_file_t handle_;
};
 
class Dir {
public:
    Dir() : handle_(nullptr) {}
 
    ~Dir() { 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]] int open(const char *path) {
        return ove_fs_opendir(&handle_, path);
    }
 
    int close() {
        int ret = OVE_OK;
        if (handle_) {
            ret = ove_fs_closedir(handle_);
            handle_ = nullptr;
        }
        return ret;
    }
 
    [[nodiscard]] int readdir(struct ove_dirent *entry) {
        return ove_fs_readdir(handle_, entry);
    }
 
    bool valid() const { return handle_ != nullptr; }
 
    ove_dir_t handle() const { return handle_; }
 
private:
    ove_dir_t handle_;
};
 
} /* namespace ove */
 
#endif /* CONFIG_OVE_FS */