CORE_Run.h

#ifndef CORE_Run_H
#define CORE_Run_H
 
#include "CORE_Object.h"
 
//output
#include "CORE_Out.h"
 
//class factory
#include "CORE_ClassFactory.h"
 
//list of options header
#include "CORE_OptionsList.h"
 
//options of the program
#include "CORE_Options.h"
 
 
class CORE_Run : public virtual CORE_Object {
   
    //attributes
private :
 
    //name of the soft
    static tString mSoftName;
    
    //version of the progam
    static tString mVersion;
 
    //options class name
    tString mOptionsClassName;
    
     //output 
    static CORE_UniquePointer<CORE_Out> mOut;
 
    //class factory
    static CORE_UniquePointer<CORE_ClassFactory> mClassFactory;
 
 
    
public:
    // CONSTRUCTORS 
    CORE_Run(void);
  
    // DESTRUCTORS 
    virtual ~CORE_Run(void);
    
 
 
public : 
    // CREATE class
   
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const override {
        return mOut->getMemorySize()+mClassFactory->getMemorySize();
    }
    
    //SET & GET methods
public:
    inline static void SetSoftName(const tString& soft) {
        mSoftName=soft;
    }
    inline static const tString&  GetSoftName()  {
        return mSoftName;
    }
 
    inline static void SetVersion(const tString& version) {
        mVersion=version;
    }
    inline static const tString& GetVersion() {
        return mVersion;
    }
 
    inline void setOptionsClassName(const tString& c) {
        mOptionsClassName=c;
    }
 
 
  
  
    
    //system methods
    //===============
    
    inline static tBoolean Is64Architecture() {
        return (sizeof(tLDouble)==16);
    }
    
    inline static tBoolean Is32Architecture() {
        return (sizeof(tLDouble)==8);
    }
 
    //initialization of global variables
    //=================================
    
    inline static void InitSeed(const unsigned int& seed) {
        std::srand(seed);
    }
    inline static void InitSeed() {
        std::srand(time(NULL));
    }
   
 
public:
  
    //output methods
    //==============
    inline static CORE_Out& Out() {
        return *mOut.get();
    }
    inline static CORE_Out& getOut() {
        return *mOut.get();
    }
 
   
 
    
    //options methods
    //===============
   
    
    inline void initOptions(CORE_OptionsList& options) const {
        CORE_UniquePointer<CORE_Options> optionsCL=GetClassFactory().NewInstance<CORE_Options>(mOptionsClassName);
        if (optionsCL.get()!=null) {
            optionsCL->initOptions(options);
            optionsCL->initManOptions(options);
        } 
       
    }
  
   
 
      
   
    //classes factory
    //===============
    virtual void createClassFactories(const CORE_OptionsList& options) const;
    
    inline static CORE_ClassFactory& GetClassFactory() {
        return *mClassFactory.get();
    }
 
    //Options methods
    //================
 
    static tString ReadPath(const CORE_OptionsList& options,
                            const tString& optName);
    
    static void ReadOutputOptions(const CORE_OptionsList& options,
                                  tString& outputPath,
                                  tString& outputPrefix);
 
    static void ReadInputOptions(const CORE_OptionsList& options,
                                 tString& inputPath,
                                 tString& inputPrefix);
 
    static void SetLogOptions(const CORE_OptionsList& options) ;
    
    virtual void setLogOptions(const CORE_OptionsList& options) const {
        CORE_Run::SetLogOptions(options);
    }
    
    inline static void SetDebugOptions(const CORE_OptionsList& options) {
        tBoolean isMemoryChecked=false;
        options.getOptionValue("check-memory",isMemoryChecked);
        if (isMemoryChecked && (!CORE_Object::EnableMemoryStack(isMemoryChecked))) {
            std::cout<<"memory checked is  forced to be disabled because of release mode / OpenMP module \n";
        }
        options.getOptionValue("is-profiling-printed",CORE_Profiler::IS_PROFILING_ROUTINE_PRINTED);
        
        
    }
    
    // Make Methods
    //============
 
    
    virtual void  getManCommands(std::map<tString,tString>& commandsMan) const {
        commandsMan["make run"]="run the program";
        commandsMan["make tests"]="run the tests";
        commandsMan["make help"]="show the help";
    }
   
    
    tBoolean executeRun(int argc,char* argv[]) const;
    
    virtual tBoolean makeRun(const tString& command,const CORE_OptionsList& options) const;
    
  
    
    virtual tBoolean makeTests(const CORE_OptionsList& options) const;
 
    virtual tBoolean printHelp(const CORE_OptionsList& options) const;
  
   
    
    
    
 
 
};
 
 
#endif