progress_bar.hpp

Go to the documentation of this file.

//====================================================
//     File data
//====================================================
//====================================================
//     Preprocessor settings
//====================================================
#pragma once
#ifndef OSMANIP_PROGRESSBAR_PROGRESSBAR_HPP
#define OSMANIP_PROGRESSBAR_PROGRESSBAR_HPP
 
//====================================================
//     Headers
//====================================================
 
// My headers
#include <osmanip/manipulators/colsty.hpp>
#include <osmanip/manipulators/common.hpp>
#include <osmanip/manipulators/cursor.hpp>
#include <osmanip/utility/generic.hpp>
#include <osmanip/utility/iostream.hpp>
 
// STD headers
#include <stdint.h>
 
#include <chrono>
#include <cmath>
#include <mutex>
#include <ratio>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace osm {
 
    //====================================================
    //     Aliases
    //====================================================
    using string_set_map = std::unordered_map<std::string, std::unordered_set<std::string>>;
    using steady_clock = std::chrono::steady_clock;
    using duration = std::chrono::duration<float, steady_clock::period>;
 
    //====================================================
    //     ProgressBar
    //====================================================
    template <typename bar_type>
    class ProgressBar {
        public:
 
            //====================================================
            //     Constructors and destructors
            //====================================================
 
            // Default constructor
            ProgressBar()
                : max_(0),
                  min_(0),
                  style_(""),
                  type_(""),
                  message_(""),
                  time_count_(duration::zero().count()),
                  brackets_open_(""),
                  brackets_close_(""),
                  begin_timer(steady_clock::now()),
                  color_(feat(rst, "color")),
                  color_name_(""),
                  ticks_occurred(0),
                  time_flag_("off") {}
 
            // Parametric constructor
            explicit ProgressBar(const bar_type &min, const bar_type &max)
                : max_(max),
                  min_(min),
                  style_(""),
                  type_(""),
                  message_(""),
                  time_count_(duration::zero().count()),
                  brackets_open_(""),
                  brackets_close_(""),
                  begin_timer(steady_clock::now()),
                  color_(feat(rst, "color")),
                  color_name_(""),
                  ticks_occurred(0),
                  time_flag_("off") {}
 
            //====================================================
            //     Setters
            //====================================================
 
            // setMax
            void setMax(bar_type max) { max_ = max; }
 
            // setMin
            void setMin(bar_type min) { min_ = min; }
 
            // setStyle first overload
            void setStyle(const std::string &type, const std::string &style) {
                try {
                    if (styles_map_.at(type).find(style) != styles_map_.at(type).end()) {
                        style_ = style;
                        type_ = type;
                    } else if (styles_map_.at(type).find(style) == styles_map_.at(type).end()) {
                        throw osm::except_error_func(
                            "Inserted "
                            "ProgressBar "
                            "style",
                            style,
                            "is not "
                            "supported for "
                            "this type!");
                    } else {
                        throw osm::except_error_func(
                            "Inserted "
                            "ProgressBar "
                            "type",
                            type,
                            "is not "
                            "supported!");
                    }
                } catch (std::out_of_range const &exception) {
                    throw osm::except_error_func(
                        "Inserted ProgressBar "
                        "type",
                        type, "is not supported!");
                }
            }
 
            // setStyle second overload
            void setStyle(const std::string &type, const std::string &style_p, const std::string &style_l) {
                if (styles_map_.at("indicator").find(style_p) != styles_map_.at("indicator").end() &&
                    styles_map_.at("loader").find(style_l) != styles_map_.at("loader").end() && type == "complete") {
                    style_ = style_p + style_l;
                    style_p_ = style_p;
                    style_l_ = style_l;
                    type_ = type;
                } else if (styles_map_.at("indicator").find(style_p) == styles_map_.at("indicator").end()) {
                    throw osm::except_error_func(
                        "Inserted indicator "
                        "style",
                        style_p,
                        "is not supported for "
                        "this type!");
                } else if (styles_map_.at("loader").find(style_l) == styles_map_.at("loader").end()) {
                    throw osm::except_error_func("Inserted loader style", style_l,
                                                 "is not supported for "
                                                 "this type!");
                } else {
                    throw osm::except_error_func(
                        "Inserted ProgressBar "
                        "type",
                        type, "is not supported!");
                }
            }
 
            // setMessage
            void setMessage(std::string_view message) { message_ = message; }
 
            // setBegin
            void setBegin() { begin = steady_clock::now(); }
 
            // setEnd
            void setEnd() {
                end = steady_clock::now();
                time_count_ += std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
            }
 
            // setBrackets
            void setBrackets(std::string_view brackets_open, std::string_view brackets_close) {
                brackets_open_ = brackets_open, brackets_close_ = brackets_close;
            }
 
            // setColor
            void setColor(const std::string &color) {
                color_ = feat(col, color);
                color_name_ = color;
            }
 
            // setRemainingTimeFlag
            void setRemainingTimeFlag(std::string_view time_flag) { time_flag_ = time_flag; }
 
            //====================================================
            //     Resetters
            //====================================================
 
            // resetAll
            void resetAll() {
                max_ = static_cast<bar_type>(0), min_ = static_cast<bar_type>(0), style_ = "", type_ = "",
                message_ = "", time_count_ = 0, ticks_occurred = 0, begin_timer = steady_clock::now(),
                brackets_open_ = "", brackets_close_ = "", color_ = feat(rst, "color");
                color_name_ = "";
                time_flag_ = "off";
            }
 
            // resetMax
            void resetMax() { max_ = static_cast<bar_type>(0); }
 
            // resetMin
            void resetMin() { min_ = static_cast<bar_type>(0); }
 
            // resetStyle
            void resetStyle() {
                style_.clear();
                type_.clear();
            }
 
            // resetMessage
            void resetMessage() { message_.clear(); }
 
            // resetTime
            void resetTime() { time_count_ = duration::zero().count(); }
 
            // resetRemainingTime
            void resetRemainingTime() {
                ticks_occurred = 0;
                begin_timer = steady_clock::now();
            }
 
            // resetBrackets
            void resetBrackets() { brackets_open_.clear(), brackets_close_.clear(); }
 
            // resetColor
            void resetColor() {
                color_ = feat(rst, "color");
                color_name_ = "";
            }
 
            //====================================================
            //     Getters
            //====================================================
 
            // getMax
            bar_type getMax() const { return max_; }
 
            // getMin
            bar_type getMin() const { return min_; }
 
            // getTime
            long long getTime() const { return time_count_; }
 
            // getIteratingVar
            bar_type getIteratingVar() const { return iterating_var_; }
 
            // getStyle
            std::string getStyle() const { return style_; }
 
            // getStyleComplete
            std::string getStyleComplete() const {
                if (type_ == "complete") {
                    return "Percentage: \"" + style_p_ + "\"\n" + "Loader: \"" + style_l_ + "\"\n";
                }
                return style_;
            }
 
            // getType
            std::string getType() const { return type_; }
 
            // getMessage
            std::string getMessage() const { return message_; }
 
            // getBrackets_open
            std::string getBrackets_open() const { return brackets_open_; }
 
            // getBrackets_close
            std::string getBrackets_close() const { return brackets_close_; }
 
            // getColor
            std::string getColor() const { return color_; }
 
            // getColorName
            std::string getColorName() const { return color_name_; }
 
            // getRemainingTimeFlag
            std::string getRemainingTimeFlag() const { return time_flag_; }
 
            //====================================================
            //     Other methods
            //====================================================
 
            // update
            void update(bar_type iterating_var) {
                std::lock_guard<std::mutex> lock{mutex_};
 
                iterating_var_ = 100 * (iterating_var - min_) / (max_ - min_ - osm::one(iterating_var)),
                iterating_var_spin_ =
                    osm::isFloatingPoint(iterating_var) ? (osm::roundoff(iterating_var, 1) * 10) : iterating_var,
                width_ = (iterating_var_ + 1) / 4;
 
                // Update of the progress indicator only:
                if (styles_map_.at("indicator").find(style_) != styles_map_.at("indicator").end()) {
                    output_ = feat(crs, "left", 100) + getColor() +
                              std::to_string(static_cast<int32_t>(round(iterating_var_++))) + feat(rst, "color") +
                              getStyle();
 
                    update_output(output_);
                }
 
                // Update of the loader indicator only:
                else if (styles_map_.at("loader").find(style_) != styles_map_.at("loader").end()) {
                    output_ =
                        feat(crs, "left", 100) + getBrackets_open() + getColor() + getStyle() * width_ +
                        osm::empty_space<std::string> * ((osm::isFloatingPoint(iterating_var) ? 26 : 25) - width_) +
                        feat(rst, "color") + getBrackets_close();
 
                    update_output(output_);
                }
 
                // Update of the whole progress bar:
                else if (style_.find(style_p_) != std::string::npos && style_.find(style_l_) != std::string::npos &&
                         type_ == "complete") {
                    output_ =
                        feat(crs, "left", 100) + getBrackets_open() + getColor() + style_l_ * width_ +
                        osm::empty_space<std::string> * ((osm::isFloatingPoint(iterating_var) ? 26 : 25) - width_) +
                        feat(rst, "color") + getBrackets_close() + getColor() + osm::empty_space<std::string> +
                        std::to_string(static_cast<int32_t>(round(iterating_var_++))) + feat(rst, "color") + style_p_;
 
                    update_output(output_);
                }
 
                // Update of the progress spinner:
                else if (styles_map_.at("spinner").find(style_) != styles_map_.at("spinner").end()) {
                    output_ = feat(crs, "left", 100) + getColor() +
                              getStyle()[static_cast<uint64_t>(iterating_var_spin_) & 3] + feat(col, "green") +
                              ((osm::roundoff(iterating_var, 1) == osm::roundoff(max_, 1) - osm::one(iterating_var))
                                   ? (static_cast<std::string>(feat(crs, "left", 100) + "0"))
                                   : "") +
                              feat(rst, "color");
 
                    update_output(output_);
                }
 
                else {
                    throw std::runtime_error(
                        "ProgressBar style has "
                        "not been set!");
                }
            }
 
            // print
            void print() const {
                osm::cout << "Max: " << max_ << "\n"
                          << "Min: " << min_ << "\n"
                          << "Time counter: " << time_count_ << "\n"
                          << "Style: " << style_ << "\n"
                          << "Type: " << type_ << "\n"
                          << "Message: " << message_ << "\n"
                          << "Brackets style: " << brackets_open_ << brackets_close_ << "\n"
                          << "Color: " << color_name_ << "\n"
                          << "Show remaining time: " << time_flag_ << "\n";
            }
 
            // addStyle
            void addStyle(const std::string &type, const std::string &style) { styles_map_.at(type).insert(style); }
 
        private:
 
            //====================================================
            //     Private methods
            //====================================================
 
            // remaining_time
            void remaining_time() {
                max_spin_ = osm::isFloatingPoint(max_) ? (osm::roundoff(max_ - min_, 1) * 10 + 1) : (max_ - min_ + 1);
 
                duration time_taken = steady_clock::now() - begin_timer;
                float percentage_done = static_cast<float>(ticks_occurred) / (max_spin_);
                duration time_left = time_taken * (1 / percentage_done - 1);
                std::chrono::minutes minutes_left = std::chrono::duration_cast<std::chrono::minutes>(time_left);
                std::chrono::seconds seconds_left =
                    std::chrono::duration_cast<std::chrono::seconds>(time_left - minutes_left);
 
                osm::cout << "["
                          << feat(sty, "italics") +
                                 "Estimated time "
                                 "left: " +
                                 feat(rst, "italics")
                          << feat(col, "green") << minutes_left.count() << feat(rst, "color") << "m "
                          << feat(col, "green") << seconds_left.count() << feat(rst, "color") << "s"
                          << "]" << feat(tcsc, "cln", 0);
            }
 
            // update_output
            void update_output(std::string_view output) {
                osm::cout << output << getColor()
                          << ((message_ != osm::null_str<std::string>)
                                  ? (osm::empty_space<std::string> + message_ + osm::empty_space<std::string>)
                                  : osm::empty_space<std::string>)
                          << feat(rst, "color");
 
                if (time_flag_ == "on") {
                    ticks_occurred++;
                    remaining_time();
                }
 
                osm::cout << std::flush;
            }
 
            //====================================================
            //     Private static attributes
            //====================================================
            static string_set_map styles_map_;
            static std::mutex mutex_;
 
            //====================================================
            //     Private attributes
            //====================================================
            long long time_count_;
            std::uint64_t ticks_occurred;
            bar_type max_, max_spin_, min_, iterating_var_, iterating_var_spin_, width_;
            std::string style_, style_p_, style_l_, type_, message_, brackets_open_, brackets_close_, output_, color_,
                time_flag_, color_name_;
            steady_clock::time_point begin, end, begin_timer;
    };
 
    //====================================================
    //     Operator << redefinition
    //====================================================
    template <typename bar_type>
    std::ostream &operator<<(std::ostream &os, const ProgressBar<bar_type> &pb) {
        os << "Max: " << pb.getMax() << "\n"
           << "Min: " << pb.getMin() << "\n"
           << "Time counter: " << pb.getTime() << "\n"
           << "Style: " << pb.getStyle() << "\n"
           << "Type: " << pb.getType() << "\n"
           << "Message: " << pb.getMessage() << "\n"
           << "Brackets style: " << pb.getBrackets_open() << pb.getBrackets_close() << "\n"
           << "Color: " << pb.getColorName() << "\n"
           << "Show remaining time: " << pb.getRemainingTimeFlag() << "\n";
 
        return os;
    }
 
    //====================================================
    //     Static attributes declaration
    //====================================================
    template <typename bar_type>
    string_set_map ProgressBar<bar_type>::styles_map_{
        {"indicator", {"%", "/100"}},
        {"loader", {"#", "■"}},
        {"spinner", {"/-\\|"}},
    };
 
    template <typename bar_type>
    std::mutex ProgressBar<bar_type>::mutex_;
}  // namespace osm
 
#endif