ResourceManager.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_RESOURCE_MANAGER_H
#define GF_RESOURCE_MANAGER_H

#include <functional>
#include <future>
#include <initializer_list>
#include <map>
#include <memory>
#include <stdexcept>

#include "AssetManager.h"
#include "Image.h"
#include "Font.h"
#include "Portability.h"
#include "Texture.h"
#include "Window.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  template<typename T>
  class ResourceCache {
  public:
    using Loader = std::function<std::unique_ptr<T>(const Path&)>;

    explicit ResourceCache(Loader loader)
    : m_loader(std::move(loader))
    {

    }

    ResourceCache(const ResourceCache&) = delete;

    ResourceCache& operator=(const ResourceCache&) = delete;

    T& getResource(AssetManager& assets, Path filename) {
      // try to find a known prefix
      if (filename.is_absolute()) {
        Path relativePath = assets.getRelativePath(filename);

        if (!relativePath.empty()) {
          filename = relativePath;
        }
      }

      std::size_t h = boost::filesystem::hash_value(filename);

      auto it = m_cache.find(h);

      if (it != m_cache.end()) {
        return *it->second;
      }

      Path absolutePath = assets.getAbsolutePath(filename);

      if (absolutePath.empty()) {
        throw std::runtime_error("Path not found");
      }

      auto ptr = m_loader(absolutePath);

      if (!ptr) {
        throw std::runtime_error("Resource not loaded");
      }

      auto inserted = m_cache.emplace(h, std::move(ptr));

      if (inserted.second) {
        return *inserted.first->second;
      }

      throw std::runtime_error("Resource not inserted in the cache");
    }

  private:
    Loader m_loader;
    std::map<std::size_t, std::unique_ptr<T>> m_cache;
  };


  class GF_API ResourceManager : public AssetManager {
  public:
    ResourceManager();

    ResourceManager(std::initializer_list<Path> paths);


    Image& getImage(const Path& path) {
      std::lock_guard<std::mutex> lock(m_mutex);
      return m_images.getResource(*this, path);
    }

    Texture& getTexture(const Path& path) {
      std::lock_guard<std::mutex> lock(m_mutex);
      return m_textures.getResource(*this, path);
    }

    Font& getFont(const Path& path) {
      std::lock_guard<std::mutex> lock(m_mutex);
      return m_fonts.getResource(*this, path);
    }

  private:
    ResourceCache<Image> m_images;
    ResourceCache<Texture> m_textures;
    ResourceCache<Font> m_fonts;
    std::mutex m_mutex;
  };

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_RESOURCE_MANAGER_H