|| || || || || || || ||

---

ModuleStore.h

Go to the documentation of this file.

#ifndef MediaTable_ModuleStore_h
#define MediaTable_ModuleStore_h

#include "Module.h"

namespace Impala {
namespace Application {
namespace MediaTable {

class ModuleStore {
public:
    typedef std::map<std::string, Module*>                                      ModuleMapType;
    typedef std::multimap<std::string, ModuleListener*>         ModuleListenersMapType;

    static void Initialize()
    {
        if (sInstance)
        {
            ILOG_WARN("ModuleStore already initialized. Skipping.");
            return;
        }
        sInstance = new ModuleStore();
    }

    static ModuleStore* GetInstance()
    {
        if (!sInstance)
        {
            sInstance = new ModuleStore();
        }
        return sInstance;
    }

    void Register(Module* module) {
        mModules[module->GetType()][module->GetName()] = module;
        // AddExistingListeners
        std::pair<ModuleListenersMapType::iterator,ModuleListenersMapType::iterator> listeners
                        = mListeners.equal_range(module->GetType());
        for (ModuleListenersMapType::iterator it=listeners.first ; it != listeners.second; it++ )
                module->AddModuleListener((*it).second);
    }

    void Unregister(Module* module) {
        mModules[module->GetType()].erase(module->GetName());
    }

    void RegisterListener(ModuleListener* listener) {
        mListeners.insert(std::pair<std::string, ModuleListener*>(listener->GetType(), listener));
        ModuleMapType modules = GetModulesOfType(listener->GetType());
        for (ModuleMapType::iterator it=modules.begin() ; it != modules.end(); it++ )
                (*it).second->AddModuleListener(listener);
    }

    int CountModulesOfType(std::string type)
    {
        return mModules[type].size();
    }

    void Clear() {
        delete sInstance;
        sInstance = new ModuleStore();
    }

    ModuleMapType GetModulesOfType(std::string type) {
        return mModules[type];
    }

private:
    ModuleStore() // constructor: private
    {
        Init();
    }

    ModuleStore(ModuleStore const&){};             // copy constructor: private
    ModuleStore& operator=(ModuleStore const&){};  // assignment operator: private

    void Init()
    {
        ILOG_DEBUG("Initializing ModuleStore");
    }

    typedef std::map<std::string, ModuleMapType>                ModuleMapMapType;

    ModuleMapMapType                    mModules;
    ModuleListenersMapType              mListeners;

    static ModuleStore*         sInstance;

    ILOG_VAR_DEC;
};

ModuleStore* ModuleStore::sInstance = 0;

ILOG_VAR_INIT(ModuleStore, Application.MediaTable);

} // namespace MediaTable
} // namespace Application
} // namespace Impala
#endif // ModuleStore_h

---