CORE_Run.h

Go to the documentation of this file.

#ifndef CORE_Run_H
#define CORE_Run_H

#include "CORE_VectorReader.h"
#include "CORE_Object.h"
#include "CORE_Out.h"
#include "CORE_Exception.h"
#include "CORE_ClassFactory.h"

DEFINE_SPTR(CORE_ClassFactory)


DEFINE_SPTR(CORE_Run);
class CORE_Run : public virtual CORE_Object {
    SP_OBJECT(CORE_Run);
    
    //attributes
private :
   
    tString mSoftName;
    static tString VERSION;
    static SP::CORE_ClassFactory CLASS_FACTORY;
    
protected: 
    // CONSTRUCTORS 
    CORE_Run(void);
  
    // DESTRUCTORS 
    virtual ~CORE_Run(void);
    

 
public : 
    // CREATE class
    static inline SP::CORE_Run New() {
        SP::CORE_Run p(new CORE_Run(),CORE_Run::Delete());
        p->setThis(p);
        return p;
    }

    //SET & GET methods

    inline void setSoftName(const tString& soft) {
        mSoftName=soft;
    }
    inline const tString&  getSoftName() const {
        return mSoftName;
    }

    inline static void setVersion(const tString& version) {
        VERSION=version;
    }
    inline static tString getVersion() {
        return VERSION;
    }

    static inline void setClassFactory(SP::CORE_ClassFactory cf) {
        CLASS_FACTORY=cf;
    }
    static inline CORE_ClassFactory & getClassFactory()  {
        if (CLASS_FACTORY.get()==null) throw CORE_Exception("common/core",
                                                            "CORE_Run::getClassFactory()",
                                                            "global variable CORE_Run::CLASS_FACTORY not set");
        return *CLASS_FACTORY.get();
    }
    
   
    
    // MAIN Method

public:
    static void createIO(const map<tString,tString>& options);

  
    
    virtual tBoolean run(int argc,char* argv[]) const;

protected:
    virtual void createClassFactories(const map<tString,tString>& options) const{
    }
    virtual tBoolean make(const map<tString,tString>&options,const tString& arg)  const {

        
        if (arg.compare("tests")==0)  return makeTests(options);
        else  if (arg.compare("performance")==0)  return makePerformance(options);
        else  if (arg.compare("help")==0)  {
            cout << man();
            return true;
        }
        else  if (arg.compare("type")==0)  return makeType();
        else  if (arg.compare("validation")==0)  return makeValidation(options);
        else  if (arg.compare("run")==0)  return makeRun(options);
        else {
            CORE_Object::out() << arg << " unrecognized.\n";
            cout <<  arg << " unrecognized.\n";
            return false;
        }
    }

    
   

protected:
    tString man() const;

    virtual tBoolean makeType() const;
    
    virtual tBoolean makeValidation(const map<tString,tString>&options) const {
        return true;
    }
    
    virtual tBoolean makeTests(const map<tString,tString>&options) const ;

    virtual tBoolean makePerformance(const map<tString,tString>&options) const ;

public:
    virtual tBoolean makeRun(const map<tString,tString>&options) const {
        return true;
    }
  

    
private:
    static void readOptions(int argc,char *argv[],map<tString,tString>& options);
    

public:
    static tString readOption(const tString& opt,int argc,char *argv[],tBoolean& isExists);
    
public:
    virtual void initOptions(map<tString,tString>& options) const;
    
    virtual void initManOptions(map<tString,map<tString,tString> >& options) const;
    
protected:
    virtual void readOptionsFromCommandLine(int argc,char *argv[],map<tString,tString>& options) const {
        readOptions(argc,argv,options);
    }

public:
    virtual void readOptionsFromFile(const tString& fileName,
                                     map<tString,tString>& options) const;
    tBoolean saveOptionsToFile(const tString& fileName,
                               const map<tString,tString>& options) const;   
    tBoolean saveOptionsToFile(const tString& fileName,
                               const map<tString,map<tString,tString> >& manOptions,
                               const map<tString,tString>& options) const;
    
    CORE_Out& printOptions(CORE_Out& out,
                           const map<tString,tString>& options) const;

    CORE_Out& printOptions(CORE_Out& out,
                           const map<tString,map<tString,tString> >& manOptions,
                           const map<tString,tString>& options) const;
    
public:
 
    static tString readPath(const tString& path);
    
    static tString readFile(const tString& path, const tString& fn);
    template<class T>
    inline static tBoolean readVector(const tString& str,CORE_Array<T>& value)  {
        tString s=str;
        tBoolean succeeds=CORE_VectorReader::readVector(s,value);
        return succeeds;
    }
    inline static tBoolean readVector(const tString& str,vector<tReal>& value)  {
        tString s=str;
        tBoolean succeeds=CORE_VectorReader::readVector(s,value);
        return succeeds;
    }
    inline static tBoolean readVector(const tString& str,tReal value[3])  {

        vector<tReal> vs;
        tString s=str;
        tBoolean succeeds=CORE_VectorReader::readVector(s,vs);
        tFlag i,p=(vs.size()<3)?vs.size():3;
        for (i=0;i<p;i++) value[i]=vs[i];
        return succeeds;
    }
    inline static tBoolean readVector(const tString& str,int value[3])  {
        tReal rv[3];
        tString s=str;
        tBoolean succeeds=readVector(s,rv);
        for (tFlag i=0;i<3;i++) value[i]=(int) rv[i];
        return succeeds;
    }
    inline static tBoolean readVector(const tString& str,tBoolean value[3])  {
        vector<tBoolean> vs;
        tString s=str;
        tBoolean succeeds=CORE_VectorReader::readVector(s,vs);
        tFlag i,p=(vs.size()<3)?vs.size():3;
        for (i=0;i<p;i++) value[i]=vs[i];
        return succeeds;
    }
  
    static tBoolean readBoolean(const tString& fn);
    static tInteger readInt(const tString& fn);
    static tReal readReal(const tString& fn);




};


#endif