CUGenericLoader.h

//
//  CUGenericLoader.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a templated implementation of the Loader class to load
//  any subclass of asset. Unlike the base loader, this class has a static
//  coordinator behind the scenes to manage resources access scene.  This is
//  similar to the solutions for our other loaders.  Hence we have a consistent
//  loading framework with maximum flexibility.
//
//  Author: Walker White
//  Version: 1/20/16
//
#ifndef __CU_ASSET_LOADER__
#define __CU_ASSET_LOADER__
#include <unordered_set>
#include <mutex>
#include "CULoader.h"
#include "CUAsset.h"
#include "CUThreadPool.h"


NS_CC_BEGIN

#pragma mark -
#pragma mark  Abstract Base Class

class CC_DLL GenericBaseLoader : public Loader<Asset> {
private:
    CC_DISALLOW_COPY_AND_ASSIGN(GenericBaseLoader);
    
protected:
#pragma mark -
#pragma mark Asset Coordinator

    class Coordinator {
    private:
        std::unordered_map<std::string,Asset*> _objects;
        std::unordered_map<std::string, int> _refcnts;
        std::unordered_map<std::string,std::vector<std::function<void(Asset* s)>>> _callbacks;
        
        ThreadPool* _threads;
        std::mutex _mutex;
        
    public:
        size_t instances;
        
        Coordinator();
        
        ~Coordinator();
        
        bool isLoaded(std::string id)  const { return _objects.find(id) != _objects.end(); }
        
        bool isPending(std::string id) const { return _callbacks.find(id) != _callbacks.end(); }
        
        
#pragma mark Allocation Methods

        Asset* load(Asset* asset);
        
        void loadAsync(Asset* asset, std::function<void(Asset* s)> callback);
        
        Asset* allocate(Asset* asset);
        
        void release(Asset* asset);
    };
    
    static Coordinator* _gCoordinator;

    
#pragma mark -
#pragma mark Asset Loader

    std::unordered_set<std::string> _aqueue;
    
    void allocate(std::string key, Asset* asset);
    
    
public:
#pragma mark Activation/Deactivation

    static GenericBaseLoader* create();
    
    void start() override;
    
    void stop() override;
    
    
#pragma mark Loading/Unloading

    size_t waitCount() const override { return _aqueue.size(); }
    
    Asset* load(std::string key, std::string source) override { return nullptr; }

    Asset* load(std::string key, Asset* asset);
    
    void loadAsync(std::string key, std::string source) override {}

    void loadAsync(std::string key, Asset* asset);
    
    void unload(std::string key) override;
    
    void unloadAll() override;
    
    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    GenericBaseLoader() : Loader<Asset>() {}
    
    virtual ~GenericBaseLoader() { if (_active) { stop(); } }
};


#pragma mark -
#pragma mark Asset Loader Template

template <class T>
class GenericLoader : public Loader<T> {
protected:
    GenericBaseLoader* _internal;
    
public:
    static GenericLoader<T>* create() {
        GenericLoader<T> *loader = new (std::nothrow) GenericLoader<T>();
        if (loader) {
            loader->autorelease();
            return loader;
        }
        CC_SAFE_DELETE(loader);
        return nullptr;
    }
    
    void start() override {
        if (_internal->isActive()) {
            return;
        }
        BaseLoader::start();
        _internal->start();
    }
    
    void stop() override {
        if (!_internal->isActive()) {
            return;
        }
        BaseLoader::stop();
        _internal->stop();
    }


#pragma mark Loading/Unloading

    size_t waitCount() const override { return _internal->waitCount(); }
    
    size_t loadCount() const override { return _internal->loadCount(); }
    
    bool contains(std::string key) const override { return _internal->contains(key); }

    T* get(std::string key) const override {
        Asset* asset = _internal->get(key);
        return dynamic_cast<T*>(asset);
    }
    
    T* load(std::string key, std::string source) override {
        T* asset = T::create(source);
        if (asset != nullptr) {
            Asset* result = _internal->load(key,asset);
            return dynamic_cast<T*>(result);
        }
        return nullptr;
    }
    
    void loadAsync(std::string key, std::string source) override {
        T* asset = T::create(source);
        if (asset != nullptr) {
            _internal->loadAsync(key,asset);
        }
    }
    
    void unload(std::string key) override { _internal->unload(key); }
    
    void unloadAll() override { _internal->unloadAll(); }

    
//CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    GenericLoader() : Loader<T>() {
        _internal = GenericBaseLoader::create();
        _internal->retain();
    }
    
    virtual ~GenericLoader() {
        if (_internal->isActive()) { _internal->stop(); }
        _internal->release();
        _internal = nullptr;
    }
};


NS_CC_END

#endif /* defined(__CU_ASSET_LOADER__) */