QGeneralFactory.cc

Go to the documentation of this file.

#include "QGeneralFactory.hh"
#include "QMessage.hh"
#include "QDll.hh"
 
Q_BEGIN_NAMESPACE
 
QGeneralFactory& QGeneralFactory::GetInstance()
{
    static QGeneralFactory factory;
    return factory;
}
 
QGeneralFactory::QGeneralFactory() : QNamed("QGeneralFactory")
{
    fDLLLoader = &QDLLLoader::GetInstance();
    std::string pluginListFile = "plugins.list"; 
    QError err = fDLLLoader->Init(pluginListFile,std::string(Q_PLUGIN_PREFIX_STR));
    if(err!=QERR_SUCCESS) QMessageHandler::Panic(GetName(), std::string(err.ToString()) + " - " + err.GetDescription());
 
    // load external plugins
    pluginListFile = "diana_plugins_external.list";
    err = fDLLLoader->Init(pluginListFile,std::string(Q_PLUGIN_PREFIX_STR));
    if(err!=QERR_SUCCESS) QMessageHandler::Debug(GetName(), std::string(err.ToString()) + " - " + err.GetDescription());
}
 
QGeneralFactory::~QGeneralFactory()
{
    std::map<std::string, QModFactory<QModule>* >::iterator ModulesIter;
    std::map<std::string, QModFactory<QFilter>* >::iterator FiltersIter;
    std::map<std::string, QModFactory<QReader>* >::iterator ReadersIter;
    std::map<std::string, QModFactory<QWriter>* >::iterator WritersIter;
    std::map<std::string, QModFactory<QDriver>* >::iterator DriversIter;
   
   
    for(ModulesIter = fModules.begin(); ModulesIter != fModules.end(); ModulesIter++)
       if(ModulesIter->second) delete ModulesIter->second;
 
    for(FiltersIter = fFilters.begin(); FiltersIter != fFilters.end(); FiltersIter++)
       if(FiltersIter->second) delete FiltersIter->second;
   
    for(ReadersIter = fReaders.begin(); ReadersIter != fReaders.end(); ReadersIter++)
       if(ReadersIter->second) delete ReadersIter->second;
   
    for(WritersIter = fWriters.begin(); WritersIter != fWriters.end(); WritersIter++)
       if(WritersIter->second) delete WritersIter->second;
   
    for(DriversIter = fDrivers.begin(); DriversIter != fDrivers.end(); DriversIter++)
       if(DriversIter->second) delete DriversIter->second;
 
}
 
void QGeneralFactory::LoadPlugin(const std::string& name)
{
    std::string fullName =  name;
    QError err = fDLLLoader->LoadPlugin(fullName);
    if(err!=QERR_SUCCESS) QMessageHandler::Error(GetName(), std::string(err.ToString()) + " - " + err.GetDescription());
}
// QModule
void QGeneralFactory::Register(QModFactory<QModule>* MF)
{
    std::map<std::string, QModFactory<QModule>* >::iterator iter;
    iter = fModules.find(MF->GetName());
    if(iter == fModules.end()) {
        fModules[MF->GetName()] = MF;
        QMessageHandler::Debug(GetName(), std::string("Registered module  : ") + MF->GetName());
    } else {
        QMessageHandler::Debug(GetName(), std::string("Already registered: ") + MF->GetName());
        delete MF;
    }
}
 
QModule* QGeneralFactory::CreateModule(const std::string& name,  QSequence* s)
{
    std::map<std::string, QModFactory<QModule>* >::iterator iter;
    iter = fModules.find(name);
    // if not yet registered, try to register automatically
    if(iter == fModules.end() ){
        LoadPlugin(name);
        iter = fModules.find(name);
    }
    if(iter!=fModules.end() && iter->second != NULL) 
        return iter->second->Create(s);
    return NULL;
}
 
 
// QWriter
void QGeneralFactory::Register(QModFactory<QWriter>* MF)
{
    std::map<std::string, QModFactory<QWriter>* >::iterator iter;
    iter = fWriters.find(MF->GetName());
    if(iter == fWriters.end()) {
        fWriters[MF->GetName()] = MF;
        QMessageHandler::Debug(GetName(), std::string("Registered writer  : ") + MF->GetName());
    } else {
        QMessageHandler::Debug(GetName(), std::string("Already registered: ") + MF->GetName());
        delete MF;
    }
}
 
QWriter* QGeneralFactory::CreateWriter(const std::string& name,  QSequence* s)
{
    std::map<std::string, QModFactory<QWriter>* >::iterator iter;
    iter = fWriters.find(name);
    // if not yet registered, try to register automatically
    if(iter == fWriters.end() ){
        LoadPlugin(name);
        iter = fWriters.find(name);
    }
    if(iter!=fWriters.end() && iter->second != NULL) 
        return iter->second->Create(s);
    return NULL;
}
 
// QReader
void QGeneralFactory::Register(QModFactory<QReader>* MF)
{
    std::map<std::string, QModFactory<QReader>* >::iterator iter;
    iter = fReaders.find(MF->GetName());
    if(iter == fReaders.end()) {
        fReaders[MF->GetName()] = MF;
        QMessageHandler::Debug(GetName(), std::string("Registered reader  : ") + MF->GetName());
    } else {
        QMessageHandler::Debug(GetName(), std::string("Already registered: ") + MF->GetName());
        delete MF;
    }
}
 
QReader* QGeneralFactory::CreateReader(const std::string& name,  QSequence* s)
{
    std::map<std::string, QModFactory<QReader>* >::iterator iter;
    iter = fReaders.find(name);
    // if not yet registered, try to register automatically
    if(iter == fReaders.end() ){
        LoadPlugin(name);
        iter = fReaders.find(name);
    }
    if(iter!=fReaders.end() && iter->second != NULL) 
        return iter->second->Create(s);
    return NULL;
}
 
// QFilter
void QGeneralFactory::Register(QModFactory<QFilter>* MF)
{
    std::map<std::string, QModFactory<QFilter>* >::iterator iter;
    iter = fFilters.find(MF->GetName());
    if(iter == fFilters.end()) {
        fFilters[MF->GetName()] = MF;
        QMessageHandler::Debug(GetName(), std::string("Registered filter  : ") + MF->GetName());
    } else {
        QMessageHandler::Debug(GetName(), std::string("Already registered: ") + MF->GetName());
        delete MF;
    }
}
 
QFilter* QGeneralFactory::CreateFilter(const std::string& name,  QSequence* s)
{
    std::map<std::string, QModFactory<QFilter>* >::iterator iter;
    iter = fFilters.find(name);
    // if not yet registered, try to register automatically
    if(iter == fFilters.end() ){
        LoadPlugin(name);
        iter = fFilters.find(name);
    }
    if(iter!=fFilters.end() && iter->second != NULL) 
        return iter->second->Create(s);
    return NULL;
}
// QDriver
void QGeneralFactory::Register(QModFactory<QDriver>* MF)
{
    std::map<std::string, QModFactory<QDriver>* >::iterator iter;
    iter = fDrivers.find(MF->GetName());
    if(iter == fDrivers.end()) {
        fDrivers[MF->GetName()] = MF;
        QMessageHandler::Debug(GetName(), std::string("Registered driver  : ") + MF->GetName());
    } else {
        QMessageHandler::Debug(GetName(), std::string("Already registered: ") + MF->GetName());
        delete MF;
    }
}
 
QDriver* QGeneralFactory::CreateDriver(const std::string& name,  QSequence* s)
{
    std::map<std::string, QModFactory<QDriver>* >::iterator iter;
    iter = fDrivers.find(name);
    // if not yet registered, try to register automatically
    if(iter == fDrivers.end() ){
        LoadPlugin(name);
        iter = fDrivers.find(name);
    }
    if(iter!=fDrivers.end() && iter->second != NULL) 
        return iter->second->Create(s);
    return NULL;
}
 
Q_END_NAMESPACE