CProgressBar.h

#ifndef PROGRESS_BAR_H
#define PROGRESS_BAR_H
 
#include <CPrintDuringExec.h>
#include <SimObject.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
 
class ProgressBar
{
   public:
   static int LENGTH_OF_PROGRESS_BAR;
   static double PERCENTAGE_BIN_SIZE;
 
   static std::string generateProgressBar(unsigned int percentage, double currentTime)
   {
      const int progress = static_cast<int>(std::ceil(percentage / (double)PERCENTAGE_BIN_SIZE));
      std::ostringstream ss;
      ss << std::fixed << std::setprecision(3) << "T:" << currentTime << " " << std::setw(3) << std::right << percentage << "% ";
      std::string bar("[" + std::string(LENGTH_OF_PROGRESS_BAR - 2, ' ') + "]");
 
      unsigned int numberOfSymbols = std::min(
          std::max(0, progress - 1),
          LENGTH_OF_PROGRESS_BAR - 2);
 
      bar.replace(1, numberOfSymbols, std::string(numberOfSymbols, '#'));
      ss << bar;
      return ss.str();
   }
 
   ProgressBar(double totalTime, const std::string& initialMessage = "")
       : mTotalTime(totalTime)
       , mCurrentTime(0)
       , mEnded(false)
       , mOutStream(nullptr)
   {
      mCout = std::cout.rdbuf();
      std::cout.rdbuf(mSs.rdbuf());
      mOutStream.rdbuf(mCout);
      mOutStream << initialMessage << "\n";
      mLengthOfLastPrintedMessage = initialMessage.size();
      mOutStream << generateProgressBar(0, 0) << "\r" << std::flush;
   }
 
   ~ProgressBar()
   {
      endProgressBar();
   }
 
   // Make the object non-copyable
   ProgressBar(const ProgressBar& o) = delete;
   ProgressBar& operator=(const ProgressBar& o) = delete;
 
   void endProgressBar()
   {
      if (!mEnded) {
         mOutStream << std::string(2, '\n');
      }
      mEnded = true;
   }
 
   void printNewMessage(const std::string& message)
   {
      if (mEnded) {
         throw std::runtime_error("Attempted to use progress bar after having terminated it");
      }
 
      mOutStream << "\r"
                 << std::left
                 << std::setw(LENGTH_OF_PROGRESS_BAR + 6)
                 << message << "\n";
      mLengthOfLastPrintedMessage   = message.size();
      const unsigned int percentage = static_cast<unsigned int>(std::ceil(mCurrentTime / mTotalTime * 100));
 
      mOutStream << generateProgressBar(percentage, mCurrentTime) << "\r" << std::flush;
   }
 
 
   /*void updateLastPrintedMessage(const std::string& message)
    {
        if (mEnded)
        {
            throw std::runtime_error("Attempted to use progress bar after having terminated it");
        }
 
        mOutStream << "\r\x1b[1A"
            << std::left
            << std::setw(mLengthOfLastPrintedMessage)
            << message << "\n";
        mLengthOfLastPrintedMessage = message.size();
    }*/
 
   void setTime(double currentTime)
   {
      if (mEnded) {
         throw std::runtime_error(
             "Attempted to use progress bar after having terminated it");
      }
      mCurrentTime = currentTime;
 
      const unsigned int percentage = static_cast<unsigned int>(std::ceil(mCurrentTime / mTotalTime * 100));
 
      if (mSs.str().length() > 0) {
         printNewMessage("Message at time " + std::to_string(currentTime) + ": " + mSs.str());
         mSs.clear();
      }
 
      mOutStream << generateProgressBar(percentage, mCurrentTime) << "\r" << std::flush;
   }
 
   private:
   double mTotalTime;
   double mCurrentTime;
   bool mEnded;
   size_t mLengthOfLastPrintedMessage;
   std::stringstream mSs;
   std::streambuf* mCout;
   std::ostream mOutStream;
};
 
 
class CProgressBar : public SimObject
{
   public:
   CProgressBar(const std::string& name, ISimObjectCreator* const creator);
   void OdeFcn(const double t, const double* const x, double* const xdot, const bool isMajorTimeStep) { }
   void PreOdeFcn(const double T, const double* const X, IStateUpdater* updater);
   void FinalSetup(const double T, const double* const X, ISimObjectCreator* const creator);
#ifdef FH_VISUALIZATION
   virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator)
   { }
   virtual void RenderUpdate(const double T, const double* const X) { }
#endif
   protected:
   double m_end_time;
   ProgressBar* m_actualProgress;
   CPrintDuringExec* mPrint;
};
 
 
#endif /* PROGRESS_BAR_H */