---

processManager.cpp

Go to the documentation of this file.

#include "Event/processManager.h"
#include "Event/centellaAlgorithms.h"
#include "centella/userAlgorithms.h"
#include "Event/messageManager.h"

processManager* processManager::m_instance = 0;

//#####################################
processManager::processManager() 
//#####################################
{
        if (m_instance != 0) return;

        m_algorithms     = new serverVI<algorithmVI>();
        m_eventTasks = new serverVI<eventTask>();
        m_algorithmTasks = new serverVI<algorithmTask>();
        m_algConditionalTasks = new serverVI<algConditionalTask>();

        addAlgorithmTask("iniOfRun", new algorithmTask("iniOfRun"));
        addEventTask("runEvent", new eventTask("runEvent"));
        addAlgorithmTask("endOfRun", new algorithmTask("endOfRun") );

        m_applicationName = "centellaAlg";

        m_eventTaskName = "";
        m_algorithmTaskName = "";

        m_instance = this;

        setName("processManager");
        centellaAlgorithms();
        userAlgorithms();
}
//#####################################
void processManager::setOption(std::string type, std::string name)
//#####################################
{
        optionVI::setOption(type,name);
        if (type == "newEventTask") {
                addEventTask(name, new eventTask(name));
                message(" processManager: create eventTask "+name);
        } else if (type == "newAlgorithmTask") {
                addAlgorithmTask(name, new algorithmTask(name));
                message(" created algorithmTask : "+name);
        } else if (type == "newAlgConditionalTask") {
                addAlgConditionalTask(name, new algConditionalTask(name));
                message(" created algConditialTask : "+name);
        }
}
//#####################################
processManager::~processManager()
//#####################################
{
    // Free dynamically allocated algorithms
    // Note that m_algorithms contains each instance
    // of m_eventTasks, m_algorithmTasks, m_algConditionalTasks
    // So we don't free the elements of these vectors.
    unsigned int i;
    unsigned int size = m_algorithms->size();
    for (i = 0; i < size; i++) {
        if(m_algorithms->get(i)) delete (m_algorithms->get(i));
     }

        delete m_algorithms;
        delete m_eventTasks;
        delete m_algorithmTasks;
        delete m_algConditionalTasks;
}
//#####################################
void processManager::addAlgorithm(std::string name, algorithmVI* alg) 
//#####################################
{
        if (!m_algorithms->search(name)) m_algorithms->add(name,alg);
        else message(" algorithm already included in server "+name);
}
//#####################################
void processManager::addAlgorithmTask(std::string name, algorithmTask* alg)
//#####################################
{
        if (!m_algorithms->search(name)) {
                m_algorithmTasks->add(name,alg);
                addAlgorithm(name,alg);
        } else message(" algorithmTask already included in server "+name);
}
//#####################################
void processManager::addEventTask(std::string name, eventTask* evt)
//#####################################
{
        if (!m_algorithms->search(name)) {
                m_eventTasks->add(name,evt);
                addAlgorithm(name,evt);
        } else message(" not found evtProcess "+name,"GENERAL");
}
//#####################################
void processManager::addAlgConditionalTask(std::string name, algConditionalTask* alg)
//#####################################
{
        if (!m_algorithms->search(name)) {
                m_algConditionalTasks->add(name,alg);
                addAlgorithm(name,alg);
        } else message(" not found algConditionalTask "+name,"GENERAL");
}
//#####################################
algorithmVI* processManager::getAlgorithm(std::string name) const
//#####################################
{
        if (m_algorithms->search(name)) return m_algorithms->get(name);
        else message(" not found algorithm "+name,"GENERAL");
        return 0;
}
//#####################################
eventTask* processManager::getEventTask(std::string name) const
//#####################################
{
        if (m_eventTasks->search(name)) return m_eventTasks->get(name);
        message(" not found evtProcess "+name,"GENERAL");
        return 0;
}
//#####################################
algorithmTask* processManager::getAlgorithmTask(std::string name) const
//#####################################
{
        if (m_algorithmTasks->search(name)) return m_algorithmTasks->get(name);
        message(" not found algorithmTask "+name,"GENERAL");
        return 0;
}
//#####################################
algConditionalTask* processManager::getAlgConditionalTask(std::string name) const
//#####################################
{
        if (m_algConditionalTasks->search(name)) return m_algConditionalTasks->get(name);
        message(" not found algConditionalTask "+name,"GENERAL");
        return 0;
}
//########################################
void processManager::defineOption()
//########################################
{
        optionVI::defineOption("newEventTask",&m_eventTaskName);
        optionVI::defineOption("newAlgorithmTask",&m_algorithmTaskName);
        optionVI::defineOption("newAlgConditionalTask",&m_algConditionalTaskName);
        optionVI::defineOption("application",&m_applicationName);
}
//########################################
void processManager::writeOut() const
//########################################
{
        if (!acceptLevel()) return;     
        std::ostream& out = messageManager::instance()->out();

        messageVI::writeOut();

        out << " application = " << m_applicationName <<"\n";

        if (m_algorithms->size() > 0) {
                out << " -- Algorithms declared in algorithms server --" << "\n";
                out << m_algorithms->nameList();
        }
        if (m_eventTasks->size() > 0) {
                out << " -- eventTasks declared in the eventTasks server --" << "\n";
                out << m_eventTasks->nameList();
        }
        if (m_algorithmTasks->size() > 0) {
                out << " -- algorithmTask declared in the algorithmTask server --" << "\n";
                out << m_algorithmTasks->nameList();
        }
                
        if (m_algConditionalTasks->size() > 0) {
                out << " -- algConditionalTask declared in the algConditionalTask server --" << "\n";
                out << m_algConditionalTasks->nameList(); 
        }

        for (int ievt = 0; ievt < m_eventTasks->size(); ievt++ )
                m_eventTasks->get(ievt)->writeOut();

        for (int itask = 0; itask < m_algorithmTasks->size(); itask++ )
                m_algorithmTasks->get(itask)->writeOut();
        
        for (int ic = 0; ic < m_algConditionalTasks->size(); ic++ )
                m_algConditionalTasks->get(ic)->writeOut();
}

---