CULoader.h

//
//  CULoader.h
//  Cornell Extensions to Cocos2D
//
//  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 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 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.
//
//  Author: Walker White
//  Version: 12/10/15
//
#ifndef __CU_LOADER_H__
#define __CU_LOADER_H__

#include <cocos2d.h>
#include <unordered_map>

NS_CC_BEGIN

#pragma mark -
#pragma mark Polymorphic Base

class CC_DLL BaseLoader : public Ref {
protected:
    bool _active;

public:
#pragma mark Activation/Deactivation

    virtual void start() { _active = true; }
    
    virtual void stop() {  _active = false; }
    
    bool isActive() const { return _active; }

    
#pragma mark Loading/Unloading

    virtual void loadAsync(std::string key, std::string source) {}
    
    virtual void unload(std::string key) {}
    
    virtual void unloadAll() {}
    

#pragma mark Progress Monitoring

    virtual size_t loadCount() const { return 0; }

    virtual size_t waitCount() const { return 0; }

    bool isComplete() const { return waitCount() == 0; }

    float progress() const  {
        size_t size = loadCount()+waitCount();
        return (size == 0 ? 0.0f : ((float)loadCount())/size);
    }
    
    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    BaseLoader() : Ref(), _active(false) {}

    virtual ~BaseLoader()   { stop(); }
};


#pragma mark -
#pragma mark Templated Middle Layer

template <class T>
class CC_DLL Loader : public BaseLoader {
protected:
    std::unordered_map<std::string, T*> _assets;

public:
#pragma mark Asset Access

    virtual bool contains(std::string key) const { return _assets.find(key) != _assets.end(); }

    virtual T* get(std::string key) const {
        auto it = _assets.find(key);
        return (it == _assets.end() ? nullptr : it->second);
    }

    T* operator[](std::string key) const { return get(key); }
    

#pragma mark Asset Loading

    virtual size_t loadCount() const override { return _assets.size(); }

    virtual T* load(std::string key, std::string source) { return nullptr; }
    
    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    Loader() : BaseLoader() {}
};

NS_CC_END

#endif /* defined(__CU_LOADER_H__) */