Options.h

Go to the documentation of this file.

//$Id $
//------------------------------------------------------------------------------
//
//  Package    : Options
//
//  Description:
//
//  Author(s)  : F. Machefert -
//  Date       : 7 June 2004
//
//------------------------------------------------------------------------------
#ifndef CONFIG_H
#define CONFIG_H

// Include files
#include <fstream>
#include <iostream>
#include <string>

#include "MsgSvc.h"
#include "Tools.h"

class Element;

class Options {
public:
        Options();
        ~Options();

        void setLogOutputLevel (MsgSvc::MsgLevel logOutputLevel) {
                m_logOutputLevel = logOutputLevel;
        }

        MsgSvc::MsgLevel logOutputLevel () {
                return m_logOutputLevel;
        }

        void setPrintFreq (unsigned long printFreq) {
                m_printFreq = printFreq;
        }

        unsigned long printFreq () {
                return m_printFreq;
        }

        void setPlotFreq (unsigned long plotFreq) {
                m_plotFreq = plotFreq;
        }

        unsigned long plotFreq () {
                return m_plotFreq;
        }


        void setStopOnError (bool stopOnError) {
                m_stopOnError = stopOnError;
        }

        bool stopOnError () {
                return m_stopOnError;
        }

        void setRunNumber (unsigned long runNumber) {
                m_runNumber = runNumber;
        }

        unsigned long runNumber () {
                return m_runNumber;
        }

        void setRunNumberManagement (bool runNumberManagement) {
                m_runNumberManagement = runNumberManagement;
        }

        bool runNumberManagement () {
                return m_runNumberManagement;
        }

        void setCurrentPath (std::string currentPath) {
                m_currentPath = currentPath;
        }

        std::string currentPath () {
                return m_currentPath;
        }

        void setStoragePath (std::string storagePath) {
                m_storagePath = storagePath;
        }

        std::string storagePath () {
                return m_storagePath;
        }

        std::string storageFullPath () {
                std::string path = m_storagePath;
                path.append("/");
                path.append(m_storageDir);
                path.append("_");
                path.append(itos(m_runNumber));
                return path;
        }

        void setStorageDir (std::string filename){
                m_storageDir = filename;
        }

        std::string storageDir (){
                return m_storageDir;
        }

        void setStorageFile (std::string filename=std::string("")){
                if (std::string("")==filename) {
                        m_storageFile = m_storageDefault;
                        return;
                }
                m_storageFile = filename;
        }

        std::string storageFile (){
                return m_storageFile;
        }

        std::string storageFileFullName (){
                std::string file = storageFullPath();
                file.append("/");
                file.append(m_storageFile);
                return file;
        }

        std::string dataFileFullName (){
                std::string file = storageFullPath();
                file.append("/");
                file.append(m_storageFile);
                file.append(".root");
                //    std::cout << " OPTIONS ->" << file << " " << storageFullPath()<< " " << m_storageFile  << std::endl;
                return file;
        }

        std::string dataFile ();

        std::string logFile ();

        void setDataStorage (bool dataStorage) {
                m_dataStorage = dataStorage;
        }

        bool dataStorage () {
                return m_dataStorage;
        }

        void setLogStorage (bool logStorage) {
                m_logStorage = logStorage;
        }

        bool logStorage () {
                return m_logStorage;
        }

        void setLogDefFile (std::string defFile) {
                m_logDefFile = defFile;
                m_logDefStream = new std::ofstream( defFile.c_str() );
        }

        std::string logDefFile () {
                return m_logDefFile;
        }

        void setDefFile (std::string def) {
                m_defFile = def;
        }

        std::string defFile () {
                return m_defFile;
        }

        void setNEvt (unsigned long nEvt) {
                m_nEvt = nEvt;
        }

        unsigned long nEvt () {
                return m_nEvt;
        }

        void setNEvtMax (int nEvtMax) {
                m_nEvtMax = nEvtMax;
        }

        int nEvtMax () {
                return m_nEvtMax;
        }

        void setTimeMax (unsigned long timeMax) {
                m_timeMax = timeMax;
        }

        unsigned long timeMax () {
                return m_timeMax;
        }

        void setNErrors (unsigned long nErrors) {
                m_nErrors = nErrors;
        }

        unsigned long nErrors () {
                return m_nErrors;
        }

        void incRunNumber();

        void incNEvt() {
                setNEvt ( nEvt() + 1 );
        }

        void incNErrors() {
                setNErrors ( nErrors() + 1 );
        }

        std::ofstream* stream () {
                return m_stream;
        }

        void setStream ( std::string file=std::string("") ) {
                if (file.compare("")==0 ) {
                        if (m_stream == m_logStream && 0!=m_logStream ) {
                                m_logStream->close();
                                delete m_logStream;
                                m_logStream = 0;
                        }
                        m_stream=m_logDefStream;
                }
                else {
                        if ( !logStorage () ) {
                                setStorageFile ( file );
                        }
                        else {
                                if ( 0!=m_logStream) {
                                        m_logStream->close();
                                        delete m_logStream;
                                        m_logStream=0;
                                }
                                setStorageFile(file);
                                std::string name = storageFileFullName();
                                name.append(".log");
                                m_logStream = new std::ofstream( name.c_str() );
                                m_stream=m_logStream;
                        }
                }
        }

        void print();

private:
        MsgSvc m_log;
        MsgSvc::MsgLevel m_logOutputLevel; //< Output level threshold

        std::string m_currentPath; //< Current path of the application
        bool m_dataStorage;      //< Data Storage boolean
        bool m_logStorage;       //< Log Storage boolean
        std::string m_storageDir; //< data & log directory name for storage
        std::string m_storageFile; //< data & log file name for storage
        std::string m_storageDefault; //< data & log default file name for storage
        std::string m_storagePath; //< data & log file path for storage
        std::string m_defFile;   //< Definition file
        bool m_stopOnError;
        unsigned long m_nEvt;    //< number of events processed
        unsigned long m_nErrors; //< number of errors in present process
        unsigned long m_printFreq; //< Evt Number Output Frequency
        unsigned long m_plotFreq; //< Evt Number Plot Frequency
        int m_nEvtMax;           //< number of events to process (negative val=seconds)
        int m_timeMax; //< time to process
        unsigned long m_runNumber; //< Current Run Number

        bool m_runNumberManagement; //< Run Number Automatically Managed
        bool m_batch;            //< batch mode

        std::ofstream *m_stream; // current log file output stream
        std::ofstream *m_logStream; // log file output stream
        std::ofstream *m_logDefStream; // default log file output stream
        std::string m_logDefFile; //< default log file name for storage
};

#endif