IAPDemo/Libraries/redream/CCNodeLoaderLibrary.cpp

#include "CCNodeLoaderLibrary.h"

#include "CCBlockTouchLayerLoader.h"
#include "CCLayerLoader.h"
#include "CCLayerColorLoader.h"
#include "CCLayerGradientLoader.h"
#include "CCLabelBMFontLoader.h"
#include "CCLabelTTFLoader.h"
#include "CCSpriteLoader.h"
#include "CCScale9SpriteLoader.h"
#include "REDFileLoader.h"
#include "CCMenuLoader.h"
#include "CCMenuItemLoader.h"
#include "CCMenuItemImageLoader.h"
#include "CCControlButtonLoader.h"
#include "CCParticleSystemQuadLoader.h"
#include "CCScrollViewLoader.h"
#include "CCSkeletonAnimationLoader.h"
#include "ZGFrameActionSpriteLoader.h"
#include "ZMLCCParticleSystemQuadLoader.h"
#include "RParticleSystemLoader.h"
#include "REDNodeButtonLoader.h"
#include "CCProgressTimerLoader.h"
#include "UICheckBoxLoader.h"
#include "UISliderLoader.h"
#include "UIEditBoxLoader.h"
#include "CCTableViewLoader.h"
#include "TiledPolygonSpriteLoader.h"
#include "RedBakeNodeLoader.h"
#include "REDPolygonClippingNodeLoader.hpp"

using namespace cocos2d;

namespace redream {

NodeLoaderLibrary::NodeLoaderLibrary() {

}

NodeLoaderLibrary::~NodeLoaderLibrary() {
    this->purge(true);
}

void NodeLoaderLibrary::registerDefaultNodeLoaders() {
    this->registerNodeLoader("CCNode", NodeLoader::loader());
    this->registerNodeLoader("CCLayer", LayerLoader::loader());
    this->registerNodeLoader("CCLayerColor", LayerColorLoader::loader());
    this->registerNodeLoader("CCLayerGradient", LayerGradientLoader::loader());
    this->registerNodeLoader("CCSprite", SpriteLoader::loader());
    this->registerNodeLoader("CCLabelBMFont", LabelBMFontLoader::loader());
    this->registerNodeLoader("CCLabelTTF", LabelTTFLoader::loader());
    this->registerNodeLoader("CCScale9Sprite", Scale9SpriteLoader::loader());
    this->registerNodeLoader("CCScrollView", ScrollViewLoader::loader());
    this->registerNodeLoader("REDFile", REDFileLoader::loader());
    this->registerNodeLoader("CCMenu", MenuLoader::loader());
    this->registerNodeLoader("CCMenuItemImage", MenuItemImageLoader::loader());
    this->registerNodeLoader("CCControlButton", ControlButtonLoader::loader());
    this->registerNodeLoader("CCParticleSystemQuad", ParticleSystemQuadLoader::loader());
    this->registerNodeLoader("SkeletonAnimation", SkeletonAnimationLoader::loader());
    this->registerNodeLoader("ZGFrameActionSprite", ZGFrameActionSpriteLoader::loader());
    this->registerNodeLoader("ZMLParticleSystem", ZMLCCParticleSystemQuadLoader::loader());
    this->registerNodeLoader("RParticleSystem", RParticleSystemLoader::loader());
    this->registerNodeLoader("REDNodeButton", REDNodeButtonLoader::loader());
    this->registerNodeLoader("CCProgressTimer", ProgressTimerLoader::loader());
    this->registerNodeLoader("UICheckBox", CheckBoxLoader::loader());
    this->registerNodeLoader("UISlider", SliderLoader::loader());
    this->registerNodeLoader("UIEditBox", EditBoxLoader::loader());
    this->registerNodeLoader("CCTableView", TableViewLoader::loader());
    this->registerNodeLoader("CCBlockTouchLayer", BlockTouchLayerLoader::loader());
    this->registerNodeLoader("TiledPolygonSprite", TiledPolygonSpriteLoader::loader());
    this->registerNodeLoader("RedBakeNode", RedBakeNodeLoader::loader());
    this->registerNodeLoader("REDPolygonClippingNode", PolygonClippingNodeLoader::loader());
}

void NodeLoaderLibrary::registerNodeLoader(const char * pClassName, NodeLoader * pNodeLoader) {
    pNodeLoader->retain();
    auto ret= this->_nodeLoaders.insert(NodeLoaderMapEntry(pClassName, pNodeLoader));
    if (ret.second == false) {
       pNodeLoader->autorelease();
    }
}

void NodeLoaderLibrary::unregisterNodeLoader(const char * pClassName) {
    NodeLoaderMap::iterator ccNodeLoadersIterator = this->_nodeLoaders.find(pClassName);
    if (ccNodeLoadersIterator != this->_nodeLoaders.end())
    {
        ccNodeLoadersIterator->second->release();
        _nodeLoaders.erase(ccNodeLoadersIterator);
    }
    else
    {
        CCLOG("The loader (%s) doesn't exist", pClassName);
    }
}

NodeLoader * NodeLoaderLibrary::getNodeLoader(const char* pClassName) {
    NodeLoaderMap::iterator ccNodeLoadersIterator = this->_nodeLoaders.find(pClassName);
//    assert(ccNodeLoadersIterator != this->_nodeLoaders.end());
    if(ccNodeLoadersIterator != _nodeLoaders.end()){
        return ccNodeLoadersIterator->second;
    } else {
        return nullptr;
    }
}

void NodeLoaderLibrary::purge(bool pReleaseNodeLoaders) {
    if(pReleaseNodeLoaders) {
        for(auto& it : this->_nodeLoaders) {
            it.second->release();
        }
    }
    this->_nodeLoaders.clear();
}



static NodeLoaderLibrary * sSharedNodeLoaderLibrary = nullptr;

NodeLoaderLibrary * NodeLoaderLibrary::getInstance() {
    if(sSharedNodeLoaderLibrary == nullptr) {
        sSharedNodeLoaderLibrary = new (std::nothrow) NodeLoaderLibrary();

        sSharedNodeLoaderLibrary->registerDefaultNodeLoaders();
    }
    return sSharedNodeLoaderLibrary;
}

void NodeLoaderLibrary::destroyInstance() {
    CC_SAFE_DELETE(sSharedNodeLoaderLibrary);
}

NodeLoaderLibrary * NodeLoaderLibrary::newDefaultNodeLoaderLibrary() {
    NodeLoaderLibrary * ccNodeLoaderLibrary = NodeLoaderLibrary::library();
    
    ccNodeLoaderLibrary->registerDefaultNodeLoaders();

    return ccNodeLoaderLibrary;
}

}