CORE_Out.h

#ifndef CORE_Out_H
#define CORE_Out_H
 
 
//base class header
#include "CORE_Object.h"
 
//shared pointer header
#include "shared_pointer.h"
 
//iostream header
#include <iostream>
 
//files header
#include <fstream>
 
//exception header
#include "CORE_Exception.h"
 
class CORE_Out : public CORE_Object {
    // ATTRIBUTES
 
    public:
  
    
private:
    // ASSOCIATIONS
  
  
    // METHODS
  
  
  
public:
    static const tUCInt NO_OUTPUT=0;
    
    static const tUCInt SCREEN_OUTPUT=1;
    
    static const tUCInt FILE_OUTPUT=2;
    
    static const tUCInt ALL_OUTPUT=3;
    
    static const tFlag APPEND=1;
 
    static const tFlag CREATE=0;
 
private:
   //file output mode APPEND `| CREATE
    tString mOutputFileName;
    tString mOutputFileName_back;
 
    //current output file
    std::ofstream *mOutputFileStream;
    
    //mOutput =mScreen+2*mFile
    tUCInt mOutput;
    //file output
    tUCInt mOutputFileMode;
   
    //backup & restore;
    tFlag mOutput_back;
    tFlag mOutputFileMode_back;
  
    
    
    
public:
    // CONSTRUCTORS
    CORE_Out() {
        mOutputFileStream=null;
        reset();
    }
   
  
  
  
    // DESTRUCTORS
    virtual ~CORE_Out(void) {
        release();
    }
  
   
   
    
public:
  
    
    //New defaut output
    inline static CORE_UniquePointer<CORE_Out> New() {
        return CORE_UniquePointer<CORE_Out>(new CORE_Out(),CORE_Out::Delete());
    }
    
    
public:
    
    // OTHERS
   
   virtual  tMemSize getMemorySize() const  override {
        return sizeof(*this)+getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const override {
        return CORE_Object::getContentsMemorySize()+mOutputFileName.size()+mOutputFileName_back.size();
    }
 public:
    inline void update() {
        //release
        release();
       
        //create file output if used
        if (isOutput(FILE_OUTPUT)) {
            if (mOutputFileMode==APPEND) {
                mOutputFileStream=new std::ofstream(mOutputFileName.c_str(),std::ios::app);
            } else {
                mOutputFileStream=new std::ofstream(mOutputFileName.c_str(),std::ios::out);
            }
            if ((mOutputFileStream!=null) && (!(*mOutputFileStream))) {
                throw CORE_Exception("core","CORE_Out",
                                     "impossible to write in output file "+mOutputFileName);
            }
            
        }
    }
    inline void release() {
        if (mOutputFileStream!=null) {
            mOutputFileStream->close();
            delete mOutputFileStream;
            mOutputFileStream=null;
        } 
    }
    inline void reset() {
        mOutput=SCREEN_OUTPUT;
        mOutputFileMode=CREATE;
        mOutputFileName="./core.log";
        backup();
        update();
    }
    inline void setOutput(const tUSInt& mode) {
        mOutput=mode;
    }
    inline void setOutput(const tString& mode) {
        tUCInt p=1;//2^0
        tUCInt m=0;
        std::string::const_reverse_iterator iS=mode.rbegin();
        while (iS!=mode.rend()) {
            //m+=2^p.mode[l-1-p]
            m+=p*(*iS);
 
            //next element
            p*=2;
            iS++;
        }
        setOutput(m);
    }
 
    inline tBoolean isOutput(const tUCInt& mode) const {
          return ((mOutput & mode ) / mode   == 1);
    }
    inline tBoolean hasOutput() const {
        return (mOutput!=NO_OUTPUT);
    }
    
    
    inline void setOutputFile(const tString& fileName,const tFlag& mode) {
        mOutputFileName=fileName;
        mOutputFileMode=mode;
    }
    inline void setOutputFile(const tString& fileName) {
        setOutputFile(fileName,CREATE);
    }
    inline void updateOutputFile(const tString& fileName) {
        mOutputFileName=fileName;
        update();
    }
 
      
    inline const tString& getOutputFileName() const {
        return mOutputFileName;
    }
   
    inline void backup() {
        mOutputFileMode_back= mOutputFileMode;
        mOutputFileName_back= mOutputFileName;
        mOutput_back= mOutput;
    }
 
    inline void restore() {
        mOutputFileMode= mOutputFileMode_back;
        mOutputFileName= mOutputFileName_back;
        mOutput= mOutput_back;
 
        //update the state
        update();
    }
    
    inline void println(const tString& msg) {
        (*this)<<msg<<"\n";
    }
    
    inline void print(const tString& msg) {
        (*this)<<msg;
    }
    inline void printError(const tString& msg) {
        std::cerr<<msg<<std::flush<<"\n";
    }
 
    inline static void PrintProgressBar(const tString& message,
    const tInt& percent,tInt& oldPercent) {
        if (percent>oldPercent) {
            std::cout << "\r "<<message<<" [" << std::setw(3) << percent << "%] "<<std::flush;
            oldPercent=percent;
        }
     }
   
   
    // << operators
    // =============
    
    template<typename T>
    friend CORE_Out& operator <<(CORE_Out& out,const T& obj) {
        if (out.isOutput(SCREEN_OUTPUT)) std::cout<<obj<<std::flush;
        if (out.isOutput(FILE_OUTPUT) && (out.mOutputFileStream!=null)) (*out.mOutputFileStream)<<obj<<std::flush;
        return out;
    };
    
  
    virtual tString toString() const override {
        std::stringstream sstr;
        sstr<<CORE_Object::toString()<<"\n";
        sstr<<"\t"<<" outputFileName:"<<mOutputFileName<<"\n";
        sstr<<"\t"<<" output Mode:"<<((int)mOutput)<<"\n";
        sstr<<"\t"<<" outputFileMode:"<<((int)mOutputFileMode)<<"\n";
            
        return sstr.str(); 
    }
  
};
 
#endif