Merge pull request #32 from p-ranav/feature/dynamic-progress

Feature/dynamic progress

.appveyor.yml

@@ -0,0 +1,16 @@
+environment:
+  CONAN_RUN_TESTS: True
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      PATH: C:\\Python37;C:\\Python37\Scripts;C:\Users\appveyor\AppData\Roaming\Python\Python37\Scripts;%PATH%
+    # - APPVEYOR_BUILD_WORKER_IMAGE: Ubuntu
+    #   PATH: /home/appveyor/.local/bin:$PATH
+    # - APPVEYOR_BUILD_WORKER_IMAGE: macOS
+
+install:
+  - python --version
+  - python -m pip install conan --upgrade --user
+  - conan user
+
+build_script:
+  - conan create .

CMakeLists.txt

@@ -1,8 +1,21 @@
 cmake_minimum_required(VERSION 3.8)
-project(indicators VERSION 1.6.0 LANGUAGES CXX DESCRIPTION "Activity Indicators for Modern C++")
-option(INDICATORS_BUILD_TESTS OFF)
-option(SAMPLES "Build Samples" OFF)
-option(DEMO "Build Demo" OFF)
+
+if(DEFINED PROJECT_NAME)
+  set(INDICATORS_SUBPROJECT ON)
+endif()
+
+project(indicators VERSION 1.7.0 LANGUAGES CXX
+  HOMEPAGE_URL "https://github.com/p-ranav/indicators"
+  DESCRIPTION "Activity Indicators for Modern C++")
+
+if(EXISTS "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake")
+    include("${CMAKE_BINARY_DIR}/conanbuildinfo.cmake")
+    conan_basic_setup()
+endif()
+
+option(INDICATORS_BUILD_TESTS "Build indicators tests + enable CTest")
+option(INDICATORS_SAMPLES "Build indicators samples")
+option(INDICATORS_DEMO "Build indicators demo" OFF)
 
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
@@ -18,33 +31,68 @@ target_include_directories(indicators INTERFACE
   $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>)
 target_link_libraries(indicators INTERFACE Threads::Threads)
 
-
-if( DEMO )
-    add_subdirectory(demo)
+if(INDICATORS_DEMO)
+  add_subdirectory(demo)
 endif()
 
-if( SAMPLES )
-    add_subdirectory(samples)
+if(INDICATORS_SAMPLES)
+  add_subdirectory(samples)
 endif()
 
-configure_package_config_file(indicatorsConfig.cmake.in
-  ${CMAKE_CURRENT_BINARY_DIR}/indicatorsConfig.cmake
-  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/indicators)
+if(NOT INDICATORS_SUBPROJECT)
+  configure_package_config_file(indicatorsConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/indicatorsConfig.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/indicators)
+  write_basic_package_version_file(indicatorsConfigVersion.cmake
+                                   COMPATIBILITY AnyNewerVersion)
 
-configure_file(indicators.pc.in
-  "${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/indicators.pc"
-  @ONLY)
+  configure_file(indicators.pc.in indicators.pc @ONLY)
 
-install(TARGETS indicators EXPORT indicatorsTargets)
-install(EXPORT indicatorsTargets
-        FILE indicatorsTargets.cmake
-        NAMESPACE indicators::
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/indicators)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/indicatorsConfig.cmake
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/indicators)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/indicators.pc
-	DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig/)
-install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/include/indicators
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-        USE_SOURCE_PERMISSIONS
-        PATTERN "*.hpp")
+  install(TARGETS indicators EXPORT indicatorsTargets)
+  install(EXPORT indicatorsTargets
+          FILE indicatorsTargets.cmake
+          NAMESPACE indicators::
+          DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/indicators)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/indicatorsConfig.cmake
+                ${CMAKE_CURRENT_BINARY_DIR}/indicatorsConfigVersion.cmake
+          DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/indicators)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/indicators.pc
+          DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+  install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/include/indicators
+          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+          USE_SOURCE_PERMISSIONS
+          PATTERN "*.hpp")
+  install(FILES LICENSE LICENSE.termcolor
+          DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/licenses/indicators)
+
+  if(EXISTS "${PROJECT_SOURCE_DIR}/.gitignore")
+    # Simple glob to regex conversion (.gitignore => CPACK_SOURCE_IGNORE_FILES)
+    file(READ ".gitignore" DOT_GITIGNORE)
+    string(REPLACE ";" "RANDOMSEQUENCE" DOT_GITIGNORE "${DOT_GITIGNORE}")
+    string(REPLACE "\n" ";" DOT_GITIGNORE "${DOT_GITIGNORE}")
+    string(REPLACE "RANDOMSEQUENCE" "\\;" DOT_GITIGNORE "${DOT_GITIGNORE}")
+    foreach(IGNORE_LINE ${DOT_GITIGNORE})
+      if(NOT IGNORE_LINE OR IGNORE_LINE MATCHES "^#")
+        continue()
+      endif()
+      string(REPLACE "\\" "\\\\" IGNORE_LINE "${IGNORE_LINE}")
+      string(REPLACE "." "\\\\." IGNORE_LINE "${IGNORE_LINE}")
+      string(REPLACE "*" ".*" IGNORE_LINE "${IGNORE_LINE}")
+      string(REPLACE "+" "\\\\+" IGNORE_LINE "${IGNORE_LINE}")
+      list(APPEND CPACK_SOURCE_IGNORE_FILES "${IGNORE_LINE}")
+    endforeach()
+  endif()
+
+  # extra ignored files
+  list(APPEND CPACK_SOURCE_IGNORE_FILES
+    .editorconfig
+    .git
+    .gitignore
+    .travis.yml
+    .appveyor.yml
+  )
+  set(CPACK_SOURCE_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION}")
+  set(CPACK_GENERATOR "TGZ;TXZ")
+  set(CPACK_SOURCE_GENERATOR "TGZ;TXZ")
+  include(CPack)
+endif()

README.md

@@ -12,7 +12,7 @@
   <a href="https://github.com/p-ranav/indicators/blob/master/LICENSE">
     <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="license"/>
   </a>
-  <img src="https://img.shields.io/badge/version-1.6-blue.svg?cacheSeconds=2592000" alt="version"/>
+  <img src="https://img.shields.io/badge/version-1.7-blue.svg?cacheSeconds=2592000" alt="version"/>
 </p>
 
 <p align="center">
@@ -26,11 +26,20 @@
 * Source for the above GIF can be found [here](demo/demo.cpp)
 * MIT License
 
+```bash
+git clone https://github.com/p-ranav/indicators
+cd indicators
+mkdir build && cd build
+cmake -DINDICATORS_SAMPLES=ON -DINDICATORS_DEMO=ON ..
+make
+```
+
 # Table of Contents
 
 * [Progress Bar](#progress-bar)
 * [Block Progress Bar](#block-progress-bar)
 * [Multi Progress](#multiprogress)
+* [Dynamic Progress](#dynamicprogress)
 * [Progress Spinner](#progress-spinner)
 * [Contributing](#contributing)
 * [License](#license)
@@ -70,8 +79,8 @@ int main() {
     option::Lead{">"},
     option::Remainder{" "},
     option::End{"]"},
-    option::PostfixText{"Extracting Archive"};
-    option::ForegroundColor{Color::GREEN};
+    option::PostfixText{"Extracting Archive"},
+    option::ForegroundColor{Color::green}
   };
   
   // Update bar state
@@ -115,7 +124,7 @@ int main() {
     option::Remainder{"-"},
     option::End{" ]"},
     option::PostfixText{"Loading dependency 1/4"},
-    option::ForegroundColor{Color::CYAN}  
+    option::ForegroundColor{Color::cyan}  
   };
 
   // Update bar state
@@ -173,10 +182,10 @@ int main() {
     option::Lead{"█"},
     option::Remainder{"-"},
     option::End{"]"},
-    option::PrefixText{"Training Gaze Network "},
-    option::ForegroundColor{Color::YELLOW}
-    option::ShowElapsedTime{true};
-    option::ShowRemainingTime{true};
+    option::PrefixText{"Training Gaze Network 👀"},
+    option::ForegroundColor{Color::yellow},
+    option::ShowElapsedTime{true},
+    option::ShowRemainingTime{true}
   };
 
   // Update bar state
@@ -217,7 +226,7 @@ int main() {
     option::BarWidth{80},
     option::Start{"["},
     option::End{"]"},
-    option::ForegroundColor{Color::WHITE}  
+    option::ForegroundColor{Color::white}  
   };
   
   // Update bar state
@@ -263,7 +272,7 @@ int main() {
     option::Lead{"■"},
     option::Remainder{" "},
     option::End{" ]"},
-    option::ForegroundColor{Color::YELLOW},
+    option::ForegroundColor{Color::yellow},
     option::ShowElapsedTime{true},
     option::ShowRemainingTime{true},
     option::PrefixText{"Progress Bar #1 "}
@@ -271,14 +280,14 @@ int main() {
 
   // Configure second progress bar
 
-  ProgressBar bar1{
+  ProgressBar bar2{
     option::BarWidth{50},
     option::Start{"["},
     option::Fill{"="},
     option::Lead{">"},
     option::Remainder{" "},
     option::End{" ]"},
-    option::ForegroundColor{Color::CYAN},
+    option::ForegroundColor{Color::cyan},
     option::ShowElapsedTime{true},
     option::ShowRemainingTime{true},
     option::PrefixText{"Progress Bar #2 "}
@@ -292,7 +301,7 @@ int main() {
     option::Lead{"#"},
     option::Remainder{" "},
     option::End{" ]"},
-    option::ForegroundColor{Color::RED},
+    option::ForegroundColor{Color::red},
     option::ShowElapsedTime{true},
     option::ShowRemainingTime{true},
     option::PrefixText{"Progress Bar #3 "}
@@ -342,6 +351,159 @@ int main() {
 }
 ```
 
+# DynamicProgress
+
+`DynamicProgress` is a container class, similar to `MultiProgress`, for managing multiple progress bars. As the name suggests, with `DynamicProgress`, you can dynamically add new progress bars. Simply call `bars.push_back`. 
+
+Below is an example `DynamicProgress` object that manages six `ProgressBar` objects. Three of these bars are added dynamically.
+
+<p align="center">
+  <img src="img/dynamic_progress_bar.gif"/>  
+</p>
+
+```cpp
+#include <indicators/dynamic_progress.hpp>
+#include <indicators/progress_bar.hpp>
+using namespace indicators;
+
+int main() {
+
+  ProgressBar bar1{option::BarWidth{50}, option::ForegroundColor{Color::red},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"5c90d4a2d1a8: Downloading "}};
+
+  ProgressBar bar2{option::BarWidth{50}, option::ForegroundColor{Color::yellow},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"22337bfd13a9: Downloading "}};
+
+  ProgressBar bar3{option::BarWidth{50}, option::ForegroundColor{Color::green},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"10f26c680a34: Downloading "}};
+
+  ProgressBar bar4{option::BarWidth{50}, option::ForegroundColor{Color::white},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"6364e0d7a283: Downloading "}};
+
+  ProgressBar bar5{option::BarWidth{50}, option::ForegroundColor{Color::blue},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"ff1356ba118b: Downloading "}};
+
+  ProgressBar bar6{option::BarWidth{50}, option::ForegroundColor{Color::cyan},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"5a17453338b4: Downloading "}};
+
+  std::cout << termcolor::bold << termcolor::white << "Pulling image foo:bar/baz\n";
+
+  // Construct with 3 progress bars. We'll add 3 more at a later point
+  DynamicProgress<ProgressBar> bars(bar1, bar2, bar3);
+  
+  // Do not hide bars when completed
+  bars.set_option(option::HideBarWhenComplete{false});
+
+  std::thread fourth_job, fifth_job, sixth_job;
+
+  auto job4 = [&bars](size_t i) {
+    while (true) {
+      bars[i].tick();
+      if (bars[i].is_completed()) {
+        bars[i].set_option(option::PrefixText{"6364e0d7a283: Pull complete "});
+        bars[i].mark_as_completed();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+  };
+
+  auto job5 = [&bars](size_t i) {
+    while (true) {
+      bars[i].tick();
+      if (bars[i].is_completed()) {
+        bars[i].set_option(option::PrefixText{"ff1356ba118b: Pull complete "});
+        bars[i].mark_as_completed();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+  };
+
+  auto job6 = [&bars](size_t i) {
+    while (true) {
+      bars[i].tick();
+      if (bars[i].is_completed()) {
+        bars[i].set_option(option::PrefixText{"5a17453338b4: Pull complete "});
+        bars[i].mark_as_completed();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(40));
+    }
+  };
+
+  auto job1 = [&bars, &bar6, &sixth_job, &job6]() {
+    while (true) {
+      bars[0].tick();
+      if (bars[0].is_completed()) {
+        bars[0].set_option(option::PrefixText{"5c90d4a2d1a8: Pull complete "});
+        // bar1 is completed, adding bar6
+        auto i = bars.push_back(bar6);
+        sixth_job = std::thread(job6, i);
+        sixth_job.join();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(140));
+    }
+  };
+
+  auto job2 = [&bars, &bar5, &fifth_job, &job5]() {
+    while (true) {
+      bars[1].tick();
+      if (bars[1].is_completed()) {
+        bars[1].set_option(option::PrefixText{"22337bfd13a9: Pull complete "});
+        // bar2 is completed, adding bar5
+        auto i = bars.push_back(bar5);
+        fifth_job = std::thread(job5, i);
+        fifth_job.join();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(25));
+    }
+  };
+
+  auto job3 = [&bars, &bar4, &fourth_job, &job4]() {
+    while (true) {
+      bars[2].tick();
+      if (bars[2].is_completed()) {
+        bars[2].set_option(option::PrefixText{"10f26c680a34: Pull complete "});
+        // bar3 is completed, adding bar4
+        auto i = bars.push_back(bar4);
+        fourth_job = std::thread(job4, i);
+        fourth_job.join();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+  };
+
+  std::thread first_job(job1);
+  std::thread second_job(job2);
+  std::thread third_job(job3);
+
+  third_job.join();
+  second_job.join();
+  first_job.join();
+
+  std::cout << termcolor::bold << termcolor::green << "✔ Downloaded image foo/bar:baz" << std::endl;
+  std::cout << termcolor::reset;
+
+  return 0;
+}
+```
+
+In the above code, notice the option `bars.set_option(option::HideBarWhenComplete{true});`. Yes, you can hide progress bars as and when they complete by setting this option to `true`. If you do so, the above example will look like this:
+
+<p align="center">
+  <img src="img/dynamic_progress_bar_hide_completed.gif"/>  
+</p>
+
 # Progress Spinner
 
 To introduce a progress spinner in your application, include `indicators/progress_spinner.hpp` and create a `ProgressSpinner` object. Here's the general structure of a progress spinner:
@@ -363,7 +525,7 @@ int main() {
   using namespace indicators;
   indicators::ProgressSpinner spinner{
     option::PostfixText{"Checking credentials"},
-    option::ForegroundColor{Color::YELLOW},
+    option::ForegroundColor{Color::yellow},
     option::SpinnerStates{std::vector<std::string>{"⠈", "⠐", "⠠", "⢀", "⡀", "⠄", "⠂", "⠁"}}
   };
  
@@ -371,7 +533,7 @@ int main() {
   auto job = [&spinner]() {
     while (true) {
       if (spinner.is_completed()) {
-        spinner.set_option(option::ForegroundColor{Color::GREEN});
+        spinner.set_option(option::ForegroundColor{Color::green});
         spinner.set_option(option::PrefixText{"✔"});
         spinner.set_option(option::ShowSpinner{false});
         spinner.set_option(option::ShowPercentage{false});

clang-format.bash

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-find ./include ./demo/ ./samples/ -type f \( -iname \*.cpp -o -iname \*.hpp \) | xargs clang-format -style="{ColumnLimit : 100}" -i
+find ./include ./demo/ ./samples/ ./single_include -type f \( -iname \*.cpp -o -iname \*.hpp \) | xargs clang-format -style="{ColumnLimit : 100}" -i

conanfile.py

@@ -0,0 +1,78 @@
+from conans import CMake, ConanFile, tools
+from conans.errors import ConanException
+from contextlib import contextmanager
+import os
+
+
+class IndicatorsConan(ConanFile):
+    name = "indicators"
+    description = "Activity Indicators for Modern C++"
+    topics = ("indicators", "progress", "activity", "indicator", "header-only", "c++11")
+    homepage = "https://github.com/p-ranav/indicators"
+    url = "https://github.com/p-ranav/indicators"
+    license = ("MIT", "BSD-3-Clause")
+    exports_sources = "demo/**", "include/**", "samples/**", "CMakeLists.txt", "LICENSE*", \
+                      "indicators.pc.in", "indicatorsConfig.cmake.in", "README*", "img/**"
+    exports = "LICENSE"
+    no_copy_source = True
+    settings = "os", "arch", "compiler", "build_type"
+    generators = "cmake"
+
+    def set_version(self):
+        import re
+        m = re.search(r"project\(.*VERSION ([0-9a-zA-Z.-]+)[ )]",
+                      open(os.path.join(self.recipe_folder, "CMakeLists.txt")).read())
+        if not m:
+            raise ConanException("Could not extract version from CMakeLists.txt")
+        self.version = m.group(1)
+
+    _cmake = None
+
+    def _configure_cmake(self):
+        if self._cmake:
+            return self._cmake
+        generator = None
+        if self.settings.compiler == "Visual Studio":
+            generator = "NMake Makefiles"
+        self._cmake = CMake(self, generator=generator)
+        if tools.get_env("CONAN_RUN_TESTS", default=False):
+            self._cmake.definitions["INDICATORS_DEMO"] = True
+            self._cmake.definitions["INDICATORS_SAMPLES"] = True
+        self._cmake.configure()
+        return self._cmake
+
+    @property
+    def _test_programs(self):
+        programs = []
+        import re
+        for subdir in ("demo", "samples", ):
+            for match in re.finditer(r"add_executable\((\S+)",
+                                     open(os.path.join(self.source_folder, subdir, "CMakeLists.txt")).read()):
+                programs.append(os.path.join(self.build_folder, "bin", match.group(1)))
+        return programs
+
+    @contextmanager
+    def _build_context(self):
+        with tools.vcvars(self.settings) if self.settings.compiler == "Visual Studio" else tools.no_op():
+            yield
+
+    def build(self):
+        with self._build_context():
+            cmake = self._configure_cmake()
+            cmake.build()
+            cmake.build(target="package_source")
+            # if tools.get_env("CONAN_RUN_TESTS", default=False):
+            #     for program in self._test_programs:
+            #         self.output.info("Running program '{}'".format(program))
+            #         self.run(program, run_environment=True)
+
+    def package(self):
+        with self._build_context():
+            cmake = self._configure_cmake()
+            cmake.install()
+
+    def package_id(self):
+        self.info.header_only()
+
+    def package_info(self):
+        self.cpp_info.includedirs.append(os.path.join("include", "indicators"))

demo/demo.cpp

@@ -17,7 +17,7 @@ int main() {
                               option::Lead{"■"},
                               option::Remainder{" "},
                               option::End{" ]"},
-                              option::ForegroundColor{indicators::Color::YELLOW}};
+                              option::ForegroundColor{indicators::Color::yellow}};
 
     std::atomic<size_t> index{0};
     std::vector<std::string> status_text = {"Rocket.exe is not responding",
@@ -56,11 +56,12 @@ int main() {
     p.set_option(option::Lead{""});
     p.set_option(option::Remainder{""});
     p.set_option(option::End{""});
-    p.set_option(option::ForegroundColor{indicators::Color::WHITE});
+    p.set_option(option::ForegroundColor{indicators::Color::white});
     p.set_option(option::ShowPercentage{false});
     auto job = [&p]() {
       while (true) {
-        p.set_option(option::PrefixText{"Reading package list... " + std::to_string(p.current()) + "% "});
+        p.set_option(
+            option::PrefixText{"Reading package list... " + std::to_string(p.current()) + "% "});
         if (p.current() + 2 >= 100)
           p.set_option(option::PrefixText{"Reading package list... Done"});
         p.tick();
@@ -86,7 +87,7 @@ int main() {
     p.set_option(option::Remainder{" "});
     p.set_option(option::End{"]"});
     p.set_option(option::PostfixText{"Getting started"});
-    p.set_option(option::ForegroundColor{indicators::Color::GREEN});
+    p.set_option(option::ForegroundColor{indicators::Color::green});
     auto job = [&p]() {
       while (true) {
         auto ticks = p.current();
@@ -120,7 +121,7 @@ int main() {
     p4.set_option(option::Lead{""});
     p4.set_option(option::Remainder{" "});
     p4.set_option(option::End{""});
-    p4.set_option(option::ForegroundColor{indicators::Color::CYAN});
+    p4.set_option(option::ForegroundColor{indicators::Color::cyan});
     p4.set_option(option::PostfixText{"Restoring system state"});
     p4.set_option(option::ShowPercentage{false});
     std::atomic<size_t> index4{0};
@@ -131,7 +132,7 @@ int main() {
         index4 += 1;
         if (p4.current() + 2 >= 100) {
           std::cout << std::endl;
-          p4.set_option(option::ForegroundColor{indicators::Color::RED});
+          p4.set_option(option::ForegroundColor{indicators::Color::red});
           p4.set_option(option::PrefixText{"{ ERROR }"});
           p4.set_option(option::Start{});
           p4.set_option(option::Fill{});
@@ -155,16 +156,14 @@ int main() {
       //
       // GOING BACKWARDS
       //
-      indicators::ProgressBar p{
-          option::BarWidth {50},
-          option::Start{"["},
-          option::Fill{"■"},
-          option::Lead{"■"},
-          option::Remainder{"-"},
-          option::End{"]"},
-          option::ForegroundColor{indicators::Color::WHITE},
-          option::PostfixText{"Reverting system restore"}
-      };
+      indicators::ProgressBar p{option::BarWidth{50},
+                                option::Start{"["},
+                                option::Fill{"■"},
+                                option::Lead{"■"},
+                                option::Remainder{"-"},
+                                option::End{"]"},
+                                option::ForegroundColor{indicators::Color::white},
+                                option::PostfixText{"Reverting system restore"}};
       p.set_progress(100); // TODO backwards as an option?
       std::atomic<size_t> progress{100};
       auto job = [&p, &progress]() {
@@ -189,16 +188,14 @@ int main() {
     // PROGRESS BAR 5
     //
     indicators::ProgressSpinner p{
-      option::PrefixText{""},
-      option::PostfixText{"Checking credentials"},
-      option::ForegroundColor{indicators::Color::YELLOW},
-      option::SpinnerStates{std::vector<std::string>{"⠈", "⠐", "⠠", "⢀", "⡀", "⠄", "⠂", "⠁"}}
-    };
+        option::PrefixText{""}, option::PostfixText{"Checking credentials"},
+        option::ForegroundColor{indicators::Color::yellow},
+        option::SpinnerStates{std::vector<std::string>{"⠈", "⠐", "⠠", "⢀", "⡀", "⠄", "⠂", "⠁"}}};
 
     auto job = [&p]() {
       while (true) {
         if (p.is_completed()) {
-          p.set_option(option::ForegroundColor{indicators::Color::GREEN});
+          p.set_option(option::ForegroundColor{indicators::Color::green});
           p.set_option(option::PrefixText{"✔"});
           p.set_option(option::ShowSpinner{false});
           p.set_option(option::ShowPercentage{false});
@@ -220,12 +217,9 @@ int main() {
     // PROGRESS BAR 6
     //
     indicators::ProgressSpinner p{
-      option::PrefixText{" - "},
-      option::PostfixText{"Searching for the Moon"},
-      option::ForegroundColor{indicators::Color::WHITE},
-      option::ShowPercentage{false},
-      option::SpinnerStates{std::vector<std::string>{"▖", "▘", "▝", "▗"}}
-    };
+        option::PrefixText{" - "}, option::PostfixText{"Searching for the Moon"},
+        option::ForegroundColor{indicators::Color::white}, option::ShowPercentage{false},
+        option::SpinnerStates{std::vector<std::string>{"▖", "▘", "▝", "▗"}}};
     auto job = [&p]() {
       while (true) {
         auto current = p.current();
@@ -261,17 +255,15 @@ int main() {
           //
           // NESTED PROGRESS BAR
           //
-          indicators::ProgressBar p2{
-              option::BarWidth{30},
-              option::PrefixText{" - "},
-              option::Start{"🌎"},
-              option::Fill{"·"},
-              option::Lead{"🚀"},
-              option::Remainder{" "},
-              option::End{"🌑"},
-              option::PostfixText{"Achieved low-Earth orbit"},
-              option::ForegroundColor{indicators::Color::WHITE}
-          };
+          indicators::ProgressBar p2{option::BarWidth{30},
+                                     option::PrefixText{" - "},
+                                     option::Start{"🌎"},
+                                     option::Fill{"·"},
+                                     option::Lead{"🚀"},
+                                     option::Remainder{" "},
+                                     option::End{"🌑"},
+                                     option::PostfixText{"Achieved low-Earth orbit"},
+                                     option::ForegroundColor{indicators::Color::white}};
           std::vector<std::string> ship_trail{"⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"};
           std::atomic<int> ship_trail_index{0};
           auto job2 = [&p2, &ship_trail_index, &ship_trail]() {

include/indicators/block_progress_bar.hpp

@@ -29,164 +29,177 @@ SOFTWARE.
 #include <indicators/color.hpp>
 #include <indicators/details/stream_helper.hpp>
 
-#define NOMINMAX
 #include <algorithm>
 #include <atomic>
 #include <chrono>
+#include <indicators/setting.hpp>
 #include <iomanip>
 #include <iostream>
 #include <mutex>
 #include <string>
-#include <tuple>
 #include <thread>
-#include "setting.hpp"
+#include <tuple>
 
 namespace indicators {
 
 class BlockProgressBar {
-  using Settings = std::tuple<
-      option::ForegroundColor,
-      option::BarWidth,
-      option::Start,
-      option::End,
-      option::PrefixText,
-      option::PostfixText,
-      option::ShowPercentage,
-      option::ShowElapsedTime,
-      option::ShowRemainingTime,
-      option::Completed,
-      option::SavedStartTime,
-      option::MaxPostfixTextLen>;
+  using Settings = std::tuple<option::ForegroundColor, option::BarWidth, option::Start, option::End,
+                              option::PrefixText, option::PostfixText, option::ShowPercentage,
+                              option::ShowElapsedTime, option::ShowRemainingTime, option::Completed,
+                              option::SavedStartTime, option::MaxPostfixTextLen>;
+
 public:
-  template <typename... Args, typename std::enable_if<details::are_settings_from_tuple<Settings, typename std::decay<Args>::type...>::value, void*>::type = nullptr>
-  explicit BlockProgressBar(Args&&... args) : settings_(
-      details::get<details::ProgressBarOption::foreground_color>(option::ForegroundColor{Color::WHITE}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::bar_width>(option::BarWidth{100}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::start>(option::Start{"["}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::end>(option::End{"]"}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::prefix_text>(option::PrefixText{""}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::postfix_text>(option::PostfixText{""}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::show_percentage>(option::ShowPercentage{true}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::show_elapsed_time>(option::ShowElapsedTime{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::show_remaining_time>(option::ShowRemainingTime{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::completed>(option::Completed{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::saved_start_time>(option::SavedStartTime{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::max_postfix_text_len>(option::MaxPostfixTextLen{0}, std::forward<Args>(args)...)
-      ) {}
+  template <typename... Args,
+            typename std::enable_if<details::are_settings_from_tuple<
+                                        Settings, typename std::decay<Args>::type...>::value,
+                                    void *>::type = nullptr>
+  explicit BlockProgressBar(Args &&... args)
+      : settings_(details::get<details::ProgressBarOption::foreground_color>(
+                      option::ForegroundColor{Color::white}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::bar_width>(option::BarWidth{100},
+                                                                      std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::start>(option::Start{"["},
+                                                                  std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::end>(option::End{"]"},
+                                                                std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::prefix_text>(
+                      option::PrefixText{""}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::postfix_text>(
+                      option::PostfixText{""}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_percentage>(
+                      option::ShowPercentage{true}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_elapsed_time>(
+                      option::ShowElapsedTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_remaining_time>(
+                      option::ShowRemainingTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::completed>(option::Completed{false},
+                                                                      std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::saved_start_time>(
+                      option::SavedStartTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::max_postfix_text_len>(
+                      option::MaxPostfixTextLen{0}, std::forward<Args>(args)...)) {}
 
   template <typename T, details::ProgressBarOption id>
-  void set_option(details::Setting<T, id>&& setting){
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(std::declval<Settings>()))>::type>::value, "Setting has wrong type!");
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(details::Setting<T, id> &&setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = std::move(setting).value;
   }
 
   template <typename T, details::ProgressBarOption id>
-  void set_option(const details::Setting<T, id>& setting){
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(std::declval<Settings>()))>::type>::value, "Setting has wrong type!");
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(const details::Setting<T, id> &setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = setting.value;
   }
 
-  void set_option(const details::Setting<std::string, details::ProgressBarOption::postfix_text>& setting){
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(
+      const details::Setting<std::string, details::ProgressBarOption::postfix_text> &setting) {
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<details::ProgressBarOption::postfix_text>() = setting.value;
-    if(setting.value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()){
+    if (setting.value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
       get_value<details::ProgressBarOption::max_postfix_text_len>() = setting.value.length();
     }
   }
 
-  void set_option(details::Setting<std::string, details::ProgressBarOption::postfix_text>&& setting){
-    std::lock_guard<std::mutex> lock(_mutex);
+  void
+  set_option(details::Setting<std::string, details::ProgressBarOption::postfix_text> &&setting) {
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<details::ProgressBarOption::postfix_text>() = std::move(setting).value;
-    auto& new_value = get_value<details::ProgressBarOption::postfix_text>();
-    if(new_value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()){
+    auto &new_value = get_value<details::ProgressBarOption::postfix_text>();
+    if (new_value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
       get_value<details::ProgressBarOption::max_postfix_text_len>() = new_value.length();
     }
   }
 
   void set_progress(float value) {
     {
-      std::lock_guard<std::mutex> lock{_mutex};
-      _progress = value;
+      std::lock_guard<std::mutex> lock{mutex_};
+      progress_ = value;
     }
-    _save_start_time();
-    _print_progress();
+    save_start_time();
+    print_progress();
   }
 
   void tick() {
     {
-      std::lock_guard<std::mutex> lock{_mutex};
-      _progress += 1;
+      std::lock_guard<std::mutex> lock{mutex_};
+      progress_ += 1;
     }
-    _save_start_time();
-    _print_progress();
+    save_start_time();
+    print_progress();
   }
 
   size_t current() {
-    std::lock_guard<std::mutex> lock{_mutex};
-    return std::min(static_cast<size_t>(_progress), size_t(100));
+    std::lock_guard<std::mutex> lock{mutex_};
+    return std::min(static_cast<size_t>(progress_), size_t(100));
   }
 
   bool is_completed() const { return get_value<details::ProgressBarOption::completed>(); }
 
   void mark_as_completed() {
     get_value<details::ProgressBarOption::completed>() = true;
-    _print_progress();
+    print_progress();
   }
 
 private:
-
   template <details::ProgressBarOption id>
-  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings&>()).value)) {
+  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
   template <details::ProgressBarOption id>
-  auto get_value() const -> decltype((details::get_value<id>(std::declval<const Settings&>()).value)) {
+  auto get_value() const
+      -> decltype((details::get_value<id>(std::declval<const Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
   Settings settings_;
-  float _progress{0.0};
-  std::chrono::time_point<std::chrono::high_resolution_clock> _start_time_point;
-  std::mutex _mutex;
+  float progress_{0.0};
+  std::chrono::time_point<std::chrono::high_resolution_clock> start_time_point_;
+  std::mutex mutex_;
 
   template <typename Indicator, size_t count> friend class MultiProgress;
-  std::atomic<bool> _multi_progress_mode{false};
+  template <typename Indicator> friend class DynamicProgress;
+  std::atomic<bool> multi_progress_mode_{false};
 
-  void _save_start_time() {
-    auto& show_elapsed_time = get_value<details::ProgressBarOption::show_elapsed_time>();
-    auto& saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
-    auto& show_remaining_time = get_value<details::ProgressBarOption::show_remaining_time>();
+  void save_start_time() {
+    auto &show_elapsed_time = get_value<details::ProgressBarOption::show_elapsed_time>();
+    auto &saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
+    auto &show_remaining_time = get_value<details::ProgressBarOption::show_remaining_time>();
     if ((show_elapsed_time || show_remaining_time) && !saved_start_time) {
-      _start_time_point = std::chrono::high_resolution_clock::now();
+      start_time_point_ = std::chrono::high_resolution_clock::now();
       saved_start_time = true;
     }
   }
 
-  void _print_progress(bool from_multi_progress = false) {
-    if (_multi_progress_mode && !from_multi_progress) {
-      if (_progress > 100.0) {
+  void print_progress(bool from_multi_progress = false) {
+    if (multi_progress_mode_ && !from_multi_progress) {
+      if (progress_ > 100.0) {
         get_value<details::ProgressBarOption::completed>() = true;
       }
       return;
     }
-    std::lock_guard<std::mutex> lock{_mutex};
+    std::lock_guard<std::mutex> lock{mutex_};
     auto now = std::chrono::high_resolution_clock::now();
-    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(now - _start_time_point);
+    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_point_);
 
     std::cout << termcolor::bold;
     details::set_stream_color(std::cout, get_value<details::ProgressBarOption::foreground_color>());
     std::cout << get_value<details::ProgressBarOption::prefix_text>();
     std::cout << get_value<details::ProgressBarOption::start>();
 
-    details::BlockProgressScaleWriter writer{std::cout, get_value<details::ProgressBarOption::bar_width>()};
-    writer.write(_progress);
+    details::BlockProgressScaleWriter writer{std::cout,
+                                             get_value<details::ProgressBarOption::bar_width>()};
+    writer.write(progress_);
 
     std::cout << get_value<details::ProgressBarOption::end>();
     if (get_value<details::ProgressBarOption::show_percentage>()) {
-      std::cout << " " << std::min(static_cast<size_t>(_progress), size_t(100)) << "%";
+      std::cout << " " << std::min(static_cast<size_t>(progress_), size_t(100)) << "%";
     }
 
     if (get_value<details::ProgressBarOption::show_elapsed_time>()) {
@@ -200,7 +213,7 @@ private:
       else
         std::cout << " [";
       auto eta = std::chrono::nanoseconds(
-          _progress > 0 ? static_cast<long long>(elapsed.count() * 100 / _progress) : 0);
+          progress_ > 0 ? static_cast<long long>(elapsed.count() * 100 / progress_) : 0);
       auto remaining = eta > elapsed ? (eta - elapsed) : (elapsed - eta);
       details::write_duration(std::cout, remaining);
       std::cout << "]";
@@ -211,12 +224,15 @@ private:
 
     if (get_value<details::ProgressBarOption::max_postfix_text_len>() == 0)
       get_value<details::ProgressBarOption::max_postfix_text_len>() = 10;
-    std::cout << " " << get_value<details::ProgressBarOption::postfix_text>() << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ') << "\r";
+    std::cout << " " << get_value<details::ProgressBarOption::postfix_text>()
+              << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ')
+              << "\r";
     std::cout.flush();
-    if (_progress > 100.0) {
+    if (progress_ > 100.0) {
       get_value<details::ProgressBarOption::completed>() = true;
     }
-    if (get_value<details::ProgressBarOption::completed>() && !from_multi_progress) // Don't std::endl if calling from MultiProgress
+    if (get_value<details::ProgressBarOption::completed>() &&
+        !from_multi_progress) // Don't std::endl if calling from MultiProgress
       std::cout << termcolor::reset << std::endl;
   }
 };

include/indicators/color.hpp

@@ -28,5 +28,5 @@ SOFTWARE.
 #include <indicators/termcolor.hpp>
 
 namespace indicators {
-enum class Color { GREY, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
+enum class Color { grey, red, green, yellow, blue, magenta, cyan, white };
 }

include/indicators/details/stream_helper.hpp

@@ -17,123 +17,111 @@ namespace indicators {
 namespace details {
 
 inline void set_stream_color(std::ostream &os, Color color) {
-    switch (color) {
-        case Color::GREY:
-            os << termcolor::grey;
-            break;
-        case Color::RED:
-            os << termcolor::red;
-            break;
-        case Color::GREEN:
-            os << termcolor::green;
-            break;
-        case Color::YELLOW:
-            os << termcolor::yellow;
-            break;
-        case Color::BLUE:
-            os << termcolor::blue;
-            break;
-        case Color::MAGENTA:
-            os << termcolor::magenta;
-            break;
-        case Color::CYAN:
-            os << termcolor::cyan;
-            break;
-        case Color::WHITE:
-            os << termcolor::white;
-            break;
-        default:
-            assert(false);
-    }
+  switch (color) {
+  case Color::grey:
+    os << termcolor::grey;
+    break;
+  case Color::red:
+    os << termcolor::red;
+    break;
+  case Color::green:
+    os << termcolor::green;
+    break;
+  case Color::yellow:
+    os << termcolor::yellow;
+    break;
+  case Color::blue:
+    os << termcolor::blue;
+    break;
+  case Color::magenta:
+    os << termcolor::magenta;
+    break;
+  case Color::cyan:
+    os << termcolor::cyan;
+    break;
+  case Color::white:
+    os << termcolor::white;
+    break;
+  default:
+    assert(false);
+  }
 }
 
 inline std::ostream &write_duration(std::ostream &os, std::chrono::nanoseconds ns) {
-    using namespace std;
-    using namespace std::chrono;
-    using days = duration<int, ratio<86400>>;
-    char fill = os.fill();
-    os.fill('0');
-    auto d = duration_cast<days>(ns);
-    ns -= d;
-    auto h = duration_cast<hours>(ns);
-    ns -= h;
-    auto m = duration_cast<minutes>(ns);
-    ns -= m;
-    auto s = duration_cast<seconds>(ns);
-    if (d.count() > 0)
-        os << setw(2) << d.count() << "d:";
-    if (h.count() > 0)
-        os << setw(2) << h.count() << "h:";
-    os << setw(2) << m.count() << "m:" << setw(2) << s.count() << 's';
-    os.fill(fill);
+  using namespace std;
+  using namespace std::chrono;
+  using days = duration<int, ratio<86400>>;
+  char fill = os.fill();
+  os.fill('0');
+  auto d = duration_cast<days>(ns);
+  ns -= d;
+  auto h = duration_cast<hours>(ns);
+  ns -= h;
+  auto m = duration_cast<minutes>(ns);
+  ns -= m;
+  auto s = duration_cast<seconds>(ns);
+  if (d.count() > 0)
+    os << setw(2) << d.count() << "d:";
+  if (h.count() > 0)
+    os << setw(2) << h.count() << "h:";
+  os << setw(2) << m.count() << "m:" << setw(2) << s.count() << 's';
+  os.fill(fill);
+  return os;
+}
+
+class BlockProgressScaleWriter {
+public:
+  BlockProgressScaleWriter(std::ostream &os, size_t bar_width) : os(os), bar_width(bar_width) {}
+
+  std::ostream &write(float progress) {
+    std::string fill_text{"█"};
+    std::vector<std::string> lead_characters{" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉"};
+    auto value = std::min(1.0f, std::max(0.0f, progress / 100.0f));
+    auto whole_width = std::floor(value * bar_width);
+    auto remainder_width = fmod((value * bar_width), 1.0f);
+    auto part_width = std::floor(remainder_width * lead_characters.size());
+    std::string lead_text = lead_characters[size_t(part_width)];
+    if ((bar_width - whole_width - 1) < 0)
+      lead_text = "";
+    for (size_t i = 0; i < whole_width; ++i)
+      os << fill_text;
+    os << lead_text;
+    for (size_t i = 0; i < (bar_width - whole_width - 1); ++i)
+      os << " ";
     return os;
-}
-
-class BlockProgressScaleWriter
-{
-public:
-    BlockProgressScaleWriter(std::ostream& os, size_t bar_width)
-        : os(os)
-        , bar_width(bar_width)
-    {}
-
-    std::ostream &write(float progress) {
-        std::string fill_text{"█"};
-        std::vector<std::string> lead_characters{" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉"};
-        auto value = std::min(1.0f, std::max(0.0f, progress / 100.0f));
-        auto whole_width = std::floor(value * bar_width);
-        auto remainder_width = fmod((value * bar_width), 1.0f);
-        auto part_width = std::floor(remainder_width * lead_characters.size());
-        std::string lead_text = lead_characters[size_t(part_width)];
-        if ((bar_width - whole_width - 1) < 0)
-        lead_text = "";
-        for (size_t i = 0; i < whole_width; ++i)
-        os << fill_text;
-        os << lead_text;
-        for (size_t i = 0; i < (bar_width - whole_width - 1); ++i)
-        os << " ";
-        return os;
-    }
-private:
-    std::ostream& os;
-    size_t bar_width = 0;
-};
-
-class ProgressScaleWriter
-{
-public:
-    ProgressScaleWriter(std::ostream& os,
-                        size_t bar_width,
-                        const std::string& fill,
-                        const std::string& lead,
-                        const std::string& remainder)
-        : os(os)
-        , bar_width(bar_width)
-        , fill(fill)
-        , lead(lead)
-        , remainder(remainder)
-        {}
-
-    std::ostream &write(float progress) {
-        auto pos = static_cast<size_t>(progress * static_cast<float>(bar_width) / 100.0);
-        for (size_t i = 0; i < bar_width; ++i) {
-        if (i < pos)
-            os << fill;
-        else if (i == pos)
-            os << lead;
-        else
-            os << remainder;
-        }
-        return os;
-    }
+  }
 
 private:
-    std::ostream& os;
-    size_t bar_width = 0;
-    std::string fill;
-    std::string lead;
-    std::string remainder;
+  std::ostream &os;
+  size_t bar_width = 0;
 };
 
-}
-}
+class ProgressScaleWriter {
+public:
+  ProgressScaleWriter(std::ostream &os, size_t bar_width, const std::string &fill,
+                      const std::string &lead, const std::string &remainder)
+      : os(os), bar_width(bar_width), fill(fill), lead(lead), remainder(remainder) {}
+
+  std::ostream &write(float progress) {
+    auto pos = static_cast<size_t>(progress * static_cast<float>(bar_width) / 100.0);
+    for (size_t i = 0; i < bar_width; ++i) {
+      if (i < pos)
+        os << fill;
+      else if (i == pos)
+        os << lead;
+      else
+        os << remainder;
+    }
+    return os;
+  }
+
+private:
+  std::ostream &os;
+  size_t bar_width = 0;
+  std::string fill;
+  std::string lead;
+  std::string remainder;
+};
+
+} // namespace details
+} // namespace indicators

include/indicators/dynamic_progress.hpp

@@ -0,0 +1,138 @@
+/*
+Activity Indicators for Modern C++
+https://github.com/p-ranav/indicators
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2019 Pranav Srinivas Kumar <pranav.srinivas.kumar@gmail.com>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#pragma once
+#include <atomic>
+#include <functional>
+#include <indicators/color.hpp>
+#include <indicators/setting.hpp>
+#include <iostream>
+#include <mutex>
+#include <vector>
+
+namespace indicators {
+
+template <typename Indicator> class DynamicProgress {
+  using Settings = std::tuple<option::HideBarWhenComplete>;
+
+public:
+  template <typename... Indicators> explicit DynamicProgress(Indicators &... bars) {
+    bars_ = {bars...};
+    for (auto &bar : bars_) {
+      bar.get().multi_progress_mode_ = true;
+      ++total_count_;
+      ++incomplete_count_;
+    }
+  }
+
+  Indicator &operator[](size_t index) {
+    print_progress();
+    std::lock_guard<std::mutex> lock{mutex_};
+    return bars_[index].get();
+  }
+
+  size_t push_back(Indicator &bar) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    bar.multi_progress_mode_ = true;
+    bars_.push_back(bar);
+    return bars_.size() - 1;
+  }
+
+  template <typename T, details::ProgressBarOption id>
+  void set_option(details::Setting<T, id> &&setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
+    get_value<id>() = std::move(setting).value;
+  }
+
+  template <typename T, details::ProgressBarOption id>
+  void set_option(const details::Setting<T, id> &setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
+    get_value<id>() = setting.value;
+  }
+
+private:
+  Settings settings_;
+  std::atomic<bool> started_{false};
+  std::mutex mutex_;
+  std::vector<std::reference_wrapper<Indicator>> bars_;
+  std::atomic<size_t> total_count_{0};
+  std::atomic<size_t> incomplete_count_{0};
+
+  template <details::ProgressBarOption id>
+  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings &>()).value)) {
+    return details::get_value<id>(settings_).value;
+  }
+
+  template <details::ProgressBarOption id>
+  auto get_value() const
+      -> decltype((details::get_value<id>(std::declval<const Settings &>()).value)) {
+    return details::get_value<id>(settings_).value;
+  }
+
+  void print_progress() {
+    std::lock_guard<std::mutex> lock{mutex_};
+    auto &hide_bar_when_complete = get_value<details::ProgressBarOption::hide_bar_when_complete>();
+    if (hide_bar_when_complete) {
+      // Hide completed bars
+      if (started_) {
+        for (size_t i = 0; i < incomplete_count_; ++i)
+          std::cout << "\033[A\r\033[K" << std::flush;
+      }
+      incomplete_count_ = 0;
+      for (auto &bar : bars_) {
+        if (!bar.get().is_completed()) {
+          bar.get().print_progress(true);
+          std::cout << "\n";
+          ++incomplete_count_;
+        }
+      }
+      if (!started_)
+        started_ = true;
+    } else {
+      // Don't hide any bars
+      if (started_) {
+        for (size_t i = 0; i < total_count_; ++i)
+          std::cout << "\x1b[A";
+      }
+      for (auto &bar: bars_) {
+        bar.get().print_progress(true);
+        std::cout << "\n";
+      }
+      if (!started_)
+        started_ = true;
+    }
+    total_count_ = bars_.size();
+    std::cout << termcolor::reset;
+  }
+};
+
+} // namespace indicators

include/indicators/multi_progress.hpp

@@ -39,55 +39,55 @@ public:
   template <typename... Indicators,
             typename = typename std::enable_if<(sizeof...(Indicators) == count)>::type>
   explicit MultiProgress(Indicators &... bars) {
-    _bars = {bars...};
-    for (auto &bar : _bars) {
-      bar.get()._multi_progress_mode = true;
+    bars_ = {bars...};
+    for (auto &bar : bars_) {
+      bar.get().multi_progress_mode_ = true;
     }
   }
 
   template <size_t index>
   typename std::enable_if<(index >= 0 && index < count), void>::type set_progress(float value) {
-    if (!_bars[index].get().is_completed())
-      _bars[index].get().set_progress(value);
-    _print_progress();
+    if (!bars_[index].get().is_completed())
+      bars_[index].get().set_progress(value);
+    print_progress();
   }
 
   template <size_t index>
   typename std::enable_if<(index >= 0 && index < count), void>::type tick() {
-    if (!_bars[index].get().is_completed())
-      _bars[index].get().tick();
-    _print_progress();
+    if (!bars_[index].get().is_completed())
+      bars_[index].get().tick();
+    print_progress();
   }
 
   template <size_t index>
   typename std::enable_if<(index >= 0 && index < count), bool>::type is_completed() const {
-    return _bars[index].get().is_completed();
+    return bars_[index].get().is_completed();
   }
 
 private:
-  std::atomic<bool> _started{false};
-  std::mutex _mutex;
-  std::vector<std::reference_wrapper<Indicator>> _bars;
+  std::atomic<bool> started_{false};
+  std::mutex mutex_;
+  std::vector<std::reference_wrapper<Indicator>> bars_;
 
   bool _all_completed() {
     bool result{true};
     for (size_t i = 0; i < count; ++i)
-      result &= _bars[i].get().is_completed();
+      result &= bars_[i].get().is_completed();
     return result;
   }
 
-  void _print_progress() {
-    std::lock_guard<std::mutex> lock{_mutex};
-    if (_started)
+  void print_progress() {
+    std::lock_guard<std::mutex> lock{mutex_};
+    if (started_)
       for (size_t i = 0; i < count; ++i)
         std::cout << "\x1b[A";
-    for (auto &bar : _bars) {
-      bar.get()._print_progress(true);
+    for (auto &bar : bars_) {
+      bar.get().print_progress(true);
       std::cout << "\n";
     }
     std::cout << termcolor::reset;
-    if (!_started)
-      _started = true;
+    if (!started_)
+      started_ = true;
   }
 };
 

include/indicators/progress_bar.hpp

@@ -28,14 +28,12 @@ SOFTWARE.
 
 #include <indicators/details/stream_helper.hpp>
 
-#define NOMINMAX
 #include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <cmath>
 #include <indicators/color.hpp>
 #include <indicators/setting.hpp>
-#include <tuple>
 #include <iomanip>
 #include <iostream>
 #include <mutex>
@@ -47,149 +45,161 @@ SOFTWARE.
 namespace indicators {
 
 class ProgressBar {
-  using Settings = std::tuple<
-      option::BarWidth,
-      option::PrefixText,
-      option::PostfixText,
-      option::Start,
-      option::End,
-      option::Fill,
-      option::Lead,
-      option::Remainder,
-      option::MaxPostfixTextLen,
-      option::Completed,
-      option::ShowPercentage,
-      option::ShowElapsedTime,
-      option::ShowRemainingTime,
-      option::SavedStartTime,
-      option::ForegroundColor
-  >;
+  using Settings =
+      std::tuple<option::BarWidth, option::PrefixText, option::PostfixText, option::Start,
+                 option::End, option::Fill, option::Lead, option::Remainder,
+                 option::MaxPostfixTextLen, option::Completed, option::ShowPercentage,
+                 option::ShowElapsedTime, option::ShowRemainingTime, option::SavedStartTime,
+                 option::ForegroundColor>;
+
 public:
-  template <typename... Args, typename std::enable_if<details::are_settings_from_tuple<Settings, typename std::decay<Args>::type...>::value, void*>::type = nullptr>
-  explicit ProgressBar(Args&&... args) :
-    settings_(
-        details::get<details::ProgressBarOption::bar_width>(option::BarWidth{100}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::prefix_text>(option::PrefixText{}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::postfix_text>(option::PostfixText{}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::start>(option::Start{"["}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::end>(option::End{"]"}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::fill>(option::Fill{"="}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::lead>(option::Lead{">"}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::remainder>(option::Remainder{" "}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::max_postfix_text_len>(option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::completed>(option::Completed{false}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::show_percentage>(option::ShowPercentage{false} ,std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::show_elapsed_time>(option::ShowElapsedTime{false}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::show_remaining_time>(option::ShowRemainingTime{false}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::saved_start_time>(option::SavedStartTime{false}, std::forward<Args>(args)...),
-        details::get<details::ProgressBarOption::foreground_color>(option::ForegroundColor{Color::WHITE}, std::forward<Args>(args)...)
-    )
-  {}
+  template <typename... Args,
+            typename std::enable_if<details::are_settings_from_tuple<
+                                        Settings, typename std::decay<Args>::type...>::value,
+                                    void *>::type = nullptr>
+  explicit ProgressBar(Args &&... args)
+      : settings_(details::get<details::ProgressBarOption::bar_width>(option::BarWidth{100},
+                                                                      std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::prefix_text>(
+                      option::PrefixText{}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::postfix_text>(
+                      option::PostfixText{}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::start>(option::Start{"["},
+                                                                  std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::end>(option::End{"]"},
+                                                                std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::fill>(option::Fill{"="},
+                                                                 std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::lead>(option::Lead{">"},
+                                                                 std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::remainder>(option::Remainder{" "},
+                                                                      std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::max_postfix_text_len>(
+                      option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::completed>(option::Completed{false},
+                                                                      std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_percentage>(
+                      option::ShowPercentage{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_elapsed_time>(
+                      option::ShowElapsedTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_remaining_time>(
+                      option::ShowRemainingTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::saved_start_time>(
+                      option::SavedStartTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::foreground_color>(
+                      option::ForegroundColor{Color::white}, std::forward<Args>(args)...)) {}
 
   template <typename T, details::ProgressBarOption id>
-  void set_option(details::Setting<T, id>&& setting){
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(std::declval<Settings>()))>::type>::value, "Setting has wrong type!");
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(details::Setting<T, id> &&setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = std::move(setting).value;
   }
 
   template <typename T, details::ProgressBarOption id>
-  void set_option(const details::Setting<T, id>& setting){
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(std::declval<Settings>()))>::type>::value, "Setting has wrong type!");
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(const details::Setting<T, id> &setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = setting.value;
   }
 
-  void set_option(const details::Setting<std::string, details::ProgressBarOption::postfix_text>& setting){
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(
+      const details::Setting<std::string, details::ProgressBarOption::postfix_text> &setting) {
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<details::ProgressBarOption::postfix_text>() = setting.value;
-    if(setting.value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()){
+    if (setting.value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
       get_value<details::ProgressBarOption::max_postfix_text_len>() = setting.value.length();
     }
   }
 
-  void set_option(details::Setting<std::string, details::ProgressBarOption::postfix_text>&& setting){
-    std::lock_guard<std::mutex> lock(_mutex);
+  void
+  set_option(details::Setting<std::string, details::ProgressBarOption::postfix_text> &&setting) {
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<details::ProgressBarOption::postfix_text>() = std::move(setting).value;
-    auto& new_value = get_value<details::ProgressBarOption::postfix_text>();
-    if(new_value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()){
+    auto &new_value = get_value<details::ProgressBarOption::postfix_text>();
+    if (new_value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
       get_value<details::ProgressBarOption::max_postfix_text_len>() = new_value.length();
     }
   }
 
-  void set_progress(float newProgress){
+  void set_progress(float new_progress) {
     {
-      std::lock_guard<std::mutex> lck(_mutex);
-      _progress = newProgress;
+      std::lock_guard<std::mutex> lck(mutex_);
+      progress_ = new_progress;
     }
 
-    _save_start_time();
-    _print_progress();
+    save_start_time();
+    print_progress();
   }
 
   void tick() {
     {
-      std::lock_guard<std::mutex> lock{_mutex};
-      _progress += 1;
+      std::lock_guard<std::mutex> lock{mutex_};
+      progress_ += 1;
     }
-    _save_start_time();
-    _print_progress();
+    save_start_time();
+    print_progress();
   }
 
   size_t current() {
-    std::lock_guard<std::mutex> lock{_mutex};
-    return std::min(static_cast<size_t>(_progress), size_t(100));
+    std::lock_guard<std::mutex> lock{mutex_};
+    return std::min(static_cast<size_t>(progress_), size_t(100));
   }
 
   bool is_completed() const { return get_value<details::ProgressBarOption::completed>(); }
 
   void mark_as_completed() {
     get_value<details::ProgressBarOption::completed>() = true;
-    _print_progress();
+    print_progress();
   }
 
 private:
-
   template <details::ProgressBarOption id>
-  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings&>()).value)) {
+  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
   template <details::ProgressBarOption id>
-  auto get_value() const -> decltype((details::get_value<id>(std::declval<const Settings&>()).value)) {
+  auto get_value() const
+      -> decltype((details::get_value<id>(std::declval<const Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
-  float _progress{0};
+  float progress_{0};
   Settings settings_;
-  std::chrono::nanoseconds _elapsed;
-  std::chrono::time_point<std::chrono::high_resolution_clock> _start_time_point;
-  std::mutex _mutex;
+  std::chrono::nanoseconds elapsed_;
+  std::chrono::time_point<std::chrono::high_resolution_clock> start_time_point_;
+  std::mutex mutex_;
 
   template <typename Indicator, size_t count> friend class MultiProgress;
-  std::atomic<bool> _multi_progress_mode{false};
+  template <typename Indicator> friend class DynamicProgress;
+  std::atomic<bool> multi_progress_mode_{false};
 
-  void _save_start_time() {
-    auto& show_elapsed_time = get_value<details::ProgressBarOption::show_elapsed_time>();
-    auto& saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
-    auto& show_remaining_time = get_value<details::ProgressBarOption::show_remaining_time>();
+  void save_start_time() {
+    auto &show_elapsed_time = get_value<details::ProgressBarOption::show_elapsed_time>();
+    auto &saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
+    auto &show_remaining_time = get_value<details::ProgressBarOption::show_remaining_time>();
     if ((show_elapsed_time || show_remaining_time) && !saved_start_time) {
-      _start_time_point = std::chrono::high_resolution_clock::now();
+      start_time_point_ = std::chrono::high_resolution_clock::now();
       saved_start_time = true;
     }
   }
 
-  void _print_progress(bool from_multi_progress = false) {
-    if (_multi_progress_mode && !from_multi_progress) {
-      if (_progress > 100.0) {
+  void print_progress(bool from_multi_progress = false) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    if (multi_progress_mode_ && !from_multi_progress) {
+      if (progress_ > 100.0) {
         get_value<details::ProgressBarOption::completed>() = true;
       }
       return;
     }
-    std::lock_guard<std::mutex> lock{_mutex};
     auto now = std::chrono::high_resolution_clock::now();
     if (!get_value<details::ProgressBarOption::completed>())
-      _elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(now - _start_time_point);
+      elapsed_ = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_point_);
 
     std::cout << termcolor::bold;
     details::set_stream_color(std::cout, get_value<details::ProgressBarOption::foreground_color>());
@@ -197,21 +207,22 @@ private:
 
     std::cout << get_value<details::ProgressBarOption::start>();
 
-    details::ProgressScaleWriter writer{std::cout, get_value<details::ProgressBarOption::bar_width>(),
+    details::ProgressScaleWriter writer{std::cout,
+                                        get_value<details::ProgressBarOption::bar_width>(),
                                         get_value<details::ProgressBarOption::fill>(),
                                         get_value<details::ProgressBarOption::lead>(),
                                         get_value<details::ProgressBarOption::remainder>()};
-    writer.write(_progress);
+    writer.write(progress_);
 
     std::cout << get_value<details::ProgressBarOption::end>();
 
     if (get_value<details::ProgressBarOption::show_percentage>()) {
-      std::cout << " " << std::min(static_cast<size_t>(_progress), size_t(100)) << "%";
+      std::cout << " " << std::min(static_cast<size_t>(progress_), size_t(100)) << "%";
     }
 
     if (get_value<details::ProgressBarOption::show_elapsed_time>()) {
       std::cout << " [";
-      details::write_duration(std::cout, _elapsed);
+      details::write_duration(std::cout, elapsed_);
     }
 
     if (get_value<details::ProgressBarOption::show_remaining_time>()) {
@@ -220,8 +231,8 @@ private:
       else
         std::cout << " [";
       auto eta = std::chrono::nanoseconds(
-          _progress > 0 ? static_cast<long long>(_elapsed.count() * 100 / _progress) : 0);
-      auto remaining = eta > _elapsed ? (eta - _elapsed) : (_elapsed - eta);
+          progress_ > 0 ? static_cast<long long>(elapsed_.count() * 100 / progress_) : 0);
+      auto remaining = eta > elapsed_ ? (eta - elapsed_) : (elapsed_ - eta);
       details::write_duration(std::cout, remaining);
       std::cout << "]";
     } else {
@@ -231,12 +242,15 @@ private:
 
     if (get_value<details::ProgressBarOption::max_postfix_text_len>() == 0)
       get_value<details::ProgressBarOption::max_postfix_text_len>() = 10;
-    std::cout << " " << get_value<details::ProgressBarOption::postfix_text>() << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ') << "\r";
+    std::cout << " " << get_value<details::ProgressBarOption::postfix_text>()
+              << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ')
+              << "\r";
     std::cout.flush();
-    if (_progress > 100.0) {
+    if (progress_ > 100.0) {
       get_value<details::ProgressBarOption::completed>() = true;
     }
-    if (get_value<details::ProgressBarOption::completed>() && !from_multi_progress) // Don't std::endl if calling from MultiProgress
+    if (get_value<details::ProgressBarOption::completed>() &&
+        !from_multi_progress) // Don't std::endl if calling from MultiProgress
       std::cout << termcolor::reset << std::endl;
   }
 };

include/indicators/progress_spinner.hpp

@@ -28,7 +28,6 @@ SOFTWARE.
 
 #include <indicators/details/stream_helper.hpp>
 
-#define NOMINMAX
 #include <algorithm>
 #include <atomic>
 #include <chrono>
@@ -39,142 +38,158 @@ SOFTWARE.
 #include <iostream>
 #include <mutex>
 #include <string>
-#include <tuple>
 #include <thread>
+#include <tuple>
 #include <vector>
 
 namespace indicators {
 
 class ProgressSpinner {
-  using Settings = std::tuple<
-      option::ForegroundColor,
-      option::PrefixText,
-      option::PostfixText,
-      option::ShowPercentage,
-      option::ShowElapsedTime,
-      option::ShowRemainingTime,
-      option::ShowSpinner,
-      option::SavedStartTime,
-      option::Completed,
-      option::MaxPostfixTextLen,
-      option::SpinnerStates
-      >;
+  using Settings =
+      std::tuple<option::ForegroundColor, option::PrefixText, option::PostfixText,
+                 option::ShowPercentage, option::ShowElapsedTime, option::ShowRemainingTime,
+                 option::ShowSpinner, option::SavedStartTime, option::Completed,
+                 option::MaxPostfixTextLen, option::SpinnerStates>;
+
 public:
-  template <typename... Args, typename std::enable_if<details::are_settings_from_tuple<Settings, typename std::decay<Args>::type...>::value, void*>::type = nullptr>
-  explicit ProgressSpinner(Args&&... args) : settings_(
-      details::get<details::ProgressBarOption::foreground_color>(option::ForegroundColor{Color::WHITE}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::prefix_text>(option::PrefixText{}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::postfix_text>(option::PostfixText{}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::show_percentage>(option::ShowPercentage{true}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::show_elapsed_time>(option::ShowElapsedTime{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::show_remaining_time>(option::ShowRemainingTime{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::spinner_show>(option::ShowSpinner{true}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::saved_start_time>(option::SavedStartTime{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::completed>(option::Completed{false}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::max_postfix_text_len>(option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
-      details::get<details::ProgressBarOption::spinner_states>(option::SpinnerStates{std::vector<std::string>{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}}, std::forward<Args>(args)...)
-      ){}
+  template <typename... Args,
+            typename std::enable_if<details::are_settings_from_tuple<
+                                        Settings, typename std::decay<Args>::type...>::value,
+                                    void *>::type = nullptr>
+  explicit ProgressSpinner(Args &&... args)
+      : settings_(details::get<details::ProgressBarOption::foreground_color>(
+                      option::ForegroundColor{Color::white}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::prefix_text>(
+                      option::PrefixText{}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::postfix_text>(
+                      option::PostfixText{}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_percentage>(
+                      option::ShowPercentage{true}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_elapsed_time>(
+                      option::ShowElapsedTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::show_remaining_time>(
+                      option::ShowRemainingTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::spinner_show>(
+                      option::ShowSpinner{true}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::saved_start_time>(
+                      option::SavedStartTime{false}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::completed>(option::Completed{false},
+                                                                      std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::max_postfix_text_len>(
+                      option::MaxPostfixTextLen{0}, std::forward<Args>(args)...),
+                  details::get<details::ProgressBarOption::spinner_states>(
+                      option::SpinnerStates{std::vector<std::string>{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴",
+                                                                     "⠦", "⠧", "⠇", "⠏"}},
+                      std::forward<Args>(args)...)) {}
 
   template <typename T, details::ProgressBarOption id>
-  void set_option(details::Setting<T, id>&& setting){
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(std::declval<Settings>()))>::type>::value, "Setting has wrong type!");
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(details::Setting<T, id> &&setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = std::move(setting).value;
   }
 
   template <typename T, details::ProgressBarOption id>
-  void set_option(const details::Setting<T, id>& setting){
-    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(std::declval<Settings>()))>::type>::value, "Setting has wrong type!");
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(const details::Setting<T, id> &setting) {
+    static_assert(!std::is_same<T, typename std::decay<decltype(details::get_value<id>(
+                                       std::declval<Settings>()))>::type>::value,
+                  "Setting has wrong type!");
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<id>() = setting.value;
   }
 
-  void set_option(const details::Setting<std::string, details::ProgressBarOption::postfix_text>& setting){
-    std::lock_guard<std::mutex> lock(_mutex);
+  void set_option(
+      const details::Setting<std::string, details::ProgressBarOption::postfix_text> &setting) {
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<details::ProgressBarOption::postfix_text>() = setting.value;
-    if(setting.value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()){
+    if (setting.value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
       get_value<details::ProgressBarOption::max_postfix_text_len>() = setting.value.length();
     }
   }
 
-  void set_option(details::Setting<std::string, details::ProgressBarOption::postfix_text>&& setting){
-    std::lock_guard<std::mutex> lock(_mutex);
+  void
+  set_option(details::Setting<std::string, details::ProgressBarOption::postfix_text> &&setting) {
+    std::lock_guard<std::mutex> lock(mutex_);
     get_value<details::ProgressBarOption::postfix_text>() = std::move(setting).value;
-    auto& new_value = get_value<details::ProgressBarOption::postfix_text>();
-    if(new_value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()){
+    auto &new_value = get_value<details::ProgressBarOption::postfix_text>();
+    if (new_value.length() > get_value<details::ProgressBarOption::max_postfix_text_len>()) {
       get_value<details::ProgressBarOption::max_postfix_text_len>() = new_value.length();
     }
   }
 
   void set_progress(float value) {
     {
-      std::lock_guard<std::mutex> lock{_mutex};
-      _progress = value;
+      std::lock_guard<std::mutex> lock{mutex_};
+      progress_ = value;
     }
-    _save_start_time();
-    _print_progress();
+    save_start_time();
+    print_progress();
   }
 
   void tick() {
     {
-      std::lock_guard<std::mutex> lock{_mutex};
-      _progress += 1;
+      std::lock_guard<std::mutex> lock{mutex_};
+      progress_ += 1;
     }
-    _save_start_time();
-    _print_progress();
+    save_start_time();
+    print_progress();
   }
 
   size_t current() {
-    std::lock_guard<std::mutex> lock{_mutex};
-    return std::min(static_cast<size_t>(_progress), size_t(100));
+    std::lock_guard<std::mutex> lock{mutex_};
+    return std::min(static_cast<size_t>(progress_), size_t(100));
   }
 
   bool is_completed() const { return get_value<details::ProgressBarOption::completed>(); }
 
   void mark_as_completed() {
     get_value<details::ProgressBarOption::completed>() = true;
-    _print_progress();
+    print_progress();
   }
 
 private:
   Settings settings_;
-  float _progress{0.0};
-  size_t _index{0};
-  std::chrono::time_point<std::chrono::high_resolution_clock> _start_time_point;
-  std::mutex _mutex;
+  float progress_{0.0};
+  size_t index_{0};
+  std::chrono::time_point<std::chrono::high_resolution_clock> start_time_point_;
+  std::mutex mutex_;
 
   template <details::ProgressBarOption id>
-  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings&>()).value)) {
+  auto get_value() -> decltype((details::get_value<id>(std::declval<Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
   template <details::ProgressBarOption id>
-  auto get_value() const -> decltype((details::get_value<id>(std::declval<const Settings&>()).value)) {
+  auto get_value() const
+      -> decltype((details::get_value<id>(std::declval<const Settings &>()).value)) {
     return details::get_value<id>(settings_).value;
   }
 
-  void _save_start_time() {
-    auto& show_elapsed_time = get_value<details::ProgressBarOption::show_elapsed_time>();
-    auto& show_remaining_time = get_value<details::ProgressBarOption::show_remaining_time>();
-    auto& saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
+  void save_start_time() {
+    auto &show_elapsed_time = get_value<details::ProgressBarOption::show_elapsed_time>();
+    auto &show_remaining_time = get_value<details::ProgressBarOption::show_remaining_time>();
+    auto &saved_start_time = get_value<details::ProgressBarOption::saved_start_time>();
     if ((show_elapsed_time || show_remaining_time) && !saved_start_time) {
-      _start_time_point = std::chrono::high_resolution_clock::now();
+      start_time_point_ = std::chrono::high_resolution_clock::now();
       saved_start_time = true;
     }
   }
 
-  void _print_progress() {
-    std::lock_guard<std::mutex> lock{_mutex};
+  void print_progress() {
+    std::lock_guard<std::mutex> lock{mutex_};
     auto now = std::chrono::high_resolution_clock::now();
-    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(now - _start_time_point);
+    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_point_);
 
     std::cout << termcolor::bold;
     details::set_stream_color(std::cout, get_value<details::ProgressBarOption::foreground_color>());
     std::cout << get_value<details::ProgressBarOption::prefix_text>();
     if (get_value<details::ProgressBarOption::spinner_show>())
-      std::cout << get_value<details::ProgressBarOption::spinner_states>()[_index % get_value<details::ProgressBarOption::spinner_states>().size()];
+      std::cout << get_value<details::ProgressBarOption::spinner_states>()
+              [index_ % get_value<details::ProgressBarOption::spinner_states>().size()];
     if (get_value<details::ProgressBarOption::show_percentage>()) {
-      std::cout << " " << std::min(static_cast<size_t>(_progress), size_t(100)) << "%";
+      std::cout << " " << std::min(static_cast<size_t>(progress_), size_t(100)) << "%";
     }
 
     if (get_value<details::ProgressBarOption::show_elapsed_time>()) {
@@ -188,7 +203,7 @@ private:
       else
         std::cout << " [";
       auto eta = std::chrono::nanoseconds(
-          _progress > 0 ? static_cast<long long>(elapsed.count() * 100 / _progress) : 0);
+          progress_ > 0 ? static_cast<long long>(elapsed.count() * 100 / progress_) : 0);
       auto remaining = eta > elapsed ? (eta - elapsed) : (elapsed - eta);
       details::write_duration(std::cout, remaining);
       std::cout << "]";
@@ -199,10 +214,12 @@ private:
 
     if (get_value<details::ProgressBarOption::max_postfix_text_len>() == 0)
       get_value<details::ProgressBarOption::max_postfix_text_len>() = 10;
-    std::cout << " " << get_value<details::ProgressBarOption::postfix_text>() << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ') << "\r";
+    std::cout << " " << get_value<details::ProgressBarOption::postfix_text>()
+              << std::string(get_value<details::ProgressBarOption::max_postfix_text_len>(), ' ')
+              << "\r";
     std::cout.flush();
-    _index += 1;
-    if (_progress > 100.0) {
+    index_ += 1;
+    if (progress_ > 100.0) {
       get_value<details::ProgressBarOption::completed>() = true;
     }
     if (get_value<details::ProgressBarOption::completed>())

include/indicators/setting.hpp

@@ -32,57 +32,44 @@ SOFTWARE.
 #include <type_traits>
 #include <utility>
 
+namespace indicators {
 
-namespace indicators{
+namespace details {
 
-namespace details{
+template <bool condition> struct if_else;
 
-template <bool condition>
-struct if_else;
+template <> struct if_else<true> { using type = std::true_type; };
 
-template<>
-struct if_else<true>{
-  using type = std::true_type;
-};
+template <> struct if_else<false> { using type = std::false_type; };
 
-template<>
-struct if_else<false>{
-  using type = std::false_type ;
-};
+template <bool condition, typename True, typename False> struct if_else_type;
 
-template <bool condition, typename True, typename False>
-struct if_else_type;
-
-template <typename True, typename False>
-struct if_else_type<true, True, False>{
+template <typename True, typename False> struct if_else_type<true, True, False> {
   using type = True;
 };
 
-template <typename True, typename False>
-struct if_else_type<false, True, False>{
+template <typename True, typename False> struct if_else_type<false, True, False> {
   using type = False;
 };
 
-template <typename... Ops>
-struct conjuction;
+template <typename... Ops> struct conjuction;
 
-template <>
-struct conjuction<> : std::true_type {};
+template <> struct conjuction<> : std::true_type {};
 
 template <typename Op, typename... TailOps>
-struct conjuction<Op, TailOps...> : if_else_type<!Op::value, std::false_type, conjuction<TailOps...>>::type {};
+struct conjuction<Op, TailOps...>
+    : if_else_type<!Op::value, std::false_type, conjuction<TailOps...>>::type {};
 
-template <typename... Ops>
-struct disjunction;
+template <typename... Ops> struct disjunction;
 
-template <>
-struct disjunction<> : std::false_type {};
+template <> struct disjunction<> : std::false_type {};
 
 template <typename Op, typename... TailOps>
-struct disjunction<Op, TailOps...> : if_else_type<Op::value, std::true_type, disjunction<TailOps...>>::type {};
+struct disjunction<Op, TailOps...>
+    : if_else_type<Op::value, std::true_type, disjunction<TailOps...>>::type {};
 
-enum class ProgressBarOption{
-  bar_width=0,
+enum class ProgressBarOption {
+  bar_width = 0,
   prefix_text,
   postfix_text,
   start,
@@ -98,15 +85,16 @@ enum class ProgressBarOption{
   saved_start_time,
   foreground_color,
   spinner_show,
-  spinner_states
+  spinner_states,
+  hide_bar_when_complete
 };
 
-template <typename T, ProgressBarOption Id>
-struct Setting{
-  template <typename... Args, typename = typename std::enable_if<std::is_constructible<T, Args...>::value>::type>
-  explicit Setting(Args&&... args) : value(std::forward<Args>(args)...){}
-  Setting(const Setting&) = default;
-  Setting(Setting&&) = default;
+template <typename T, ProgressBarOption Id> struct Setting {
+  template <typename... Args,
+            typename = typename std::enable_if<std::is_constructible<T, Args...>::value>::type>
+  explicit Setting(Args &&... args) : value(std::forward<Args>(args)...) {}
+  Setting(const Setting &) = default;
+  Setting(Setting &&) = default;
 
   static constexpr auto id = Id;
   using type = T;
@@ -114,109 +102,102 @@ struct Setting{
   T value{};
 };
 
-template <typename T>
-struct is_setting : std::false_type{};
+template <typename T> struct is_setting : std::false_type {};
 
-template <ProgressBarOption Id, typename T>
-struct is_setting<Setting<T, Id>> : std::true_type{};
+template <ProgressBarOption Id, typename T> struct is_setting<Setting<T, Id>> : std::true_type {};
 
 template <typename... Args>
 struct are_settings : if_else<conjuction<is_setting<Args>...>::value>::type {};
 
-template <>
-struct are_settings<> : std::true_type{};
+template <> struct are_settings<> : std::true_type {};
 
-template<typename Setting, typename Tuple>
-struct is_setting_from_tuple;
+template <typename Setting, typename Tuple> struct is_setting_from_tuple;
 
-template<typename Setting>
-struct is_setting_from_tuple<Setting, std::tuple<>> : std::true_type {};
+template <typename Setting> struct is_setting_from_tuple<Setting, std::tuple<>> : std::true_type {};
 
 template <typename Setting, typename... TupleTypes>
-struct is_setting_from_tuple<Setting, std::tuple<TupleTypes...>> :
-    if_else<disjunction<std::is_same<Setting, TupleTypes>...>::value>::type {};
+struct is_setting_from_tuple<Setting, std::tuple<TupleTypes...>>
+    : if_else<disjunction<std::is_same<Setting, TupleTypes>...>::value>::type {};
 
 template <typename Tuple, typename... Settings>
-struct are_settings_from_tuple : if_else<conjuction<is_setting_from_tuple<Settings, Tuple>...>::value>::type {};
+struct are_settings_from_tuple
+    : if_else<conjuction<is_setting_from_tuple<Settings, Tuple>...>::value>::type {};
 
+template <ProgressBarOption Id> struct always_true { static constexpr auto value = true; };
 
-template <ProgressBarOption Id>
-struct always_true{
-  static constexpr auto value = true;
-};
-
-template<ProgressBarOption Id, typename Default>
-Default&& get_impl(Default&& def){
+template <ProgressBarOption Id, typename Default> Default &&get_impl(Default &&def) {
   return std::forward<Default>(def);
 }
 
 template <ProgressBarOption Id, typename Default, typename T, typename... Args>
-auto get_impl(Default&& def, T&& first, Args&&... tail) -> typename std::enable_if<
-                                                (std::decay<T>::type::id == Id),
-                                                decltype(std::forward<T>(first))>
-                                                ::type{
-    return std::forward<T>(first);
+auto get_impl(Default &&def, T &&first, Args &&... tail) ->
+    typename std::enable_if<(std::decay<T>::type::id == Id),
+                            decltype(std::forward<T>(first))>::type {
+  return std::forward<T>(first);
 }
 
 template <ProgressBarOption Id, typename Default, typename T, typename... Args>
-auto get_impl(Default&& def, T&& first, Args&&... tail) -> typename std::enable_if<
-    (std::decay<T>::type::id != Id),
-    decltype(get_impl<Id>(std::forward<Default>(def), std::forward<Args>(tail)...))>::type{
+auto get_impl(Default &&def, T &&first, Args &&... tail) ->
+    typename std::enable_if<(std::decay<T>::type::id != Id),
+                            decltype(get_impl<Id>(std::forward<Default>(def),
+                                                  std::forward<Args>(tail)...))>::type {
   return get_impl<Id>(std::forward<Default>(def), std::forward<Args>(tail)...);
 }
 
-template <ProgressBarOption Id, typename Default,  typename... Args, typename = typename std::enable_if<are_settings<Args...>::value, void>::type>
-auto get(Default&& def, Args&&... args) -> decltype(details::get_impl<Id>(std::forward<Default>(def), std::forward<Args>(args)...)){
+template <ProgressBarOption Id, typename Default, typename... Args,
+          typename = typename std::enable_if<are_settings<Args...>::value, void>::type>
+auto get(Default &&def, Args &&... args)
+    -> decltype(details::get_impl<Id>(std::forward<Default>(def), std::forward<Args>(args)...)) {
   return details::get_impl<Id>(std::forward<Default>(def), std::forward<Args>(args)...);
 }
 
-template <ProgressBarOption Id>
-using StringSetting = Setting<std::string, Id>;
+template <ProgressBarOption Id> using StringSetting = Setting<std::string, Id>;
 
-template <ProgressBarOption Id>
-using IntegerSetting = Setting<std::size_t, Id>;
+template <ProgressBarOption Id> using IntegerSetting = Setting<std::size_t, Id>;
 
-template <ProgressBarOption Id>
-using BooleanSetting = Setting<bool, Id>;
+template <ProgressBarOption Id> using BooleanSetting = Setting<bool, Id>;
 
-template <ProgressBarOption Id, typename Tuple, std::size_t counter =0>
-struct option_idx;
+template <ProgressBarOption Id, typename Tuple, std::size_t counter = 0> struct option_idx;
 
 template <ProgressBarOption Id, typename T, typename... Settings, std::size_t counter>
-struct option_idx<Id, std::tuple<T, Settings...>, counter> : if_else_type<(Id == T::id),
-    std::integral_constant<std::size_t, counter>,
-    option_idx<Id, std::tuple<Settings...>, counter+1>>::type{};
+struct option_idx<Id, std::tuple<T, Settings...>, counter>
+    : if_else_type<(Id == T::id), std::integral_constant<std::size_t, counter>,
+                   option_idx<Id, std::tuple<Settings...>, counter + 1>>::type {};
 
-template <ProgressBarOption Id, std::size_t counter>
-struct option_idx<Id, std::tuple<>, counter>{
+template <ProgressBarOption Id, std::size_t counter> struct option_idx<Id, std::tuple<>, counter> {
   static_assert(always_true<(ProgressBarOption)Id>::value, "No such option was found");
 };
 
 template <ProgressBarOption Id, typename Settings>
-auto get_value(Settings&& settings) -> decltype((std::get<option_idx<Id, typename std::decay<Settings>::type>::value>(std::declval<Settings&&>()))){
-  return std::get<option_idx<Id, typename std::decay<Settings>::type>::value>(std::forward<Settings>(settings));
+auto get_value(Settings &&settings)
+    -> decltype((std::get<option_idx<Id, typename std::decay<Settings>::type>::value>(
+        std::declval<Settings &&>()))) {
+  return std::get<option_idx<Id, typename std::decay<Settings>::type>::value>(
+      std::forward<Settings>(settings));
 }
 
-}
+} // namespace details
 
-
-namespace option{
-  using BarWidth = details::IntegerSetting<details::ProgressBarOption::bar_width>;
-  using PrefixText = details::StringSetting<details::ProgressBarOption::prefix_text>;
-  using PostfixText = details::StringSetting<details::ProgressBarOption::postfix_text>;
-  using Start = details::StringSetting<details::ProgressBarOption::start>;
-  using End = details::StringSetting<details::ProgressBarOption::end>;
-  using Fill = details::StringSetting<details::ProgressBarOption::fill>;
-  using Lead = details::StringSetting<details::ProgressBarOption::lead>;
-  using Remainder = details::StringSetting<details::ProgressBarOption::remainder>;
-  using MaxPostfixTextLen = details::IntegerSetting<details::ProgressBarOption::max_postfix_text_len>;
-  using Completed = details::BooleanSetting<details::ProgressBarOption::completed>;
-  using ShowPercentage = details::BooleanSetting<details::ProgressBarOption::show_percentage>;
-  using ShowElapsedTime = details::BooleanSetting<details::ProgressBarOption::show_elapsed_time>;
-  using ShowRemainingTime = details::BooleanSetting<details::ProgressBarOption::show_remaining_time>;
-  using SavedStartTime = details::BooleanSetting<details::ProgressBarOption::saved_start_time>;
-  using ForegroundColor = details::Setting<Color, details::ProgressBarOption::foreground_color>;
-  using ShowSpinner = details::BooleanSetting<details::ProgressBarOption::spinner_show>;
-  using SpinnerStates = details::Setting<std::vector<std::string>, details::ProgressBarOption::spinner_states>;
-}
-}
+namespace option {
+using BarWidth = details::IntegerSetting<details::ProgressBarOption::bar_width>;
+using PrefixText = details::StringSetting<details::ProgressBarOption::prefix_text>;
+using PostfixText = details::StringSetting<details::ProgressBarOption::postfix_text>;
+using Start = details::StringSetting<details::ProgressBarOption::start>;
+using End = details::StringSetting<details::ProgressBarOption::end>;
+using Fill = details::StringSetting<details::ProgressBarOption::fill>;
+using Lead = details::StringSetting<details::ProgressBarOption::lead>;
+using Remainder = details::StringSetting<details::ProgressBarOption::remainder>;
+using MaxPostfixTextLen = details::IntegerSetting<details::ProgressBarOption::max_postfix_text_len>;
+using Completed = details::BooleanSetting<details::ProgressBarOption::completed>;
+using ShowPercentage = details::BooleanSetting<details::ProgressBarOption::show_percentage>;
+using ShowElapsedTime = details::BooleanSetting<details::ProgressBarOption::show_elapsed_time>;
+using ShowRemainingTime = details::BooleanSetting<details::ProgressBarOption::show_remaining_time>;
+using SavedStartTime = details::BooleanSetting<details::ProgressBarOption::saved_start_time>;
+using ForegroundColor = details::Setting<Color, details::ProgressBarOption::foreground_color>;
+using ShowSpinner = details::BooleanSetting<details::ProgressBarOption::spinner_show>;
+using SpinnerStates =
+    details::Setting<std::vector<std::string>, details::ProgressBarOption::spinner_states>;
+using HideBarWhenComplete =
+    details::BooleanSetting<details::ProgressBarOption::hide_bar_when_complete>;
+} // namespace option
+} // namespace indicators

include/indicators/termcolor.hpp

@@ -32,6 +32,9 @@
 #if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
 #include <unistd.h>
 #elif defined(TERMCOLOR_OS_WINDOWS)
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif
 #include <io.h>
 #include <windows.h>
 #endif

indicators.pc.in

@@ -1,7 +1,7 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
 
-Name: indicators
-Description: Activity Indicators for Modern C++
+Name: @PROJECT_NAME@
+Description: @PROJECT_DESCRIPTION@
+URL: @PROJECT_HOMEPAGE_URL@
 Version: @PROJECT_VERSION@
 Cflags: -I${includedir}

indicatorsConfig.cmake.in

@@ -2,7 +2,7 @@
 
 include(CMakeFindDependencyMacro)
 
-find_dependency(Threads)
+find_dependency(Threads REQUIRED)
 
 if (NOT TARGET indicators::indicators)
   include(${CMAKE_CURRENT_LIST_DIR}/indicatorsTargets.cmake)

samples/CMakeLists.txt

@@ -22,3 +22,6 @@ target_link_libraries(multi_progress_bar PRIVATE indicators::indicators)
 
 add_executable(multi_block_progress_bar multi_block_progress_bar.cpp)
 target_link_libraries(multi_block_progress_bar PRIVATE indicators::indicators)
+
+add_executable(dynamic_progress dynamic_progress.cpp)
+target_link_libraries(dynamic_progress PRIVATE indicators::indicators)

samples/block_progress_bar.cpp

@@ -7,9 +7,7 @@ int main() {
   // Hide cursor
   std::cout << "\e[?25l";
 
-  indicators::BlockProgressBar bar{
-    indicators::option::BarWidth {80}
-  };
+  indicators::BlockProgressBar bar{indicators::option::BarWidth{80}};
 
   // Update bar state
   auto progress = 0.0f;

samples/dynamic_progress.cpp

@@ -0,0 +1,131 @@
+#include <indicators/dynamic_progress.hpp>
+#include <indicators/progress_bar.hpp>
+using namespace indicators;
+
+int main() {
+
+  ProgressBar bar1{option::BarWidth{50}, option::ForegroundColor{Color::red},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"5c90d4a2d1a8: Downloading "}};
+
+  ProgressBar bar2{option::BarWidth{50}, option::ForegroundColor{Color::yellow},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"22337bfd13a9: Downloading "}};
+
+  ProgressBar bar3{option::BarWidth{50}, option::ForegroundColor{Color::green},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"10f26c680a34: Downloading "}};
+
+  ProgressBar bar4{option::BarWidth{50}, option::ForegroundColor{Color::white},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"6364e0d7a283: Downloading "}};
+
+  ProgressBar bar5{option::BarWidth{50}, option::ForegroundColor{Color::blue},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"ff1356ba118b: Downloading "}};
+
+  ProgressBar bar6{option::BarWidth{50}, option::ForegroundColor{Color::cyan},
+                   option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                   option::PrefixText{"5a17453338b4: Downloading "}};
+
+  std::cout << termcolor::bold << termcolor::white << "Pulling image foo:bar/baz\n";
+
+  DynamicProgress<ProgressBar> bars(bar1, bar2, bar3);
+  bars.set_option(option::HideBarWhenComplete{false});
+
+  std::thread fourth_job, fifth_job, sixth_job;
+
+  auto job4 = [&bars](size_t i) {
+    while (true) {
+      bars[i].tick();
+      if (bars[i].is_completed()) {
+        bars[i].set_option(option::PrefixText{"6364e0d7a283: Pull complete "});
+        bars[i].mark_as_completed();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+  };
+
+  auto job5 = [&bars](size_t i) {
+    while (true) {
+      bars[i].tick();
+      if (bars[i].is_completed()) {
+        bars[i].set_option(option::PrefixText{"ff1356ba118b: Pull complete "});
+        bars[i].mark_as_completed();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+  };
+
+  auto job6 = [&bars](size_t i) {
+    while (true) {
+      bars[i].tick();
+      if (bars[i].is_completed()) {
+        bars[i].set_option(option::PrefixText{"5a17453338b4: Pull complete "});
+        bars[i].mark_as_completed();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(40));
+    }
+  };
+
+  auto job1 = [&bars, &bar6, &sixth_job, &job6]() {
+    while (true) {
+      bars[0].tick();
+      if (bars[0].is_completed()) {
+        bars[0].set_option(option::PrefixText{"5c90d4a2d1a8: Pull complete "});
+        // bar1 is completed, adding bar6
+        auto i = bars.push_back(bar6);
+        sixth_job = std::thread(job6, i);
+        sixth_job.join();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(140));
+    }
+  };
+
+  auto job2 = [&bars, &bar5, &fifth_job, &job5]() {
+    while (true) {
+      bars[1].tick();
+      if (bars[1].is_completed()) {
+        bars[1].set_option(option::PrefixText{"22337bfd13a9: Pull complete "});
+        // bar2 is completed, adding bar5
+        auto i = bars.push_back(bar5);
+        fifth_job = std::thread(job5, i);
+        fifth_job.join();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(25));
+    }
+  };
+
+  auto job3 = [&bars, &bar4, &fourth_job, &job4]() {
+    while (true) {
+      bars[2].tick();
+      if (bars[2].is_completed()) {
+        bars[2].set_option(option::PrefixText{"10f26c680a34: Pull complete "});
+        // bar3 is completed, adding bar4
+        auto i = bars.push_back(bar4);
+        fourth_job = std::thread(job4, i);
+        fourth_job.join();
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+  };
+
+  std::thread first_job(job1);
+  std::thread second_job(job2);
+  std::thread third_job(job3);
+
+  third_job.join();
+  second_job.join();
+  first_job.join();
+
+  std::cout << termcolor::bold << termcolor::green << "✔ Downloaded image foo/bar:baz" << std::endl;
+  std::cout << termcolor::reset;
+
+  return 0;
+}

samples/multi_block_progress_bar.cpp

@@ -3,29 +3,17 @@
 
 int main() {
   using namespace indicators;
-  BlockProgressBar bar1{
-    option::BarWidth{50},
-    option::ForegroundColor{Color::YELLOW},
-    option::ShowElapsedTime{true},
-    option::ShowRemainingTime{true},
-    option::PrefixText{"Progress Bar #1 "}
-  };
+  BlockProgressBar bar1{option::BarWidth{50}, option::ForegroundColor{Color::yellow},
+                        option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                        option::PrefixText{"Progress Bar #1 "}};
 
-  BlockProgressBar bar2{
-    option::BarWidth{50},
-    option::ForegroundColor{Color::CYAN},
-    option::ShowElapsedTime{true},
-    option::ShowRemainingTime{true},
-    option::PrefixText{"Progress Bar #2 "}
-  };
+  BlockProgressBar bar2{option::BarWidth{50}, option::ForegroundColor{Color::cyan},
+                        option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                        option::PrefixText{"Progress Bar #2 "}};
 
-  BlockProgressBar bar3{
-    option::BarWidth{50},
-    option::ForegroundColor{Color::RED},
-    option::ShowElapsedTime{true},
-    option::ShowRemainingTime{true},
-    option::PrefixText{"Progress Bar #3 "}
-  };
+  BlockProgressBar bar3{option::BarWidth{50}, option::ForegroundColor{Color::red},
+                        option::ShowElapsedTime{true}, option::ShowRemainingTime{true},
+                        option::PrefixText{"Progress Bar #3 "}};
 
   indicators::MultiProgress<indicators::BlockProgressBar, 3> bars(bar1, bar2, bar3);
 

samples/multi_progress_bar.cpp

@@ -3,44 +3,38 @@
 
 int main() {
 
-  indicators::ProgressBar bar1{
-    indicators::option::BarWidth{50},
-    indicators::option::Start{"["},
-    indicators::option::Fill{"■"},
-    indicators::option::Lead{"■"},
-    indicators::option::Remainder{" "},
-    indicators::option::End{" ]"},
-    indicators::option::ForegroundColor{indicators::Color::YELLOW},
-    indicators::option::ShowElapsedTime{true},
-    indicators::option::ShowRemainingTime{true},
-    indicators::option::PrefixText{"Progress Bar #1 "}
-  };
+  indicators::ProgressBar bar1{indicators::option::BarWidth{50},
+                               indicators::option::Start{"["},
+                               indicators::option::Fill{"■"},
+                               indicators::option::Lead{"■"},
+                               indicators::option::Remainder{" "},
+                               indicators::option::End{" ]"},
+                               indicators::option::ForegroundColor{indicators::Color::yellow},
+                               indicators::option::ShowElapsedTime{true},
+                               indicators::option::ShowRemainingTime{true},
+                               indicators::option::PrefixText{"Progress Bar #1 "}};
 
-  indicators::ProgressBar bar2{
-    indicators::option::BarWidth{50},
-    indicators::option::Start{"["},
-    indicators::option::Fill{"="},
-    indicators::option::Lead{">"},
-    indicators::option::Remainder{" "},
-    indicators::option::End{" ]"},
-    indicators::option::ForegroundColor{indicators::Color::CYAN},
-    indicators::option::ShowElapsedTime{true},
-    indicators::option::ShowRemainingTime{true},
-    indicators::option::PrefixText{"Progress Bar #2 "}
-  };
+  indicators::ProgressBar bar2{indicators::option::BarWidth{50},
+                               indicators::option::Start{"["},
+                               indicators::option::Fill{"="},
+                               indicators::option::Lead{">"},
+                               indicators::option::Remainder{" "},
+                               indicators::option::End{" ]"},
+                               indicators::option::ForegroundColor{indicators::Color::cyan},
+                               indicators::option::ShowElapsedTime{true},
+                               indicators::option::ShowRemainingTime{true},
+                               indicators::option::PrefixText{"Progress Bar #2 "}};
 
-  indicators::ProgressBar bar3{
-    indicators::option::BarWidth{50},
-    indicators::option::Start{"["},
-    indicators::option::Fill{"#"},
-    indicators::option::Lead{"#"},
-    indicators::option::Remainder{" "},
-    indicators::option::End{" ]"},
-    indicators::option::ForegroundColor{indicators::Color::CYAN},
-    indicators::option::ShowElapsedTime{true},
-    indicators::option::ShowRemainingTime{true},
-    indicators::option::PrefixText{"Progress Bar #3 "}
-  };
+  indicators::ProgressBar bar3{indicators::option::BarWidth{50},
+                               indicators::option::Start{"["},
+                               indicators::option::Fill{"#"},
+                               indicators::option::Lead{"#"},
+                               indicators::option::Remainder{" "},
+                               indicators::option::End{" ]"},
+                               indicators::option::ForegroundColor{indicators::Color::red},
+                               indicators::option::ShowElapsedTime{true},
+                               indicators::option::ShowRemainingTime{true},
+                               indicators::option::PrefixText{"Progress Bar #3 "}};
 
   indicators::MultiProgress<indicators::ProgressBar, 3> bars(bar1, bar2, bar3);
 

samples/multi_threaded_bar.cpp

@@ -4,13 +4,13 @@
 int main() {
 
   indicators::ProgressBar bar{
-    indicators::option::BarWidth{50},
-    indicators::option::Start{"["},
-    indicators::option::Fill{"■"},
-    indicators::option::Lead{"■"},
-    indicators::option::Remainder{"-"},
-    indicators::option::End{" ]"},
-    indicators::option::ForegroundColor{indicators::Color::YELLOW},
+      indicators::option::BarWidth{50},
+      indicators::option::Start{"["},
+      indicators::option::Fill{"■"},
+      indicators::option::Lead{"■"},
+      indicators::option::Remainder{"-"},
+      indicators::option::End{" ]"},
+      indicators::option::ForegroundColor{indicators::Color::yellow},
   };
 
   // As configured, the bar will look like this:

samples/progress_bar_set_progress.cpp

@@ -8,14 +8,14 @@ int main() {
   std::cout << "\e[?25l";
 
   indicators::ProgressBar bar{
-    indicators::option::BarWidth{50},
-    indicators::option::Start{"["},
-    indicators::option::Fill{"■"},
-    indicators::option::Lead{"■"},
-    indicators::option::Remainder{"-"},
-    indicators::option::End{" ]"},
-    indicators::option::PostfixText{"Loading dependency 1/4"},
-    indicators::option::ForegroundColor{indicators::Color::CYAN},
+      indicators::option::BarWidth{50},
+      indicators::option::Start{"["},
+      indicators::option::Fill{"■"},
+      indicators::option::Lead{"■"},
+      indicators::option::Remainder{"-"},
+      indicators::option::End{" ]"},
+      indicators::option::PostfixText{"Loading dependency 1/4"},
+      indicators::option::ForegroundColor{indicators::Color::cyan},
   };
 
   // Update bar state

samples/progress_bar_tick.cpp

@@ -4,14 +4,14 @@
 
 int main() {
   indicators::ProgressBar bar{
-    indicators::option::BarWidth{50},
-    indicators::option::Start{"["},
-    indicators::option::Fill{"="},
-    indicators::option::Lead{">"},
-    indicators::option::Remainder{" "},
-    indicators::option::End{" ]"},
-    indicators::option::PostfixText{"Getting started"},
-    indicators::option::ForegroundColor{indicators::Color::GREEN},
+      indicators::option::BarWidth{50},
+      indicators::option::Start{"["},
+      indicators::option::Fill{"="},
+      indicators::option::Lead{">"},
+      indicators::option::Remainder{" "},
+      indicators::option::End{" ]"},
+      indicators::option::PostfixText{"Getting started"},
+      indicators::option::ForegroundColor{indicators::Color::green},
   };
 
   // Update bar state

samples/progress_spinner.cpp

@@ -6,16 +6,17 @@ int main() {
   std::cout << "\e[?25l";
 
   indicators::ProgressSpinner spinner{
-    indicators::option::PostfixText{"Checking credentials"},
-    indicators::option::ForegroundColor{indicators::Color::YELLOW},
-    indicators::option::SpinnerStates{std::vector<std::string>{"⠈", "⠐", "⠠", "⢀", "⡀", "⠄", "⠂", "⠁"}},
+      indicators::option::PostfixText{"Checking credentials"},
+      indicators::option::ForegroundColor{indicators::Color::yellow},
+      indicators::option::SpinnerStates{
+          std::vector<std::string>{"⠈", "⠐", "⠠", "⢀", "⡀", "⠄", "⠂", "⠁"}},
   };
 
   // Update spinner state
   auto job = [&spinner]() {
     while (true) {
       if (spinner.is_completed()) {
-        spinner.set_option(indicators::option::ForegroundColor{indicators::Color::GREEN});
+        spinner.set_option(indicators::option::ForegroundColor{indicators::Color::green});
         spinner.set_option(indicators::option::PrefixText{"✔"});
         spinner.set_option(indicators::option::ShowSpinner{false});
         spinner.set_option(indicators::option::ShowPercentage{false});

samples/time_meter.cpp

@@ -4,16 +4,16 @@
 
 int main() {
   indicators::ProgressBar bar{
-    indicators::option::BarWidth{50},
-    indicators::option::Start{" ["},
-    indicators::option::Fill{"█"},
-    indicators::option::Lead{"█"},
-    indicators::option::Remainder{"-"},
-    indicators::option::End{"]"},
-    indicators::option::PostfixText{"Training Gaze Network "},
-    indicators::option::ForegroundColor{indicators::Color::YELLOW},
-    indicators::option::ShowElapsedTime{true},
-    indicators::option::ShowRemainingTime{true},
+      indicators::option::BarWidth{50},
+      indicators::option::Start{" ["},
+      indicators::option::Fill{"█"},
+      indicators::option::Lead{"█"},
+      indicators::option::Remainder{"-"},
+      indicators::option::End{"]"},
+      indicators::option::PrefixText{"Training Gaze Network 👀"},
+      indicators::option::ForegroundColor{indicators::Color::yellow},
+      indicators::option::ShowElapsedTime{true},
+      indicators::option::ShowRemainingTime{true},
   };
 
   // Update bar state