resource-manager.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_RESOURCES_RESOURCE_MANAGER_HPP
#define ANTKEEPER_RESOURCES_RESOURCE_MANAGER_HPP
 
#include <engine/debug/log.hpp>
#include <engine/resources/deserialize-context.hpp>
#include <engine/resources/deserializer.hpp>
#include <engine/resources/serialize-context.hpp>
#include <engine/resources/serializer.hpp>
#include <engine/resources/resource-loader.hpp>
#include <filesystem>
#include <memory>
#include <stdexcept>
#include <unordered_map>
 
class resource_manager
{
public:
    resource_manager();
    
    ~resource_manager();
    
    bool mount(const std::filesystem::path& path);
    
    bool unmount(const std::filesystem::path& path);
    
    template <class T>
    std::shared_ptr<T> load(const std::filesystem::path& path);
    
    template <class T>
    bool save(const T& resource, const std::filesystem::path& path) const;
    
    bool set_write_path(const std::filesystem::path& path);
    
    [[nodiscard]] inline const std::filesystem::path& get_write_path() const noexcept
    {
        return write_path;
    }
 
private:
    [[nodiscard]] std::shared_ptr<void> fetch(const std::filesystem::path& path) const;
    
    [[nodiscard]] std::unique_ptr<deserialize_context> open_read(const std::filesystem::path& path) const;
    
    [[nodiscard]] std::unique_ptr<serialize_context> open_write(const std::filesystem::path& path) const;
    
    std::unordered_map<std::filesystem::path, std::weak_ptr<void>> resource_cache;
    std::filesystem::path write_path;
};
 
template <class T>
std::shared_ptr<T> resource_manager::load(const std::filesystem::path& path)
{
    // Fetch cached resource, if any
    if (auto resource = fetch(path))
    {
        return std::static_pointer_cast<T>(resource);
    }
    
    const auto path_string = path.string();
    
    try
    {
        debug::log_trace("Loading resource \"{}\"...", path_string);
        
        // Open file for reading
        auto deserialize_ctx = open_read(path);
        
        // Load and cache resource
        std::shared_ptr<T> resource = resource_loader<T>::load(*this, *deserialize_ctx);
        resource_cache[path] = resource;
        
        debug::log_trace("Loaded resource \"{}\"", path_string);
        
        return resource;
    }
    catch (const std::exception& e)
    {
        debug::log_error("Failed to load resource \"{}\": {}", path_string, e.what());
    }
    
    return nullptr;
}
 
template <class T>
bool resource_manager::save(const T& resource, const std::filesystem::path& path) const
{
    const auto path_string = path.string();
    
    try
    {
        debug::log_trace("Saving resource to \"{}\"...", path_string);
        
        // Open file for writing
        auto serialize_ctx = open_write(path);
        
        serializer<T>().serialize(resource, *serialize_ctx);
        
        debug::log_trace("Saved resource to \"{}\"", path_string);
        
        return true;
    }
    catch (const std::exception& e)
    {
        debug::log_error("Failed to save resource to \"{}\": {}", path_string, e.what());
    }
    
    return false;
}
 
#endif // ANTKEEPER_RESOURCES_RESOURCE_MANAGER_HPP