CORE_Run.h

Go to the documentation of this file.

#ifndef CORE_Run_H
#define CORE_Run_H
 
#include "CORE_Object.h"
 
//output
#include "CORE_Out.h"
//class factory
#include "CORE_ClassFactory.h"
 
class CORE_Run : public virtual CORE_Object {
   
    //attributes
private :
 
    //name of the soft
    static tString mSoftName;
    
    //version of the progam
    static tString mVersion;
  
     //output 
    static CORE_UniquePointer<CORE_Out> mOut;
 
    //class factory
    static CORE_UniquePointer<CORE_ClassFactory> mClassFactory;
 
    //for profiling method
    static tBoolean mIsProfiling;
    
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;
    }
 
    //debug methods
    //=============
 
     static inline const tBoolean& IsProfiling() {
         return mIsProfiling;
     }
 
    
    //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();
    }
  
    static void SetOutputOptions(const std::map<tString,tString>& option);
 
    static void SetDebugOptions(const std::map<tString,tString>& option);
    
    //options methods
    //===============
    
    virtual void initManOptions(std::map<tString,std::map<tString,tString> >& options) const;
    
    virtual void initOptions(std::map<tString,tString>& options) const;
 
      
   
    //classes factory
    //===============
    virtual void createClassFactories(const std::map<tString,tString>& options) const;
    
    inline static CORE_ClassFactory& GetClassFactory() {
        return *mClassFactory.get();
    }
 
    // Make Methods
    //============
    
    tBoolean executeRun(int argc,char* argv[]) const;
    
    virtual tBoolean makeRun(const tString& command,const std::map<tString,tString>& options) const;
    
  
    
    virtual tBoolean makeTests(const std::map<tString,tString>& options) const;
 
    tBoolean printHelp(const std::map<tString,tString>& options) const;
  
   
    
    
    
 
 
};
 
 
#endif