CORE_Out.h

Go to the documentation of this file.

#ifndef CORE_Out_H
#define CORE_Out_H


#include "CORE_Object.h"
#include "CORE_Integer.h"
#include "CORE_Real.h"


  
  

DEFINE_SPTR(CORE_Out);

class CORE_Out : public CORE_Object { // class
    SP_OBJECT(CORE_Out)
  
    // ATTRIBUTES

    public:
    static const tFlag NO_OUTPUT;
    static const tFlag STRING_OUTPUT;
    static const tFlag SCREEN_OUTPUT;
    static const tFlag FILE_OUTPUT;
    static const tFlag ALL_OUTPUT;

    static const tFlag APPEND;
    static const tFlag CREATE;
    
    static const int ERROR_MSG;
    static const int WARNING_MSG;
    static const int DEBUG_MSG;
    
    
private:
    
    tBoolean mIsAborting;
    tFlag mVerbose;

    //output
    tFlag mOutputType;
    ofstream *mOutputFile;
    tString mOutputFileName;
    std::stringstream *mOutputString;
    
    
    // ASSOCIATIONS
  
  
    // METHODS
  
  
protected:
    // CONSTRUCTORS
    CORE_Out(); 
   
  
  
  
    // DESTRUCTORS
    virtual ~CORE_Out(void);  
  
  
public:
    // NEW
    inline static SP::CORE_Out New(){
        SP::CORE_Out p(new CORE_Out(),CORE_Out::Delete());
        p->setOutputType(NO_OUTPUT);
        return p;
    };
  
    inline static SP::CORE_Out New(const tFlag& outputType){
        SP::CORE_Out p=New();
        p->setOutputType(outputType);
        return p;
    };
  
  
    // SET

protected:
    inline void setOutputType(const tFlag& type)  {
        mOutputType=type;
        if (mOutputType==STRING_OUTPUT) {
            if (mOutputString!=null) delete mOutputString;
            mOutputString=new std::stringstream();
        }
    }
public:
    void setOutputFile(const tString& fileName,const tFlag& mode);
    inline void setOutputFile(const tString& fileName) {
        setOutputFile(fileName,CREATE);
    }

    void setVerbose(const int& f) {
        mVerbose=f;
    }
    
    // GET

    inline tString getOutputFileName() const {
        return mOutputFileName;
    }

    inline tString getOutputString() const {
        if (mOutputString==null) return "";
        return mOutputString->str();
    }

    inline tBoolean isVerbose(const int& type) const {
        return ((mVerbose & type) / type != 0 );
    }
public:
    
    // OTHERS
    virtual void print(const int& type,const tString& str);
    inline void print(const tString& str) {
        print(WARNING_MSG,str);
    }
    
    inline void println(const int& type,const tString& str) {
        print(type,str+"\n");
    }
    inline void println(const tString& str) {
        print(str+"\n");
    }
    inline void println(const int& type) {
        print(type,"\n");
    }
    inline void println() {
        print("\n");
    }
    
    virtual void print(const int& type,const tLong& str);
    virtual void print(const int& type,const unsigned tLong& str);
    
    virtual void print(const int& type,const long double& str); 
  
  
    virtual void print(const int& type,const int& str); 
  
    virtual void printInt(const int& type,const int& i) {
        print(type,CORE_Integer::toString(i));
    };
    virtual void printInt(const int& i) {
        print(WARNING_MSG,CORE_Integer::toString(i));
    };
  
    virtual void printReal(const int& type,const tReal& i) {
        print(type,CORE_Real::toString(i));
    };
  
    virtual void printString(const int& type,const tString& str) {
        print(type,str);
    };
    virtual void printString(const tString& str) {
        print(WARNING_MSG,str);
    };

    virtual void printTime(const int& type);
    inline void printTime() {
        printTime(ERROR_MSG);
    }
     static tString getTime();
    
    virtual void printError(const tString& str);
    virtual void printWarning(const tString& str);
    
  
    virtual void abort(){mIsAborting=true;};
    tBoolean isAborting() const {
        return mIsAborting;
    };
  
    virtual void setAction(const tFlag& type,
                           const vector<tString>& args){
       
        int n=args.size();
        for(int i=0;i<n;i++) {
            print("args["+CORE_Integer::toString(i)+"]="+args[i]+"\n");
        }
    };

  
    
    virtual void ask(const tString& question,tString& ret);
    
    virtual void ask(const tString& question,int& ret);
    
    friend CORE_Out& operator << (CORE_Out& out,const CORE_Object& obj) {
        out.print(WARNING_MSG,obj.toString());
        return out;
    };
    friend CORE_Out& operator << (CORE_Out& out,const tString& obj) {
        out.print(WARNING_MSG,obj);
        return out;
    };
   
    friend CORE_Out& operator << (CORE_Out& out,const int& obj) {
        out.print(WARNING_MSG,obj);
        return out;
    };
    friend CORE_Out& operator << (CORE_Out& out,const tLong& obj) {
        out.print(WARNING_MSG,obj);
        return out;
    }; 
    friend CORE_Out& operator << (CORE_Out& out,const unsigned tLong& obj) {
        out.print(WARNING_MSG,obj);
        return out;
    };
    friend CORE_Out& operator << (CORE_Out& out,const long double& obj) {
        out.print(WARNING_MSG,obj);
        return out;
    };
    
    
};

#endif