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"
#include "CORE_String.h"


  
  

DEFINE_SPTR(CORE_Out);

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

    public:
    //for printing in string
    static const tFlag STRING_OUTPUT;
    //for printing in screen
    static const tFlag SCREEN_OUTPUT;
    //for printing in file
    static const tFlag FILE_OUTPUT;
    
    //output file mode : append to file
    static const tFlag APPEND;
    //output file mode : create file
    static const tFlag CREATE;

    //print only error
    static const tFlag ERROR_MSG;
    //print only warning
    static const tFlag WARNING_MSG;
    //print only DEBUG
    static const tFlag DEBUG_MSG;
    //print only comment
    static const tFlag COMMENT_MSG;
    
    //true to print error or screen
    static tBoolean IS_ERROR_MESSAGE_PRINTED_ON_SCREEN;
    
private:
    
    tBoolean mIsAborting;

    
    static tFlag mPrintedType;
    
    // mVerbose= (mError+2*(mWarning+2*(mDebug+2*mComment)))
    tFlag mVerbose;
    tFlag mVerbose_back;

    //mOutput =(mScreen+2*(mFile+2*String))
    tFlag mOutput;
    tFlag mOutput_back;

    //file output
    tFlag mOutputFileMode;
    tString mOutputFileName;
    
    tFlag mOutputFileMode_back;
    tString mOutputFileName_back;
    
    ofstream *mOutputFile;
    
    //string output
    std::stringstream *mOutputString;
    
    
    // ASSOCIATIONS
  
  
    // METHODS
  
  
public:
    // 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->setOutput("000");//no outout
        return p;
    };
  
    inline static SP::CORE_Out New(const tString& outputType){
        SP::CORE_Out p=New();
        p->setOutput(outputType);
        return p;
    };
    inline static SP::CORE_Out New(const tFlag& outputType){
        SP::CORE_Out p=New();
        p->setOutput(outputType);
        return p;
    };
  

private:
    void release();
    
    // SET
public:
    inline static void setPrintedType(const tFlag& type) {
        mPrintedType=type;
    }
    inline void setVerbose(const tFlag& f) {
        setVerbose(CORE_Integer::toBinString<4>(f));
    }
    
    void setVerbose(const tString& f);
    
    inline void setOutput(const tFlag& type)  {
        setOutput(CORE_Integer::toBinString<3>(type));
    }
    void setOutput(const tString& type);
    void setOutputBit(const tUChar& index, const tBoolean& v);

    void backup();
    void restore();
    
    void reset();
    
private:
    void createStreams();
    
public:
    void setOutputFile(const tString& fileName,const tFlag& mode);
    inline void setOutputFile(const tString& fileName) {
        setOutputFile(fileName,CREATE);
    }

    inline void update() {
        createStreams();
    }
    
  
    // GET
    inline static const tFlag&  getPrintedType() {
        return mPrintedType;
    }
    inline tBoolean isVerbose(const tFlag& type)  {
        return ((mVerbose & type ) / type   == 1);
    }
    inline tBoolean isOutput(const tFlag& type)  {
        return ((mOutput & type ) / type   == 1);
    }
    
    
    inline ofstream& getOutputFile() {
        return *mOutputFile;
    };
    inline const tFlag& getOutput() {
        return mOutput;
    };
    
    inline tString getOutputFileName() const {
        return mOutputFileName;
    }

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

    inline tString str() const {
        return getOutputString();
    }
  
    
    
public:
    
    // OTHERS
   
    
 public:
    virtual void printInt(const tInteger& i) {
        genericPrint(mPrintedType,i);
    }

    virtual void printString(const tString& message) {
        genericPrint(mPrintedType,message);
    };
    
    virtual void print(const tFlag& type,const tString& message) {
        genericPrint(type,message);
    }
    virtual void println(const tFlag& type,const tString& message) {
        genericPrint(type,message+"\n");
    }
    virtual void print(const tString& message) {
        genericPrint(mPrintedType,message);
    }
    virtual void println(const tString& message) {
        genericPrint(mPrintedType,message+"\n");
    }
    

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

  
    
    virtual void ask(const tString& question,tString& ret);
    
    virtual void ask(const tString& question,tInteger& ret);



    // templated printed methods
    // =========================
private:
    template<class T>
    CORE_Out& templatedPrint(const tFlag& type,const T& str) {
        
        if (!isVerbose(type)) return (*this);
        
        //prefix depending on type
        tString prefix="";
        if (type==WARNING_MSG) {
            prefix="WARNING:\t";
        }else if (type==ERROR_MSG) {
            prefix="ERROR:\t";
            if (IS_ERROR_MESSAGE_PRINTED_ON_SCREEN) cerr << prefix<<str<<flush;
        }else if (type==DEBUG_MSG) {
            prefix="DEBUG:\t";
        }

        if (isOutput(SCREEN_OUTPUT) || ((type==ERROR_MSG) && IS_ERROR_MESSAGE_PRINTED_ON_SCREEN ) )   cout << prefix<<str<<flush;
        if (isOutput(FILE_OUTPUT))   (*mOutputFile) << prefix<<str<<flush;
        if (isOutput(STRING_OUTPUT)) (*mOutputString) << prefix<<str<<flush;
        
        return (*this);
    }
    
   

    // << operators
    // =============
    
    friend CORE_Out& operator << (CORE_Out& out,const CORE_Object& obj) {
        return out.genericPrint(mPrintedType,obj.toString());
    };
    friend CORE_Out& operator << (CORE_Out& out,const tString& obj) {
        return out.genericPrint(mPrintedType,obj);
    };

    friend CORE_Out& operator << (CORE_Out& out,const tBoolean& obj) {
        return out.genericPrint(mPrintedType,CORE_String::boolean2String(obj));
    };
    
    friend CORE_Out& operator << (CORE_Out& out,const tChar& obj) {
       
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tChar* obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tUChar& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
     
    friend CORE_Out& operator << (CORE_Out& out,const tSInt& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tUSInt& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tInt& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tUInt& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
  
    friend CORE_Out& operator << (CORE_Out& out,const tLInt & obj) {
        return out.genericPrint(mPrintedType,obj);
    }; 
    friend CORE_Out& operator << (CORE_Out& out,const tULInt& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tLLInt & obj) {
        return out.genericPrint(mPrintedType,obj);
    }; 
    friend CORE_Out& operator << (CORE_Out& out,const tULLInt& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tFloat& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tDouble& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    
    friend CORE_Out& operator << (CORE_Out& out,const tLDouble& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tFComplex& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tDComplex& obj) {
        return out.genericPrint(mPrintedType,obj);
    };
    friend CORE_Out& operator << (CORE_Out& out,const tLDComplex& obj) {
        return out.genericPrint(mPrintedType,obj);
    };

    // methods to specialized << operator
    // ==================================
    
public:
    virtual CORE_Out& genericPrint(const tFlag& type,const CORE_Object& obj) {
        return templatedPrint(type,obj.toString());
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tString& obj) {
        return templatedPrint(type,obj);
    };
   
    virtual CORE_Out& genericPrint(const tFlag& type,const tBoolean& obj) {
        return templatedPrint(type,CORE_String::boolean2String(obj));
    };
    
    virtual CORE_Out& genericPrint(const tFlag& type,const tChar& obj) {
       
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tChar* obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tUChar& obj) {
        return templatedPrint(type,obj);
    };
     
    virtual CORE_Out& genericPrint(const tFlag& type,const tSInt& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tUSInt& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tInt& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tUInt& obj) {
        return templatedPrint(type,obj);
    };
  
    virtual CORE_Out& genericPrint(const tFlag& type,const tLInt & obj) {
        return templatedPrint(type,obj);
    }; 
    virtual CORE_Out& genericPrint(const tFlag& type,const tULInt& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tLLInt & obj) {
        return templatedPrint(type,obj);
    }; 
    virtual CORE_Out& genericPrint(const tFlag& type,const tULLInt& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tFloat& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tDouble& obj) {
        return templatedPrint(type,obj);
    };
    
    virtual CORE_Out& genericPrint(const tFlag& type,const tLDouble& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tFComplex& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tDComplex& obj) {
        return templatedPrint(type,obj);
    };
    virtual CORE_Out& genericPrint(const tFlag& type,const tLDComplex& obj) {
        return templatedPrint(type,obj);
    };


    virtual tString toString() const {
        tString ret="log :\n";
        ret+="\t file mode:"+CORE_Integer::toString((int)mOutputFileMode)+" APPEND="+CORE_Integer::toString((int)APPEND)+" CREATE="+CORE_Integer::toString((int)CREATE)+"\n";
        ret+="\t file name:"+mOutputFileName+"\n";
        ret+="\t verbose:"+CORE_Integer::toString((int)mVerbose)+" FILE="+CORE_Integer::toString((int)FILE_OUTPUT)+" STRING="+CORE_Integer::toString((int)STRING_OUTPUT)+" SCREEN="+CORE_Integer::toString((int)SCREEN_OUTPUT)+"\n";
        return ret;
    }
};

#endif