game/mario/filesystem/windows/filesystem.cpp

#include "../../filesystem.hpp"
#include <Shlwapi.h>
#include <cstring>
#include <stdexcept>
#include <windows.h>

char FSLib::dir_divisor = '\\';

FSLib::Directory::Directory(const string &path_) : dir_path(path_) {
    // need to append \\* for windows to search files in directory
    dir_path.append(L"\\*");
}

FSLib::Directory::Iterator::Iterator(const Directory &d_) {
    if (!exists(d_.validPath()) || !isDirectory(d_.validPath())) {
        throw std::runtime_error(
            "Directory either doesn't exist or isn't a directory");
    }
    hFind = FindFirstFileW(d_.path(), &data);
    if (hFind != INVALID_HANDLE_VALUE) {
        if (!wcscmp(data.cFileName, L".") || !wcscmp(data.cFileName, L"..")) {
            ++(*this);
        }
    } else {
        ended = true;
    }
}

FSLib::Directory::Iterator::~Iterator() {
    if (hFind)
        FindClose(hFind);
}

// this is definitely not a good way to create the "end" iterator
// but it was the only way I thought of with my limited knowledge of
// windows.h
FSLib::Directory::Iterator::Iterator(bool ended_) : ended(ended_) {}

bool FSLib::exists(const string &path) {
    struct _stat path_stat;
    return _wstat(path.c_str(), &path_stat) == 0;
}

string FSLib::canonical(const string &path) {
    char_t *full_path = new char_t[MAX_PATH];
    char_t *canonical_path = new char_t[MAX_PATH];

    auto failed = !GetFullPathName(path.c_str(), MAX_PATH, full_path, NULL);

    if (failed) {
        delete[] canonical_path;
        delete[] full_path;
        return string();
    }

    failed = !PathCanonicalizeW(canonical_path, full_path);

    delete[] full_path;

    if (failed) {
        delete[] canonical_path;
        return string();
    }

    string canonical_string{ canonical_path };
    delete[] canonical_path;
    return canonical_string;
}

bool FSLib::isDirectory(const string &path) {
    struct _stat path_stat;

    if (_wstat(path.c_str(), &path_stat) != 0)
        return false;

    return path_stat.st_mode & _S_IFDIR;
}

bool FSLib::rename(const string &file_a, const string &file_b) {
    return MoveFileExW(file_a.c_str(), file_b.c_str(),
                       MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING);
}

bool FSLib::createDirectoryFull(const string &path) {
    uint64_t pos = path.find_first_of(L":", 0) + 2;
    if (pos == string::npos)
        pos = 0;
    // go through all directories leading to the last one
    // and create them if they don't exist
    do {
        // get partial directory path
        pos = path.find_first_of(L"\\", pos);
        auto dirname = path.substr(0, pos);
        // create it if it doesn't exist
        if (!FSLib::exists(dirname)) {
            if (!CreateDirectoryW(dirname.c_str(), NULL))
                return false;
        }
        pos++;
    } while (pos < path.length() && pos != 0);
    return true;
}

FSLib::Directory::iterator FSLib::Directory::end() {
    return Iterator(true);
}

FSLib::Directory::const_iterator FSLib::Directory::end() const {
    return Iterator(true);
}

char_t const *FSLib::Directory::Iterator::operator*() const {
    return data.cFileName;
}

FSLib::Directory::Iterator &FSLib::Directory::Iterator::operator++() {
    if (ended == true)
        return *this;
    // skip . and ..
    if (FindNextFileW(hFind, &data) == 0) {
        ended = true;
    } else if (!wcscmp(data.cFileName, L".") ||
               !wcscmp(data.cFileName, L"..")) {
        return operator++();
    }
    return *this;
}

bool FSLib::Directory::Iterator::operator==(const Iterator &i_other) const {
    return i_other.ended == ended;
}

string FSLib::getContainingDirectory(const string &path) {
    auto pos = path.find_last_of('\\');
    if (pos == string::npos) {
        return ".";
    }
    return path.substr(0, pos);
}

string FSLib::getFileName(const string &path) {
    auto pos = path.find_last_of('\\');
    if (pos == string::npos) {
        return path;
    }
    return path.substr(pos + 1);
}

string FSLib::getFileExtension(const string &path) {
    auto pos = path.find_last_of('.');
    if (pos == string::npos) {
        return "";
    }
    return path.substr(pos + 1);
}