filesystem.cpp

Go to the documentation of this file.

 
#include <filesystem/filesystem.h>
#include <common/logger.h>
 
using namespace MaxOS;
using namespace MaxOS::filesystem;
using namespace MaxOS::common;
 
File::File() = default;
 
File::~File() = default;
 
void File::write(buffer_t* data, size_t amount) {
}
 
void File::read(common::buffer_t* data, size_t amount) {
}
 
void File::flush() {
}
 
void File::seek(SeekType seek_type, size_t offset) {
 
    // Seek based on the type
    switch (seek_type) {
        case SeekType::SET:
            m_offset = offset;
            break;
 
        case SeekType::CURRENT:
            m_offset += offset;
            break;
 
        case SeekType::END:
            m_offset = size() - offset;
            break;
    }
}
 
uint32_t File::position() const {
    return m_offset;
}
 
string File::name() {
    return m_name;
}
 
size_t File::size() const {
    return m_size;
}
 
Directory::Directory() = default;
 
Directory::~Directory() {
 
    // Free the files
    for (auto &file: m_files)
        delete file;
 
    // Free the subdirectories
    for (auto &subdirectory: m_subdirectories)
        delete subdirectory;
 
}
 
void Directory::read_from_disk() {
 
}
 
common::Vector<File*> Directory::files() {
    return m_files;
}
 
File* Directory::open_file(const string &name) {
 
    // Try to find the file
    for (auto &file: m_files)
        if (file->name() == name)
            return file;
 
    // File not found
    return nullptr;
}
 
File* Directory::create_file(const string &name) {
    return nullptr;
}
 
void Directory::remove_file(const string &name) {
}
 
common::Vector<Directory*> Directory::subdirectories() {
    return m_subdirectories;
}
 
Directory* Directory::open_subdirectory(const string &name) {
 
    // Try to find the directory
    for (auto &subdirectory: m_subdirectories)
        if (subdirectory->name() == name) {
            subdirectory->read_from_disk();
            return subdirectory;
        }
 
    // Directory not found
    return nullptr;
}
 
Directory* Directory::create_subdirectory(const string &name) {
    return nullptr;
}
 
void Directory::remove_subdirectory(const string &name) {
}
 
 
string Directory::name() {
    return m_name;
}
 
size_t Directory::size() {
 
    // Sum the size of all the files
    size_t size = 0;
    for (auto &file: m_files)
        size += file->size();
 
    return size;
 
}
 
void Directory::rename_file(File* file, string const &new_name) {
 
    rename_file(file->name(), new_name);
 
}
 
void Directory::rename_file(string const &old_name, string const &new_name) {
 
    ASSERT(false, "not implemented");
 
}
 
void Directory::rename_subdirectory(Directory* directory, string const &new_name) {
 
    rename_subdirectory(directory->name(), new_name);
 
}
 
void Directory::rename_subdirectory(string const &old_name, string const &new_name) {
    ASSERT(false, "not implemented");
}
 
FileSystem::FileSystem() = default;
 
FileSystem::~FileSystem() {
 
    // Free the root directory
    delete m_root_directory;
 
}
 
Directory* FileSystem::root_directory() {
    return m_root_directory;
}
 
Directory* FileSystem::get_directory(const string &path) {
 
    // Check if the path is the root
    if (path == "/")
        return root_directory();
 
    // Recursively open the directory
    Directory* directory = root_directory();
    string directory_path = path;
    while (directory_path.length() > 0) {
 
        // Get the name of the directory
        string directory_name = Path::top_directory(directory_path);
 
        // Open the directory
        Directory* subdirectory = directory->open_subdirectory(directory_name);
        if (!subdirectory)
            return nullptr;
 
        // Set the new directory
        directory = subdirectory;
 
        // Get the path to the next directory
        directory_path = directory_path.substring(directory_name.length() + 1, directory_path.length() - directory_name.length() - 1);
    }
 
    return directory;
}
 
bool FileSystem::exists(const string &path) {
 
    // Get the directory at the path
    string directory_path = Path::file_path(path);
    Directory* directory = get_directory(directory_path);
 
    // Check if the directory exists
    if (!directory)
        return false;
 
    // Check if the file exists
    const string file_name = Path::file_name(path);
    return directory->open_file(file_name) != nullptr;
}