progress.hpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// openCARP is an open cardiac electrophysiology simulator.
//
// Copyright (C) 2020 openCARP project
//
// This program is licensed under the openCARP Academic Public License (APL)
// v1.0: You can use and redistribute it and/or modify it in non-commercial
// academic environments under the terms of APL as published by the openCARP
// project v1.0, or (at your option) any later version. Commercial use requires
// a commercial license (info@opencarp.org).
//
// This program is distributed without any warranty; see the openCARP APL for
// more details.
//
// You should have received a copy of the openCARP APL along with this program
// and can find it online: http://www.opencarp.org/license
// ----------------------------------------------------------------------------

#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