progress.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) NumeriCor GmbH
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _MT_PROGRESS_H
#define _MT_PROGRESS_H
 
#include <string>
 
template<class T>
class progress
{
  protected:
  T _num_next;        
  std::string _msg;   
 
  public:
  progress(T num_next, const char* msg) :
              _num_next(num_next),
              _msg(msg)
  {}
  virtual ~progress()
  {}
 
  virtual void next() = 0;
  virtual void increment(T inc) = 0;
  virtual void finish() = 0;
};
 
template<class T>
class progress_percent : public progress<T>
{
  private:
  T _counter;          
  T _threshold;        
  std::string _blank;  
 
  void display(T percentage)
  {
    const std::string & msg = progress<T>::_msg;
    
    printf("\r%s%s%d %c", msg.c_str(), _blank.c_str(), int(percentage), '%');
    fflush(stdout);
  }
 
  void evaluate()
  {
    const T & num_next = progress<T>::_num_next;
    T prog = T(float(_counter) / float(num_next) * 100.0f);
    
    if(prog > _threshold)
    {
      _threshold = prog;
      this->display(prog);
    }
  }
 
  public:
  progress_percent(T num_next, const char* msg, T start = 60) : 
                      progress<T>(num_next, msg),
                      _counter(0),
                      _threshold(0)
  {
    int size = start - progress<T>::_msg.size();
    if(size < 0) size = 0;
 
    _blank.assign(size, ' ');
    this->display(0);
  }
 
  void next()
  {
    _counter++;
    this->evaluate();
  }
 
  void increment(T inc)
  {
    _counter += inc;
    this->evaluate();
  }
 
  void finish()
  {
    this->display(100);
    printf("\n");
  }
};
 
 
template<class T>
class progress_bar : public progress<T>
{
  private:
  T _counter;     
  T _threshold;   
  
  const T _bar_len;       
  const char _bar_char;   
 
  std::string _bar;       
  std::string _blank_a;   
  std::string _blank_b;   
 
  void display(T nbars)
  {
    const std::string & msg = progress<T>::_msg;
    if(nbars > _bar_len) nbars = _bar_len;
 
    _bar.assign(nbars, _bar_char);
    _blank_b.assign(_bar_len - nbars, ' ');
 
    printf("\r%s%s[%s%s]", msg.c_str(), _blank_a.c_str(), _bar.c_str(), _blank_b.c_str());
    fflush(stdout);
  }
 
  void evaluate()
  {
    const T & num_next = progress<T>::_num_next;
    T prog = T(float(_counter) / float(num_next) * float(_bar_len));
    
    if(prog > _threshold)
    {
      _threshold = prog;
      this->display(prog);
    }
  }
 
  public:
  progress_bar(T num_next, const char* msg, T bar_start = 60, T bar_len = 20, char bar_char = '=') : 
                  progress<T>(num_next, msg),
                  _counter(0),
                  _threshold(0),
                  _bar_len(bar_len),
                  _bar_char(bar_char)
  {
    int size = bar_start - progress<T>::_msg.size();
    if(size < 0) size = 0;
 
    _blank_a.assign(size, ' ');
    this->display(0);
  }
 
  void next()
  {
    _counter++;
    this->evaluate();
  }
 
  void increment(T inc)
  {
    _counter += inc;
    this->evaluate();
  }
 
  void finish()
  {
    this->display(_bar_len);
    printf("\n");
  }
};
 
#endif