progress-bar.hpp

 
#ifndef RUSH_PROGRESS_BAR_HPP
#define RUSH_PROGRESS_BAR_HPP
 
#include "rush/string.hpp"
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <sys/ioctl.h>
#include <unistd.h>
#include <utility>
 
namespace rush::progress {
 
struct Configuration {
  std::string name;                                 
  std::string complete{"="};                        
  std::string uncomplete{" "};                      
  std::array<std::string, 2> decorator{{"[", "]"}}; 
  bool percentage{true};                            
  double decimals{0};                               
};
 
class Bar {
private:
  int width_{0};
  double max_{0};
  double current_{0};
  Configuration config_;
 
  double update(double p) {
    p = std::clamp(p, 0.0, 1.0);
 
    std::string s = std::string("\033[0m") + config_.name;
    if(!config_.name.empty()) {
      s += " ";
    }
    s += config_.decorator[0];
    s += static_cast<rush::string>(config_.complete) * static_cast<int>(p * width_);
    s += static_cast<rush::string>(config_.uncomplete) * (width_ - static_cast<int>(p * width_));
    s += config_.decorator[1];
 
    if(config_.percentage) {
      s += " " + std::to_string(p * 100).substr(0, std::to_string(p * 100).find('.') + (config_.decimals > 0) + config_.decimals) + "%";
    }
 
    std::cout << "\u001b[1000D\033[31m\033[41m" << s << std::flush;
    return p;
  }
 
public:
  explicit Bar(const double max, Configuration cfg = Configuration()) : max_{max}, config_{std::move(cfg)} {
    struct winsize w{};
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    width_ = w.ws_col - config_.decorator.size() - config_.name.size() - config_.decimals - 7;
  }
 
  ~Bar() {
    std::cout << '\n';
  }
  double operator()(const double x) {
    return update((current_ = x) / max_);
  }
 
  double operator++() {
    return update(++current_ / max_);
  }
 
  double operator++(int) {
    return update(++current_ / max_);
  }
 
  double operator+=(const int n) {
    return update((current_ += n) / max_);
  }
 
  double operator--() {
    return update(--current_ / max_);
  }
 
  double operator--(int) {
    return update(--current_ / max_);
  }
 
  double operator-=(const int n) {
    return update((current_ -= n) / max_);
  }
};
 
} // namespace rush::progress
 
#endif // RUSH_PROGRESS_BAR_HPP