QProgressBar.hh

Go to the documentation of this file.

#ifndef _Q_PROGRESSBAR_HH_
#define _Q_PROGRESSBAR_HH_
 
#include "QObject.hh"
#include <string>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <cstdio>
 
using std::string;
 
 
class QProgressBar : public Diana::QObject {
 
    public:
       QProgressBar(uint64_t total_iterations,string description="Progress",bool leave=true,int step=1,bool enable=true,std::ostream& out=std::cout)
            :foutstream(out)
       {
            fEnabled=enable;
            if(fEnabled){
                Clear();
                get_terminal_size();
                fleave=leave;
                fstep=(uint64_t)step;
            
                SetIterations(total_iterations);
                SetDescription(description);
            }
       }
       QProgressBar(const QProgressBar& other)
            :foutstream(other.foutstream)
       {
            *this = other;
       }
       QProgressBar()
         :foutstream(std::cout)
       {
           Clear();
       }
 
       ~QProgressBar(){Clear();}
       void Clear(){
            if(fEnabled){
                get_terminal_size();
                foutstream<<"\r";
                for(size_t i=0;i<terminalwidth;i++){
                    foutstream<<" ";
                }
                foutstream<<"\r";
            
                fNumOfIters=0;
                fCurrentIter=0;
                fdesc="Progress";
                terminalwidth=50;
                fleave=true;
                fstep=1;
            }
       }
 
       void SetIterations(uint64_t total_iterations){
            fNumOfIters=total_iterations;
            uint64_t sugg_step=total_iterations/1e4;//because we are printing number with 2 decimal places
            if(sugg_step>fstep){
                fstep=sugg_step;
            } 
       }
       void SetDescription(string description){fdesc=description;}
      
       void IncrementIter(bool printbar=true){
            if(fEnabled){
                fCurrentIter++;
                printbar = printbar and ((fCurrentIter%fstep==0) or (fCurrentIter==fNumOfIters));
                if(printbar){
                    PrintBar();
                }
                if(fCurrentIter==fNumOfIters){
                    if(!fleave){
                         foutstream<<"\r";
                        for(size_t i=0;i<terminalwidth;i++){
                            foutstream<<" ";
                        }
                        foutstream<<"\r";
                    }else{
                        foutstream<<std::endl;
                    }
                }
            }
       }
 
       void Print(string message,bool isbar=false)const{
            if(fEnabled){
                foutstream<<"\r";
                foutstream<<message;
                if(!isbar){
                     for(size_t i=message.size();i<terminalwidth;i++){
                        foutstream<<" ";
                    }
                    foutstream<<std::endl;
                    foutstream<<bar.str();
                }
            }else if(!isbar){
                foutstream<<message<<std::endl;
            }
            foutstream.flush();
       }
       QProgressBar& operator=(const QProgressBar& other)
       {
            fNumOfIters=other.fNumOfIters;
            fCurrentIter = other.fCurrentIter;
            fdesc=other.fdesc;
            bar<<other.bar.str();
            fleave=other.fleave;
            get_terminal_size();
            fEnabled=other.fEnabled;
            return *this;
       }
    protected:
        std::ostream& foutstream;
    
    private:
        void get_terminal_size(){
             FILE* stream = popen("tput cols", "r");
             if (stream) {
                 char buffer[128];
                 if (fgets(buffer, sizeof(buffer), stream) != NULL) {
                     terminalwidth = (size_t)std::stoi(buffer);
                 }
                 pclose(stream);
             }
        }
       
        void PrintBar(){
            char donechar ='#';
            double doneperc = (double)fCurrentIter/(double)fNumOfIters;
            bar.str("");
            bar <<"[";
            bar <<std::setw(6)<<std::setfill(' ')<< std::fixed << std::setprecision(2) << doneperc*100;
            bar <<"%]"<<fdesc<<": [";
            
            size_t progresssize=terminalwidth-(bar.str().size()+1);
            size_t maxdonechar = (size_t)(doneperc * (double)progresssize);
            for(size_t i =0;i<progresssize;i++){
                if(i<maxdonechar){
                    bar<<donechar;
                }else{
                    bar<<" ";
                }
            }
            bar <<"]";
            Print(bar.str(),true); 
        }
        bool fleave;         
 
        uint64_t fNumOfIters;
        uint64_t fCurrentIter;
        uint64_t fstep;
        
        string fdesc;
        
        std::ostringstream bar;
        size_t terminalwidth;
        bool fEnabled;
     
        QObjectDef(QProgressBar,2);
 
};
 
#endif