CUAssetManager.h

//
//  CUAssetManager.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a class to support asset management. Assets should
//  always be managed by a central loader.  The loader ensures that the assets
//  are in memory at all times (even when not in use) and that there is a simple
//  way to refer to them using user-defined keys.
//
//  While most game engines implement asset managers as singletons, we have
//  elected not to do that.  This way you can use a different managers for
//  different player modes.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//
//  CUGL zlib 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/16
//
#ifndef __CU_ASSET_MANAGER_H__
#define __CU_ASSET_MANAGER_H__
#include <cugl/util/CUThreadPool.h>
#include <cugl/util/CUDebug.h>
#include <cugl/assets/CULoader.h>
#include <typeinfo>


namespace cugl {
    
class AssetManager {
private:
    CU_DISALLOW_COPY_AND_ASSIGN(AssetManager);
    
protected:
    std::unordered_map<size_t,std::shared_ptr<BaseLoader>> _handlers;
    std::shared_ptr<ThreadPool> _workers;

    bool _preload;

    bool readCategory(size_t hash, const std::shared_ptr<JsonValue>& json);
    
    void readCategory(size_t hash, const std::shared_ptr<JsonValue>& json,
                      LoaderCallback callback);
    
#pragma mark -
#pragma mark Constructors
public:
    AssetManager() : _preload(false) {}
    
    ~AssetManager() { dispose(); }
    
    void dispose();

    bool init() {
        return init(2);
    }

    bool init(unsigned int threads);
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<AssetManager> alloc() {
        std::shared_ptr<AssetManager> result = std::make_shared<AssetManager>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<AssetManager> alloc(unsigned int threads) {
        std::shared_ptr<AssetManager> result = std::make_shared<AssetManager>();
        return (result->init(threads) ? result : nullptr);
    }

#pragma mark -
#pragma mark Loader Management

    template<typename T>
    bool attach(const std::shared_ptr<BaseLoader>& loader) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            return false;
        }
        
        loader->setThreadPool(_workers);
        _handlers[hash] = loader;
        return true;
    }
    
    template<typename T>
    bool isAttached() {
        size_t hash = typeid(T).hash_code();
        return _handlers.find(hash) != _handlers.end();
    }
    
    template<typename T>
    bool detach() {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it == _handlers.end()) {
            return false;
        }
        it->second->setThreadPool(nullptr);
        it->second = nullptr;
        _handlers.erase(hash);
        return true;
    }
    
    void detachAll() {
        for(auto it = _handlers.begin(); it != _handlers.end(); ++it) {
            it->second = nullptr;
        }
        _handlers.clear();
    }
    
    template<typename T>
    std::shared_ptr<Loader<T>> access() {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it == _handlers.end()) {
            CUAssertLog(false, "No loader assigned for given type");
            return nullptr;
        }
        
        return std::dynamic_pointer_cast<Loader<T>>(it->second);
    }
    
#pragma mark -
#pragma mark Progress Monitoring

    size_t loadCount() const;
    
    size_t waitCount() const;
    
    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 Loading/Unloading

    template<typename T>
    std::shared_ptr<T> get(const std::string& key) const {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it == _handlers.end()) {
            CUAssertLog(false, "No loader assigned for given type");
            return nullptr;
        }
        
        std::shared_ptr<Loader<T>> loader = std::dynamic_pointer_cast<Loader<T>>(it->second);
        return loader->get(key);
    }
    
    template<typename T>
    std::shared_ptr<T> get(const char* key) const {
        return get<T>(std::string(key));
    }
    
    template<typename T>
    bool load(const std::string& key, const std::string& source) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            std::shared_ptr<Loader<T>> loader = std::dynamic_pointer_cast<Loader<T>>(it->second);
            return loader->load(key,source);
        }
        
        CUAssertLog(false, "No loader assigned for given type");
        return nullptr;
    }

    template<typename T>
    bool load(const char* key, const std::string& source) {
        return load<T>(std::string(key),source);
    }

    template<typename T>
    bool load(const std::string& key, const char* source) {
        return load<T>(key,std::string(source));
    }

    template<typename T>
    bool load(const char* key, const char* source) {
        return load<T>(std::string(key),std::string(source));
    }
    
    template<typename T>
    void loadAsync(const std::string& key, const std::string& source, LoaderCallback callback) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            it->second->loadAsync(key,source,callback);
            return;
        }
        
        CUAssertLog(false, "No loader assigned for given type");
    }

    template<typename T>
    void loadAsync(const char* key, const std::string& source, LoaderCallback callback) {
        loadAsync<T>(std::string(key),source,callback);
    }

    template<typename T>
    void loadAsync(const std::string& key, const char* source, LoaderCallback callback) {
        loadAsync<T>(key,std::string(source),callback);
    }

    template<typename T>
    void loadAsync(const char* key, const char* source, LoaderCallback callback) {
        loadAsync<T>(std::string(key),std::string(source),callback);
    }
    
    template<typename T>
    void unload(const std::string& key) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            it->second->unload(key);
            return;
        }
        
        CUAssertLog(false, "No loader assigned for given type");
    }
    
    template<typename T>
    void unload(const char* key) {
        unload<T>(std::string(key));
    }
    
    void unloadAll() {
        for(auto it = _handlers.begin(); it != _handlers.end(); ++it) {
            it->second->unloadAll();
        }
    }
    
#pragma mark -
#pragma mark Directory Support

    bool loadDirectory(const std::shared_ptr<JsonValue>& json);

    bool loadDirectory(const std::string& directory);

    bool loadDirectory(const char* directory) {
        return loadDirectory(std::string(directory));
    }
   
    void loadDirectoryAsync(const std::shared_ptr<JsonValue>& json, LoaderCallback callback);

    void loadDirectoryAsync(const std::string& directory, LoaderCallback callback);
    
    void loadDirectoryAsync(const char* directory, LoaderCallback callback) {
        loadDirectoryAsync(std::string(directory),callback);
    }
    
};

}

#endif /* __CU_ASSET_MANAGER_H__ */