QModuleFactory.cc

Go to the documentation of this file.

#include "QOptions.hh"
#include "QMessage.hh"
#include "QModuleFactory.hh"
#include "QStringHandler.hh"
#include "QGeneralFactory.hh"
#include "QGlobalRWFactory.hh"
#include "QWriter.hh"
#include "QReader.hh"
#include "QFilter.hh"
#include "QDriver.hh"
#include "QModule.hh"
 
 
#include <stdexcept>
#include <iostream>
#include <fstream>
 
using namespace QStringHandler;
 
Q_BEGIN_NAMESPACE
 
QModuleFactory *QModuleFactory::me = 0;
 
// singleton 
    QModuleFactory *QModuleFactory::Get() {
        if (!me)
            me = new QModuleFactory();
        return me;
    }
 
// dtor
QModuleFactory::~QModuleFactory() {
}
 
 
// private ctor; it does nothing
QModuleFactory::QModuleFactory() :  QNamed("QModuleFactory"), init_done(false){
}
 
QSequence* QModuleFactory::FindSequence(const std::string& s)
{
    std::list<QSequence*>::iterator it;
    for(it = sequences.begin(); it != sequences.end(); it++) 
        if((*it)->GetName() == s) return *it;
    return NULL;
}
 
void QModuleFactory::LoadLoadable(const std::string& n)
{
    QGlobalRWFactory::GetInstance().LoadPlugin(std::string("L") + n);
}
 
// function that creates readers
QReader* QModuleFactory::CreateReader(const std::string& n, QSequence *s)
{ 
 
    // dynamic loader
    QReader* reader = QGeneralFactory::GetInstance().CreateReader(std::string("M") + n,s); 
    if(reader) return reader;
    else QMessageHandler::Panic(GetName(),std::string("UNKNOWN reader: ") + n);
    return NULL;
}
 
QFilter* QModuleFactory::CreateFilter(const std::string& n, QSequence *s)
{
    // dynamic loader
    QFilter* filter = QGeneralFactory::GetInstance().CreateFilter(std::string("M") + n,s); 
    if(filter) return filter;
    else QMessageHandler::Panic(GetName(),std::string("UNKNOWN filter: ")+ n);
    return NULL;
}
 
QDriver* QModuleFactory::CreateDriver(const std::string& n, QSequence *s)
{
    // dynamic loader
    QDriver* driver = QGeneralFactory::GetInstance().CreateDriver(std::string("M") + n,s); 
    if(driver) return driver;
    else QMessageHandler::Panic(GetName(),std::string("UNKNOWN driver: ")+ n);
    return NULL;
}
 
// function that creates writers
QWriter* QModuleFactory::CreateWriter(const std::string& n, QSequence *s)
{ 
    // dynamic loader
    QWriter* writer = QGeneralFactory::GetInstance().CreateWriter(std::string("M") + n,s); 
    if(writer) return writer;
    else QMessageHandler::Panic(GetName(),std::string("UNKNOWN writer: ") + n);
    return NULL;
}
 
 
// function that creates real modules
QModule* QModuleFactory::CreateModule(const std::string& n, QSequence *s) 
{
    // dynamic loader
    QModule* module = QGeneralFactory::GetInstance().CreateModule(std::string("M") + n,s); 
    if(module) return module;
    else QMessageHandler::Panic(GetName(),std::string("UNKNOWN module: ")+ n);
    return NULL;
}
 
// initialization of factory and load modules
void QModuleFactory::Init() {
    if ( init_done ){
        return;
    }
 
 
    std::string fname;
    std::string line;
           size_t lineCounter = 0;
 
   std::map<std::string,std::string> userConfigFile;
   try {
       fname = QOptions::GetInstance().GetString("General.UserConfigFile");
   } catch(...){
   }
   if(!fname.empty()) {
          std::ifstream in2(fname.c_str());
 
           if (!in2.good()) {
               QMessageHandler::Get()->Send(PanicMsg,"QModuleFactory","User config file \"" + fname +"\" not found. .");
           } 
           try {
           lineCounter = 0;
               
               while(getline(in2,line)) {
               lineCounter++;
               size_t pos;
               std::string s="";
 
               // erase comments
               pos=line.find('#');
               if ( pos != std::string::npos ) 
                   line.erase(pos);
 
               // swallow spaces at the beginning of the line
               line = SwallowSpaces(line);
               line = RSwallowSpaces(line);
 
               // skip blank lines
               if ( line.empty() ) 
                   continue;
 
               pos = line.find('=');
               if ( pos != std::string::npos ) {
                   std::string key = line.substr(0,line.find('='));
                   key = SwallowSpaces(key);
                   key = RSwallowSpaces(key);
                   std::string value = line.substr(line.find('=')+1,std::string::npos);
                   value = SwallowSpaces(value);
                   value = RSwallowSpaces(value);
                   userConfigFile[key] = ReplaceCFGVar(value);
               }  else {
                   char cfgerr[128];
                   snprintf(cfgerr,128,"Syntax error in cfg file, line  %u: \"%s\"",(unsigned int)lineCounter,line.c_str());
                   throw std::runtime_error(cfgerr);
               }
 
           }
       } 
 
       catch(std::exception& ex) {
           char buf[512];
           snprintf(buf,512,"Syntax error in pfg file: %s",ex.what());
           QMessageHandler::Panic(GetName(),buf);
       }
       catch(...) { QMessageHandler::Panic(GetName(),"Syntax error in pfg file"); }
   }
   fname = "";
   fname = QOptions::GetInstance().GetString("General.MainConfigFile");
   std::ifstream in(fname.c_str());
   if (!in) {
       throw std::runtime_error("Cannot find configuration file: " + fname );
   }
   
   // read in file to a string vector instead of dynamically, so it can be modified,
   // and save line number with each line
   std::vector<std::pair<std::string, int> > cfgFileLines;
   int lineno = 1;
   while(getline(in,line)) {
       cfgFileLines.push_back(std::make_pair(line, lineno));
       lineno++;
   };
 
   std::string frameworkSection = "";
   std::string current_loader = "";
   std::string current_var = "";
   std::string current_module="";
   std::string current_sequence="";
   std::string current_group="";
   std::vector<std::pair<std::string, std::string> > current_group_options;
   std::vector<std::string> alias_files;
   QBaseModule *p_Module=NULL;
   QSequence *p_Sequence=NULL;
 
   // keep evaluating cfgFileLines.size(), since the number of lines can change
   for(size_t lineCounter = 0; lineCounter < cfgFileLines.size(); lineCounter++) {
       std::string line = cfgFileLines[lineCounter].first;
       int fileLineNum = cfgFileLines[lineCounter].second;
       size_t pos;
       std::string s="";
 
       // erase comments
       pos=line.find('#');
       if ( pos != std::string::npos ) 
           line.erase(pos);
 
       // swallow spaces at the beginning of the line
       line = SwallowSpaces(line);
       line = RSwallowSpaces(line);
 
       // skip blank lines
       if ( line.empty() ) 
           continue;
       // search for the "framework" section
       if(frameworkSection == "") {
           if (current_loader != "") {
               char cfgerr[128];
               snprintf(cfgerr,128,"Syntax error in cfg file, line %u: \"%s\"",(unsigned int)fileLineNum,line.c_str());
               throw std::runtime_error(cfgerr);
           }
           s = line;
           if( s == "framework") { 
               frameworkSection = "framework"; 
               goto end_while;
           } else {
               //      throw std::runtime_error("Syntax error in configuration file: 1");
           }
       }  else if (current_loader == "" || current_var == "") {
           if(line == "endfw") {
               current_loader = ".";
               current_var = ".";
               goto end_while;
           }
           s = line.substr(0,line.find(' '));
           if ( s == "load" ) {
               current_loader = line.substr(line.find(' ')+1,std::string::npos);
               LoadLoadable(current_loader);
               current_loader = "";
               goto end_while;
           }
           else if ( s == "cfgvar" ) {
               std::string key = line.substr(line.find(' '),std::string::npos);
               key = key.substr(0,key.find('='));
               key = SwallowSpaces(key);
               key = RSwallowSpaces(key);
               std::string value = line.substr(line.find('=')+1,std::string::npos);
               value = SwallowSpaces(value);
               value = RSwallowSpaces(value);
               QMessageHandler::Get()->Send(DebugMsg,"QModuleFactory","Defined variable \"" + key +"\" value \""+value+"\"");
               std::string fullname = std::string("CFGVar.")+key;
 
               try {
                   QOptions::GetInstance().GetParameter(fullname);
               }
               catch(...) {
                   QOptions::GetInstance().SetParameter(fullname,value);
               }
 
               current_var = "";
               goto end_while;
           } else if ( s == "groupfile" ) {
               std::string file_name = line.substr(line.find(' ')+1,std::string::npos);
               alias_files.push_back(ReplaceCFGVar(file_name));
               QMessageHandler::Get()->Send(DebugMsg,"QModuleFactory","Using group file \"" + file_name +"\"");
               goto end_while;
           } else {
               char cfgerr[128];
               snprintf(cfgerr,128,"Syntax error in cfg file, line %u: \"%s\"",(unsigned int)fileLineNum,line.c_str());
               QMessageHandler::Get()->Send(PanicMsg,"QModuleFactory",cfgerr);
           }
       }
       //search for the "sequence" section 
       if ( current_sequence == "") {
 
           if (current_module != "") {
               char cfgerr[128];
               snprintf(cfgerr,128,"Syntax error in cfg file, line  %u: \"%s\"",(unsigned int)fileLineNum,line.c_str());
               throw std::runtime_error(cfgerr);
           }
 
           s = line.substr(0,line.find(' '));
           if ( s == "sequence" ) {
               current_sequence = line.substr(line.find(' ') + 1, std::string::npos);
 
               // check that sequence does not exist yet
               if ( FindSequence(current_sequence) != NULL ) {
                   throw std::runtime_error("Sequence: "+current_sequence+" already exist!");
               } 
               else {
                   if (!p_Sequence) {
                       p_Sequence = new QSequence(current_sequence);
                       p_Sequence->fConfig.fFilename = fname;
                       size_t slashpos = p_Sequence->fConfig.fFilename.find_last_of('/');
                       if(slashpos != std::string::npos) p_Sequence->fConfig.fFilename = p_Sequence->fConfig.fFilename.substr(slashpos+1,std::string::npos);
                       std::string driver = QOptions::GetInstance().GetString("General.Driver");
                       if(!driver.empty()) {
 
                           QMessageHandler::Get()->Send(InfoMsg,"QModuleFactory","Adding driver \"" + driver +"\"");
                           p_Sequence->p_Driver = CreateDriver(driver, p_Sequence);
                           QOptions::GetInstance().SetParameter(current_sequence,driver,p_Sequence->p_Driver->GetOccurrence(),"enable", true);
 
                       }
                   } else {
                       char cfgerr[128];
                       snprintf(cfgerr,128,"Syntax error in cfg file, line  %u: \"%s\"",(unsigned int)fileLineNum,line.c_str());
                       throw std::runtime_error(cfgerr);
                   }
                   sequences.push_back(p_Sequence);
                   goto end_while;
               }
 
           } else {
               char cfgerr[128];
               snprintf(cfgerr,128,"Syntax error in cfg file, line  %u: \"%s\"",(unsigned int)fileLineNum,line.c_str());
               throw std::runtime_error(cfgerr);
           }
       } 
       else {
           if (current_module == "") {
               if (line=="endseq") {
                   current_sequence="";
                   p_Sequence = 0;
                   goto end_while;
               }
 
               s = line.substr(0,line.find(' '));
               if ( s == "module" ) {
                   current_module = line.substr(line.find(' ')+1,std::string::npos);
                   p_Sequence->modules.push_back(CreateModule(current_module, p_Sequence));
                   p_Module = p_Sequence->modules.back();
                   goto end_while;
               }
               if ( s == "reader" ) {
                   current_module = line.substr(line.find(' ')+1,std::string::npos);
                   p_Sequence->p_Reader = CreateReader(current_module, p_Sequence);
                   p_Module = p_Sequence->p_Reader;
                   goto end_while;
               }
               if ( s == "writer" ) {
                   current_module = line.substr(line.find(' ')+1,std::string::npos);
                   p_Sequence->p_Writer = CreateWriter(current_module, p_Sequence);
                   p_Module = p_Sequence->p_Writer;
                   goto end_while;
               }
               if ( s == "filter" ) {
                   current_module = line.substr(line.find(' ')+1,std::string::npos);
                   p_Sequence->modules.push_back(CreateFilter(current_module, p_Sequence));
                   p_Module = p_Sequence->modules.back();
                   goto end_while;
               }
               if ( s == "includegroup" ) {
                   current_module = "includegroup";
                   current_group = line.substr(line.find(' ')+1,std::string::npos);
                   goto end_while;
               }
               if ( s == "driver" ) {
                   current_module = line.substr(line.find(' ')+1,std::string::npos);
                   p_Sequence->p_Driver = CreateDriver(current_module, p_Sequence);
                   p_Module = p_Sequence->p_Driver;
                   goto end_while;
               }
           }
           else {
               pos = line.find('=');
               if ( pos != std::string::npos ) {
                   std::string key = line.substr(0,line.find('='));
                   key = SwallowSpaces(key);
                   key = RSwallowSpaces(key);
                   std::string value = line.substr(line.find('=')+1,std::string::npos);
                   value = SwallowSpaces(value);
                   value = RSwallowSpaces(value);
                   
                   if (current_module == "includegroup") {
                       current_group_options.push_back(make_pair(key, value));
                   } else {
                       // replace vars for module
                       try {
                           std::cout.flush();
                           value = ReplaceCFGVar(value);
                           QOptions::GetInstance().SetParameter(current_sequence,current_module,p_Module->GetOccurrence(),key, value);
                       } 
                       catch(QError& err) {
 
                           char obuf[128];
                           snprintf(obuf,128,"%u",(unsigned int)p_Module->GetOccurrence());
                           std::string upk = current_sequence+"."+current_module+"."+obuf+"."+key;
                           // if not overwritten by user raise exception
                           if(userConfigFile.find(upk) == userConfigFile.end()) {
                               char buf[256];
                               snprintf(buf,256,"Syntax error in cfg file, line %u: %s",(unsigned int)fileLineNum,err.GetDescription().c_str());
                               QMessageHandler::Panic(GetName(),buf);
                           }
                       }
                       catch(std::exception& ex) {
                           char obuf[128];
                           snprintf(obuf,128,"%u",(unsigned int)p_Module->GetOccurrence());
                           std::string upk = current_sequence+"."+current_module+"."+obuf+"."+key;
                           // if not overwritten by user raise exception
                           if(userConfigFile.find(upk) == userConfigFile.end()) {
                               char buf[512];
                               snprintf(buf,512,"Syntax error in cfg file, line %u: %s",(unsigned int)fileLineNum,ex.what());
                               QMessageHandler::Panic(GetName(),buf);
                           }
                       }
                   }
 
                   goto end_while;
               }
               else {
                   if ( line == "endmod") {
                       // if this "module" was a group alias, substitute in the cfg lines now
                       if (current_module == "includegroup") {
                           AddAliasGroup(cfgFileLines, lineCounter, alias_files, current_group, current_group_options);
                       }
                       current_module = "";
                       p_Module = 0;
                       goto end_while;
                   } else {
                       char cfgerr[128];
                       snprintf(cfgerr,128,"Syntax error in cfg file, line  %u: \"%s\"",(unsigned int)fileLineNum,line.c_str());
                       throw std::runtime_error(cfgerr);
                   }
               }
           }
       }
       // label 
end_while:
       ;
 
   }
   QOptions::GetInstance().SetFirstSequence(sequences.front()->GetName());
   QOptions::GetInstance().SetLastSequence(sequences.back()->GetName());
 
   // read user file to override parameters
   std::map<std::string,std::string>::const_iterator up = userConfigFile.begin();
   while(up != userConfigFile.end()) {
       QOptions::GetInstance().SetParameter(up->first,QVdt(up->second));
       up++;
   }
   // last step: override parameters with command line options
   QOptions::GetInstance().ReplaceUserParams();
 
   std::stringstream msg;
   Dump(msg);
   QMessageHandler::Get()->Send(DebugMsg,"QModuleFactory",msg.str());
 
 
   QOptions::GetInstance().Dump(QMessageHandler::Get()->GetLogFile());
   // config done
   init_done = true;
}
 
// dump list of sequences and modules
void QModuleFactory::Dump(std::ostream& o) {
    std::list<QSequence* >::iterator it;
    for( it = sequences.begin(); it != sequences.end(); it++) {
        (*it)->Dump( o );
        o << std::endl;
    }
}
 
std::string QModuleFactory::ReplaceCFGVar(const std::string& value)
{
    std::string retstring = value;
    size_t rightbr = std::string::npos;
    do {
        size_t leftbr = retstring.find("${");
        rightbr = std::string::npos;
        if(leftbr != std::string::npos) {
            rightbr = retstring.find_first_of("}");
        }
        if(rightbr != std::string::npos) {
            std::string varname = retstring.substr(leftbr+2,rightbr-leftbr-2);
            std::string fullname = "CFGVar.";
            fullname += varname;
            std::string varval = QOptions::GetInstance().GetParameter(fullname).GetString();
            retstring.replace(leftbr,rightbr-leftbr+1,varval);
        }
    } while(rightbr != std::string::npos);
    return retstring;
}
 
void QModuleFactory::AddAliasGroup(
        std::vector<std::pair<std::string, int> >& cfgFileLines, int location,
        const std::vector<std::string>& alias_files, const std::string& group,
        const std::vector<std::pair<std::string, std::string> >& group_options) {
    std::vector<std::pair<std::string, int> > lines_to_add;
    std::vector<std::string>::const_iterator fname;
    for (fname = alias_files.begin(); fname != alias_files.end(); ++fname) {
        if ((*fname).empty())
            continue;
        bool ingroup = false;
        std::ifstream in((*fname).c_str());
        if (!in.good()) {
            QMessageHandler::Get()->Send(PanicMsg,"QModuleFactory","Group alias file \"" + *fname +"\" not found. .");
            return;
        }
        std::string line;
        while(getline(in,line)) {
            // keep moving through file until we get to right group
            std::string target_line = "group " + group;
            if (!ingroup && line != target_line)
                continue;
            if (line == target_line) {
                ingroup = true;
                continue;
            } else {
                if (line == "endgroup") {
                    // we've finished the group, so we're done here
                    ingroup = false;
                    break;
                }
                // we're in the group and reading files
                if (line == "endmod") {
                    // we're at the end of a "module", so add in extra options
                    std::vector<std::pair<std::string, std::string> >::const_iterator option;
                    for (option = group_options.begin(); option != group_options.end(); ++option) {
                        lines_to_add.push_back(make_pair((*option).first + "=" + (*option).second, location));
                    }
                }
                lines_to_add.push_back(make_pair(line, -1));
            }
        }
        if (ingroup) {
            QMessageHandler::Get()->Send(PanicMsg,"QModuleFactory","Group file \"" + *fname +"\" is missing an endgroup.");
            return;
        }
    }
    if (lines_to_add.size())
        cfgFileLines.insert(cfgFileLines.begin() + location + 1, lines_to_add.begin(), lines_to_add.end());
    else
        QMessageHandler::Get()->Send(PanicMsg,"QModuleFactory","Unable to find group \"" + group +"\" in group files, or no group file given.");
}
 
Q_END_NAMESPACE