Gitlab is now running v13.10.2 - More info -> here <-

Commit a9475c7e authored by Pierre Aubert's avatar Pierre Aubert

Add progress bar

parent 58a0a1e2
Pipeline #99764 passed with stages
in 1 minute and 30 seconds
......@@ -14,4 +14,5 @@ add_subdirectory(TEST_STRING_FUNCTION)
add_subdirectory(TEST_SYSTEM)
add_subdirectory(TEST_REGEXPR)
add_subdirectory(TEST_PHOENIX_POPEN)
add_subdirectory(TEST_PROGRESS_BAR)
project(Phoenix)
cmake_minimum_required(VERSION 2.8)
add_executable(test_progress_bar main.cpp)
target_link_libraries(test_progress_bar string_utils)
add_test(NAME TestProgressBar
COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_progress_bar)
/***************************************
Auteur : Pierre Aubert
Mail : aubertp7@gmail.com
Licence : CeCILL-C
****************************************/
#include <unistd.h>
#include <iostream>
#include "ProgressBarr.h"
#include "ProgressTime.h"
///Test the ProgressBarr
/** @return true on success, false otherwise
*/
bool testProgressBar(){
size_t nbValue(1000);
ProgressBarr progress(nbValue);
for(size_t i(0lu); i < nbValue; ++i){
progress.progress(i);
usleep(2000);
}
progress.finish();
return true;
}
///Test the ProgressTime
/** @return true on success, false otherwise
*/
bool testProgressTime(){
size_t nbValue(1000);
ProgressTime progress(nbValue);
progress.start();
for(size_t i(0lu); i < nbValue; ++i){
progress.print();
usleep(4000);
}
progress.finish();
return true;
}
int main(int argc, char** argv){
bool b(true);
b &= testProgressBar();
b &= testProgressTime();
if(b){return 0;}
else{return -1;}
}
/***************************************
Auteur : Pierre Aubert
Mail : aubertp7@gmail.com
Licence : CeCILL-C
****************************************/
#include "ProgressBarr.h"
using namespace std;
///constructeur de la barre de progression en console
/** @param max : valeur maximale atteinte par barre de progression pleine
@param size : taille de la barre de chargement
@param chPlein : charactère de remplissage de la barre plein
@param chMiddle : charactère au bout de la ligne de remplissage
@param chEnd : charactère de remplissage de la barre vide
*/
ProgressBarr::ProgressBarr(size_t max, size_t size, char chPlein, char chMiddle, char chEnd){
init(max, size, chPlein, chMiddle, chEnd);
}
///constreucteur de copie de la barre de progression
/** @param progressBarr : barre de progression à copier
*/
ProgressBarr::ProgressBarr(const ProgressBarr & progressBarr){
copy(progressBarr);
}
///destructeur de la barre de progression
ProgressBarr::~ProgressBarr(){
if(p_buffer != NULL){
delete[] p_buffer;
}
}
///fonction qui fait avancer (ou reculer) la barre de chargement
/** @param avencement : avencement de la barre (plus petit ou égal à max)
*/
void ProgressBarr::progress(size_t avencement){
size_t taille = (avencement*p_size)/p_max;
if(p_old_taille != taille){
int pourcent = (avencement*100)/p_max;
//on efface la ligne de la console où il y a la barre de chargement
clear();
cerr << "\r" << p_buffer << "\r\r\r\r";
//on affiche la barre de chargement
feelbuffer(taille);
cerr << "[" << p_buffer << "|" << pourcent << "%]";
//on met old_taille à jour
p_old_taille = taille;
}
}
///retourne la valeur max atteinte par la barre
/** @return valeur max atteinte par la barre
*/
size_t ProgressBarr::getMax() const{
return p_max;
}
///retourne la taille maximale de la barre
/** @return taille maximale de la barre
*/
size_t ProgressBarr::getSize() const{
return p_size;
}
///retourne le caractère de remplissage
/** @return caractère de remplissage
*/
char ProgressBarr::getChPlein() const{
return p_chPlein;
}
///retourne le charactère au bout de la ligne de remplissage
/** @return charactère au bout de la ligne de remplissage
*/
char ProgressBarr::getChMiddle() const{
return p_chMiddle;
}
///retourne le charactère de remplissage de la barre vide
/** @return charactère de remplissage de la barre vide
*/
char ProgressBarr::getChEnd() const{
return p_chEnd;
}
///init la valeur max atteinte par la barre
/** @param max : valeur max atteinte par la barre
*/
void ProgressBarr::setMax(size_t max){
p_max = max;
}
///init la taille de la barre
/** @param size : taille de la barre de chargement pleine
*/
void ProgressBarr::setSize(size_t size){
p_size = size;
}
///init le caractère de remplissage
/** @param chPlein : caractère de remplissage
*/
void ProgressBarr::setChPlein(char chPlein){
p_chPlein = chPlein;
}
///init le charactère au bout de la ligne de remplissage
/** @param chMiddle : charactère au bout de la ligne de remplissage
*/
void ProgressBarr::setChMiddle(char chMiddle){
p_chMiddle = chMiddle;
}
///init le charactère de remplissage de la barre vide
/** @param chEnd : charactère de remplissage de la barre vide
*/
void ProgressBarr::setChEnd(char chEnd){
p_chEnd = chEnd;
}
///affiche la barre de chargement finie
void ProgressBarr::finish(){
progress(p_max);
cout << endl;
}
///redéfinition de l'opérateur =
/** @param progressBarr : barre de chargement à copier
*/
ProgressBarr & ProgressBarr::operator = (const ProgressBarr & progressBarr){
copy(progressBarr);
return *this;
}
///Initialisation de la barre de progression en console
/** @param max : valeur maximale atteinte par barre de progression pleine
@param size : taille de la barre de chargement
@param chPlein : charactère de remplissage de la barre plein
@param chMiddle : charactère au bout de la ligne de remplissage
@param chEnd : charactère de remplissage de la barre vide
*/
void ProgressBarr::init(size_t max,size_t size, char chPlein, char chMiddle, char chEnd){
p_buffer = new char[size + 1];
p_size = size;
p_max = max;
p_chPlein = chPlein;
p_chMiddle = chMiddle;
p_chEnd = chEnd;
p_old_taille = -1;
}
///fonction qui copie la barre de chargement
/** @param progressBarr : barre de chargement à copier
*/
void ProgressBarr::copy(const ProgressBarr & progressBarr){
p_buffer = new char[progressBarr.p_size + 1]; //on pense au caractère \0
p_size = progressBarr.p_size;
p_max = progressBarr.p_max;
p_chPlein = progressBarr.p_chPlein;
p_chMiddle = progressBarr.p_chMiddle;
p_chEnd = progressBarr.p_chEnd;
p_old_taille = progressBarr.p_old_taille;
}
///affiche la barre de chargement
/** @param taille : taille de la barre à afficher
*/
void ProgressBarr::feelbuffer(size_t taille){
if(taille <= p_size){
for(size_t i = 0; i < taille; ++i){
p_buffer[i] = p_chPlein;
}
p_buffer[taille] = p_chMiddle;
}
for(size_t i = taille + 1; i < p_size; ++i){
p_buffer[i] = p_chEnd;
}
p_buffer[p_size] = '\0';
}
///fonction qui efface la barre de chargement
void ProgressBarr::clear(){
for(size_t i = 0; i < p_size; ++i){
p_buffer[i] = '\r';
}
p_buffer[p_size] = '\0';
}
/***************************************
Auteur : Pierre Aubert
Mail : aubertp7@gmail.com
Licence : CeCILL-C
****************************************/
#ifndef __PROGRESSBARR_H__
#define __PROGRESSBARR_H__
#include <iostream>
#include <unistd.h>
///@brief classe qui permet d'afficher une barre de chargement dans la console
class ProgressBarr{
public:
ProgressBarr(size_t max = 100, size_t size = 100, char chPlein = '=', char chMiddle = '>', char chEnd = ' ');
ProgressBarr(const ProgressBarr & progressBarr);
virtual ~ProgressBarr();
void progress(size_t avencement);
size_t getMax() const;
size_t getSize() const;
char getChPlein() const;
char getChMiddle() const;
char getChEnd() const;
void setMax(size_t max);
void setSize(size_t size);
void setChPlein(char chPlein);
void setChMiddle(char chMiddle);
void setChEnd(char chEnd);
void finish();
ProgressBarr & operator = (const ProgressBarr & progressBarr);
protected:
void copy(const ProgressBarr & progressBarr);
void feelbuffer(size_t taille);
void clear();
///tampon pour l'affichage
char* p_buffer;
///taille maximale de la barre de chargement
size_t p_size;
///valeur maximale atteinte par le chargement
size_t p_max;
///ancienne taille de la barre de chargement
size_t p_old_taille;
///caractère de remplissage
char p_chPlein;
///charactère au bout de la ligne de remplissage
char p_chMiddle;
///charactère de remplissage de la barre vide
char p_chEnd;
private:
void init(size_t max, size_t size, char chPlein, char chMiddle, char chEnd);
};
#endif
/***************************************
Auteur : Pierre Aubert
Mail : aubertp7@gmail.com
Licence : CeCILL-C
****************************************/
#include "ProgressTime.h"
#include "string_utils.h"
#include "string_color.h"
using namespace std;
///Constructeur par défaut de ProgressTime
/** Cette fonction démarre le chronomètre par défaut
*/
ProgressTime::ProgressTime(){
initialisationProgressTime(0, '=', '>', ' ');
}
///Constructeur de ProgressTime
/** @param nbSteps : nombre d'étapes total à effectuer pour la barre de chargement
* @param chPlein : charactère de remplissage de la barre plein
* @param chMiddle : charactère au bout de la ligne de remplissage
* @param chEnd : charactère de remplissage de la barre vide
* Cette fonction démarre le chronomètre par défaut
*/
ProgressTime::ProgressTime(size_t nbSteps, char chPlein, char chMiddle, char chEnd){
initialisationProgressTime(nbSteps, chPlein, chMiddle, chEnd);
}
///constructeur de copie de ProgressTime
/** @param other : ProgressTime à copier
*/
ProgressTime::ProgressTime(const ProgressTime & other){
copyProgressTime(other);
}
///destructeur de ProgressTime
ProgressTime::~ProgressTime(){
if(p_buffer != NULL){
delete [] p_buffer;
}
}
///fonction qui démarre le chronomètre de la ProgressTime
void ProgressTime::start(){
p_startTime = clock();
p_iCurrent = 0;
p_oldAvancement = 0;
p_avancement = 0;
p_secondesRestantes = 0;
p_oldTempsRestant = 0;
}
///fonction qui affiche la ProgressTime
void ProgressTime::print(){
++p_iCurrent;
p_avancement = (p_iCurrent*p_sizeBarr)/p_nbSteps;
p_tempsRestant = (clock_t)(((clock() - p_startTime)*((clock_t)(p_nbSteps - p_iCurrent)))/((clock_t)p_iCurrent));
if(p_oldAvancement != p_avancement || p_oldTempsRestant != p_tempsRestant){
p_pourcent = (p_iCurrent*100)/p_nbSteps;
//on efface la ligne de la console où il y a la barre de chargement
clear();
cerr << "\r" << p_buffer << "\r\r\r\r";
//on affiche la barre de chargement
feelbuffer(p_avancement);
p_secondesRestantes = p_tempsRestant/CLOCKS_PER_SEC;
cerr << "[" << p_buffer << "|" << p_pourcent << "%] " << p_secondesRestantes << "s";
//on met old_taille à jour
p_oldAvancement = p_avancement;
p_oldTempsRestant = p_tempsRestant;
}
}
///affiche la barre de chargement finie
void ProgressTime::finish(){
clear();
cerr << "\r" << p_buffer << "\r\r\r\r";
feelbuffer(p_sizeBarr);
cerr << "[" << p_buffer << "|" << p_pourcent << "%] " << p_secondesRestantes << "s";
cerr << endl;
}
///fonction qui initialise le nombre d'étapes à faire
/** @param nbSteps : nombre d'étapes à faire pour arriver à 100%
*/
void ProgressTime::setNbSteps(size_t nbSteps){
p_nbSteps = nbSteps;
}
///init le caractère de remplissage
/** @param chPlein : caractère de remplissage
*/
void ProgressTime::setChPlein(char chPlein){
p_chPlein = chPlein;
}
///init le charactère au bout de la ligne de remplissage
/** @param chMiddle : charactère au bout de la ligne de remplissage
*/
void ProgressTime::setChMiddle(char chMiddle){
p_chMiddle = chMiddle;
}
///init le charactère de remplissage de la barre vide
/** @param chEnd : charactère de remplissage de la barre vide
*/
void ProgressTime::setChEnd(char chEnd){
p_chEnd = chEnd;
}
///Opérateur = de ProgressTime
/** @param other : ProgressTime à copier
* @return ProgressTime copié
*/
ProgressTime & ProgressTime::operator = (const ProgressTime & other){
copyProgressTime(other);
return *this;
}
///fonction de copie de ProgressTime
/** @param other : ProgressTime à copier
*/
void ProgressTime::copyProgressTime(const ProgressTime & other){
p_startTime = other.p_startTime;
p_tempsRestant = other.p_tempsRestant;
p_nbSteps = other.p_nbSteps;
p_iCurrent = other.p_iCurrent;
p_avancement = other.p_avancement;
p_oldAvancement = other.p_oldAvancement;
p_secondesRestantes = other.p_secondesRestantes;
p_oldTempsRestant = other.p_oldTempsRestant;
p_consoleWidth = other.p_consoleWidth;
p_pourcent = other.p_pourcent;
p_sizeBarr = other.p_sizeBarr;
p_chPlein = other.p_chPlein;
p_chMiddle = other.p_chMiddle;
p_chEnd = other.p_chEnd;
}
///fonction d'initialisation de ProgressTime
/** @param nbSteps : nombre d'étapes à faire pour arriver à 100%
* @param chPlein : caractère de remplissage de la barre de chargement
* @param chMiddle : caractère entre la partie vide et la partie remplie de la barre de chargement
* @param chEnd : caractère de la partie vide de la barre de chargement
*/
void ProgressTime::initialisationProgressTime(size_t nbSteps, char chPlein, char chMiddle, char chEnd){
p_nbSteps = nbSteps;
p_chPlein = chPlein;
p_chMiddle = chMiddle;
p_chEnd = chEnd;
start();
p_consoleWidth = getNbColTerminal();
p_sizeBarr = (3*p_consoleWidth)/4; //on prend 3/4 de la taille de la console
p_buffer = new char[p_sizeBarr + 1];
}
///affiche la barre de chargement
/** @param taille : taille de la barre à afficher
*/
void ProgressTime::feelbuffer(unsigned int taille){
if(taille <= p_sizeBarr){
for(unsigned int i(0); i < taille; ++i){
p_buffer[i] = p_chPlein;
}
p_buffer[taille] = p_chMiddle;
}
for(unsigned int i(taille + 1); i <= p_sizeBarr; ++i){
p_buffer[i] = p_chEnd;
}
p_buffer[p_sizeBarr + 1] = '\0';
}
///fonction qui efface la barre de chargement
void ProgressTime::clear(){
for(unsigned int i(0); i <= p_sizeBarr; ++i){
p_buffer[i] = '\r';
}
}
/***************************************
Auteur : Pierre Aubert
Mail : aubertp7@gmail.com
Licence : CeCILL-C
****************************************/
#ifndef __PPROGRESS_TIME_H__
#define __PPROGRESS_TIME_H__
#include <stdio.h>
#include <time.h>
#include <iostream>
///@brief classe qui permet de gérer des barres de chargement en console avec l'affichage et le calcul du temps restant
class ProgressTime{
public:
ProgressTime();
ProgressTime(size_t nbSteps, char chPlein = '=', char chMiddle = '>', char chEnd = ' ');
ProgressTime(const ProgressTime & other);
virtual ~ProgressTime();
void start();
void print();
void finish();
void setNbSteps(size_t nbSteps);
void setChPlein(char chPlein);
void setChMiddle(char chMiddle);
void setChEnd(char chEnd);
ProgressTime & operator = (const ProgressTime & other);
private:
void initialisationProgressTime(size_t nbSteps, char chPlein, char chMiddle, char chEnd);
void copyProgressTime(const ProgressTime & other);
void feelbuffer(unsigned int taille);
void clear();
clock_t p_startTime;
clock_t p_tempsRestant;
size_t p_nbSteps;
size_t p_iCurrent;
unsigned int p_avancement;
unsigned int p_oldAvancement;
unsigned int p_secondesRestantes;
clock_t p_oldTempsRestant;
unsigned int p_consoleWidth;
unsigned int p_pourcent;
unsigned int p_sizeBarr;
///caractère de remplissage
char p_chPlein;
///charactère au bout de la ligne de remplissage
char p_chMiddle;
///charactère de remplissage de la barre vide
char p_chEnd;
///tampon pour l'affichage
char* p_buffer;
};
#endif
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment