CUSceneManager.h

//
//  CUSceneManager.h
//  Cornell Extensions to Cocos2D
//
//  This class manages a collection of loaders for a single scene.  This allows us to
//  easily load and unload assets that are attached to a single Cocos2D scene.  As
//  Cocos2D is scene oriented, this is a natural way to handle assets.
//
//  Author: Walker White
//  Version: 12/10/15
//
#ifndef __CU_SCENE_MANAGER_H__
#define __CU_SCENE_MANAGER_H__
#include <unordered_map>
#include <cocos2d.h>
#include "CULoader.h"

NS_CC_BEGIN

#pragma mark -
#pragma mark Scene Manager

class CC_DLL SceneManager: public Ref {
private:
    CC_DISALLOW_COPY_AND_ASSIGN(SceneManager);
    
    
protected:
    bool _active;
    
    std::unordered_map<size_t,BaseLoader*> _handlers;
    
public:
#pragma mark Activation/Deactivation

    static SceneManager* create();
    
    void start();
    
    void stop();
    
    bool isActive() const { return _active; }
    

#pragma mark Loader Attachment

    template<typename T>
    bool attach(Loader<T>* loader) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            return false;
        }
        _handlers[hash] = loader;
        loader->retain();
        if (_active && !loader->isActive()) {
            loader->start();
        } else if (!_active && loader->isActive()) {
            loader->stop();
        }
        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->release();
        _handlers.erase(hash);
        return true;
    }
    
    void detachAll() {
        for(auto it = _handlers.begin(); it != _handlers.end(); ++it) {
            it->second->release();
        }
        _handlers.clear();
    }
    
    template<typename T>
    Loader<T>* access() {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it == _handlers.end()) {
            CCASSERT(false, "No loader assigned for given type");
            return nullptr;
        }

        return ((Loader<T>*)it->second);
    }

    
#pragma mark Loading/Unloading

    size_t loadCount() const;
    
    size_t waitCount() const;
    
    bool isComplete() const { return waitCount() == 0; }
    
    float progress() const  {
        size_t size = loadCount()+waitCount();
        return (size == 0 ? 0.0f : ((float)loadCount())/size);
    }
    
    template<typename T>
    T* get(std::string key) const {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it == _handlers.end()) {
            CCASSERT(false, "No loader assigned for given type");
            return nullptr;
        }
        
        return ((Loader<T>*)it->second)->get(key);
    }


    template<typename T>
    T* load(std::string key, std::string source) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            Loader<T>* ref = (Loader<T>*)(it->second);
            return ref->load(key,source);
        }
        
        CCASSERT(false, "No loader assigned for given type");
        return nullptr;
    }
    
    template<typename T>
    void loadAsync(std::string key, std::string source) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            it->second->loadAsync(key,source);
            return;
        }
        
        CCASSERT(false, "No loader assigned for given type");
    }
    
    template<typename T>
    void unload(std::string key) {
        size_t hash = typeid(T).hash_code();
        auto it = _handlers.find(hash);
        if (it != _handlers.end()) {
            it->second->unload(key);
            return;
        }
        
        CCASSERT(false, "No loader assigned for given type");
    }
    
    void unloadAll() {
        for(auto it = _handlers.begin(); it != _handlers.end(); ++it) {
            it->second->unloadAll();
        }
    }
    
    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    SceneManager() : _active(false) {}
    
    ~SceneManager() { if (_active) { stop(); } detachAll(); }
};

NS_CC_END

#endif /* defined(__CU_SCENE_MANAGER_H__) */