CULoader.h

//
//  CULoader.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the base templates for loader classes.  Our goal with
//  this module is to create a modular loader system that is as close as possible
//  to Nathan Sweet's flexible and modular AssetManager for libGDX.  To do this
//  in C++ requires three layers:
//
//  The first layer is a polymorphic base that is used by the AssetManager for
//  adding and removing loaders. It is the C++ equivalent of a Java interface.
//
//  The second layer is a template that provides type correctness when accessing
//  components in the AssetManager.  It has generic functionality that is
//  necessary for all loaders, but is missing the information needed to load
//  the specific asset.
//
//  The top layer is a specific class for each asset that implements the specific
//  loading functionality.
//
//  This module implements the first two layers.  As they are both a template
//  and a pure polymorphic class, only a header file is necessary.  There is no
//  associated CPP file with this header.
//
//
//  CUGL MIT License:
//      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.
//
//  Author: Walker White
//  Version: 1/7/18
//
#ifndef __CU_LOADER_H__
#define __CU_LOADER_H__
#include <string>
#include <functional>
#include <unordered_map>
#include <unordered_set>
#include <cugl/assets/CUJsonValue.h>
#include <cugl/util/CUThreadPool.h>
 
namespace cugl {
 
class AssetManager;
 
typedef std::function<void(const std::string& key, bool success)> LoaderCallback;
 
#pragma mark -
#pragma mark Polymorphic Base
 
class BaseLoader : public std::enable_shared_from_this<BaseLoader> {
protected:
    std::shared_ptr<ThreadPool> _loader;
    
    AssetManager* _manager;
    
    virtual bool read(const std::string& key, const std::string& source,
                      LoaderCallback callback, bool async) {
        return false;
    }
 
    virtual bool read(const std::shared_ptr<JsonValue>& json,
                      LoaderCallback callback, bool async) {
        return false;
    }
    
    virtual bool purge(const std::string& key) {
        return false;
    }
    
    virtual bool purge(const std::shared_ptr<JsonValue>& json) {
        return purge(json->key());
    }
    
    virtual bool verify(const std::string& key) const { return false; }
   
    
public:
#pragma mark Constructors
 
    BaseLoader()    {}
    
    ~BaseLoader()   { dispose(); }
    
    virtual void dispose() { _manager = nullptr; }
    
    virtual bool init() {
        return init(nullptr);
    }
    
    virtual bool init(const std::shared_ptr<ThreadPool>& threads) {
        _loader=threads;
        return true;
    }
    
    
#pragma mark AssetManager Support
 
    std::shared_ptr<BaseLoader> getHook() {
        return shared_from_this();
    }
    
    std::shared_ptr<ThreadPool> getThreadPool() const { return _loader; }
    
    void setThreadPool(const std::shared_ptr<ThreadPool>& threads) {
        _loader = threads;
    }
    
    void setManager(AssetManager* manager) {
        _manager = manager;
    }
    
    const AssetManager* getManager() const {
        return _manager;
    }
    
 
#pragma mark Loading/Unloading
 
    bool load(const std::string& key, const std::string& source) {
        return read(key,source,nullptr,false);
    }
 
    bool load(const char* key, const std::string& source) {
        return read(std::string(key),source,nullptr,false);
    }
 
    bool load(const std::string& key, const char* source) {
        return read(key,std::string(source),nullptr,false);
    }
    
    bool load(const char* key, const char* source) {
        return read(std::string(key),std::string(source),nullptr,false);
    }
 
    bool load(const std::shared_ptr<JsonValue>& json) {
        return read(json,nullptr,false);
    }
    
    void loadAsync(const std::string& key, const std::string& source, LoaderCallback callback) {
        read(key, source, callback,true);
    }
 
    void loadAsync(const char* key, const std::string& source, LoaderCallback callback) {
        read(std::string(key), source, callback,true);
    }
 
    void loadAsync(const std::string& key, const char* source, LoaderCallback callback) {
        read(key, std::string(source), callback,true);
    }
 
    void loadAsync(const char* key, const char* source, LoaderCallback callback) {
        read(std::string(key), std::string(source), callback,true);
    }
 
    void loadAsync(const std::shared_ptr<JsonValue>& json, LoaderCallback callback) {
        read(json, callback,true);
    }
 
    bool unload(const std::string& key) {
        return purge(key);
    }
 
    bool unload(const char* key) {
        return purge(key);
    }
    
    bool unload(const std::shared_ptr<JsonValue>& json) {
        return purge(json);
    }
    
    virtual void unloadAll() {}
    
 
#pragma mark Progress Monitoring
 
    bool contains(const std::string& key) const {
        return verify(key);
    }
 
    bool contains(const char* key) const {
        return verify(std::string(key));
 
    }
 
    virtual size_t loadCount() const { return 0; }
    
    virtual size_t waitCount() const { return 0; }
    
    bool complete() const { return waitCount() == 0; }
    
    float progress() const  {
        size_t size = loadCount()+waitCount();
        return (size == 0 ? 0.0f : ((float)loadCount())/size);
    }
    
};
 
 
#pragma mark -
#pragma mark Templated Middle Layer
 
template <class T>
class Loader : public BaseLoader {
protected:
    std::unordered_map<std::string, std::shared_ptr<T>> _assets;
    
    std::unordered_set<std::string> _queue;
 
    bool purge(const std::string& key) override {
        auto it = _assets.find(key);
        if (it != _assets.end()) {
            _assets.erase(it);
            return true;
        }
        return false;
    }
    
    bool verify(const std::string& key) const override {
        return _assets.find(key) != _assets.end();
    }
    
public:
#pragma mark Constructors
 
    Loader(): BaseLoader() {}
 
    
#pragma mark Asset Access
 
    std::shared_ptr<T> get(const std::string& key) const {
        auto it = _assets.find(key);
        return (it == _assets.end() ? nullptr : it->second);
    }
 
    std::shared_ptr<T> get(const char* key) const {
        auto it = _assets.find(std::string(key));
        return (it == _assets.end() ? nullptr : it->second);
    }
    
    std::shared_ptr<T> operator[](const std::string& key) const { return get(key); }
 
    std::shared_ptr<T> operator[](const char* key) const { return get(key); }
    
 
#pragma mark Asset Loading
 
    size_t loadCount() const override { return _assets.size(); }
    
    size_t waitCount() const override { return _queue.size(); }
 
    void unloadAll() override {
        _assets.clear();
    }
};
 
}
 
 
#endif /* __CU_LOADER_H__ */