Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	tmp_project/StringUtils/src/ProgressTime.cpp	Lines:	101	101	100.0 %
Date:	2024-12-09 15:30:52	Branches:	15	20	75.0 %


/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	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){
	p_buffer = NULL;
	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){
	if(p_buffer != NULL){
		delete [] p_buffer;
	}
	p_buffer = new char[other.p_sizeBarr + 1];                    //on pense au caractère \0
	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;

	p_buffer[p_sizeBarr] = '\0';
}

///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 = (3u*p_consoleWidth)/4u; //on prend 3/4 de la taille de la console
	p_buffer = new char[p_sizeBarr + 1u];
}

///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] = '\0';
}

///fonction qui efface la barre de chargement
void ProgressTime::clear(){
	for(unsigned int i(0); i < p_sizeBarr; ++i){
		p_buffer[i] = '\r';
	}
	p_buffer[p_sizeBarr] = '\0';
}



Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/***************************************
2			Auteur : Pierre Aubert
3			Mail : pierre.aubert@lapp.in2p3.fr
4			Licence : CeCILL-C
5			****************************************/
6
7			#include "ProgressTime.h"
8			#include "string_utils.h"
9			#include "string_color.h"
10
11			using namespace std;
12
13			///Constructeur par défaut de ProgressTime
14			/** Cette fonction démarre le chronomètre par défaut
15			*/
16		1	ProgressTime::ProgressTime(){
17		1	initialisationProgressTime(0, '=', '>', ' ');
18		1	}
19
20			///Constructeur de ProgressTime
21			/** @param nbSteps : nombre d'étapes total à effectuer pour la barre de chargement
22			* @param chPlein : charactère de remplissage de la barre plein
23			* @param chMiddle : charactère au bout de la ligne de remplissage
24			* @param chEnd : charactère de remplissage de la barre vide
25			* Cette fonction démarre le chronomètre par défaut
26			*/
27		2	ProgressTime::ProgressTime(size_t nbSteps, char chPlein, char chMiddle, char chEnd){
28		2	initialisationProgressTime(nbSteps, chPlein, chMiddle, chEnd);
29		2	}
30
31			///constructeur de copie de ProgressTime
32			/** @param other : ProgressTime à copier
33			*/
34		1	ProgressTime::ProgressTime(const ProgressTime & other){
35		1	p_buffer = NULL;
36		1	copyProgressTime(other);
37		1	}
38
39			///destructeur de ProgressTime
40		16	ProgressTime::~ProgressTime(){
41	✓✗	8	if(p_buffer != NULL){
42	✓✗	8	delete [] p_buffer;
43			}
44			}
45
46			///fonction qui démarre le chronomètre de la ProgressTime
47		4	void ProgressTime::start(){
48		4	p_startTime = clock();
49		4	p_iCurrent = 0;
50		4	p_oldAvancement = 0;
51		4	p_avancement = 0;
52		4	p_secondesRestantes = 0;
53		4	p_oldTempsRestant = 0;
54		4	}
55
56			///fonction qui affiche la ProgressTime
57		1001	void ProgressTime::print(){
58		1001	++p_iCurrent;
59		1001	p_avancement = (p_iCurrent*p_sizeBarr)/p_nbSteps;
60		1001	p_tempsRestant = (clock_t)(((clock() - p_startTime)*((clock_t)(p_nbSteps - p_iCurrent)))/((clock_t)p_iCurrent));
61	✓✓✓✗	1001	if(p_oldAvancement != p_avancement \|\| p_oldTempsRestant != p_tempsRestant){
62		1001	p_pourcent = (p_iCurrent*100)/p_nbSteps;
63			//on efface la ligne de la console où il y a la barre de chargement
64		1001	clear();
65		1001	cerr << "\r" << p_buffer << "\r\r\r\r";
66			//on affiche la barre de chargement
67		1001	feelbuffer(p_avancement);
68		1001	p_secondesRestantes = p_tempsRestant/CLOCKS_PER_SEC;
69		1001	cerr << "[" << p_buffer << "\|" << p_pourcent << "%] " << p_secondesRestantes << "s";
70			//on met old_taille à jour
71		1001	p_oldAvancement = p_avancement;
72		1001	p_oldTempsRestant = p_tempsRestant;
73			}
74		1001	}
75
76			///affiche la barre de chargement finie
77		2	void ProgressTime::finish(){
78		2	clear();
79		2	cerr << "\r" << p_buffer << "\r\r\r\r";
80		2	feelbuffer(p_sizeBarr);
81		2	cerr << "[" << p_buffer << "\|" << p_pourcent << "%] " << p_secondesRestantes << "s";
82		2	cerr << endl;
83		2	}
84
85			///fonction qui initialise le nombre d'étapes à faire
86			/** @param nbSteps : nombre d'étapes à faire pour arriver à 100%
87			*/
88		1	void ProgressTime::setNbSteps(size_t nbSteps){
89		1	p_nbSteps = nbSteps;
90		1	}
91
92			///init le caractère de remplissage
93			/** @param chPlein : caractère de remplissage
94			*/
95		1	void ProgressTime::setChPlein(char chPlein){
96		1	p_chPlein = chPlein;
97		1	}
98
99			///init le charactère au bout de la ligne de remplissage
100			/** @param chMiddle : charactère au bout de la ligne de remplissage
101			*/
102		1	void ProgressTime::setChMiddle(char chMiddle){
103		1	p_chMiddle = chMiddle;
104		1	}
105
106			///init le charactère de remplissage de la barre vide
107			/** @param chEnd : charactère de remplissage de la barre vide
108			*/
109		1	void ProgressTime::setChEnd(char chEnd){
110		1	p_chEnd = chEnd;
111		1	}
112
113			///Opérateur = de ProgressTime
114			/** @param other : ProgressTime à copier
115			* @return ProgressTime copié
116			*/
117		2	ProgressTime & ProgressTime::operator = (const ProgressTime & other){
118		2	copyProgressTime(other);
119		2	return *this;
120			}
121
122			///fonction de copie de ProgressTime
123			/** @param other : ProgressTime à copier
124			*/
125		3	void ProgressTime::copyProgressTime(const ProgressTime & other){
126	✓✓	3	if(p_buffer != NULL){
127	✓✗	2	delete [] p_buffer;
128			}
129		3	p_buffer = new char[other.p_sizeBarr + 1]; //on pense au caractère \0
130		3	p_startTime = other.p_startTime;
131		3	p_tempsRestant = other.p_tempsRestant;
132		3	p_nbSteps = other.p_nbSteps;
133		3	p_iCurrent = other.p_iCurrent;
134		3	p_avancement = other.p_avancement;
135		3	p_oldAvancement = other.p_oldAvancement;
136		3	p_secondesRestantes = other.p_secondesRestantes;
137		3	p_oldTempsRestant = other.p_oldTempsRestant;
138		3	p_consoleWidth = other.p_consoleWidth;
139		3	p_pourcent = other.p_pourcent;
140		3	p_sizeBarr = other.p_sizeBarr;
141		3	p_chPlein = other.p_chPlein;
142		3	p_chMiddle = other.p_chMiddle;
143		3	p_chEnd = other.p_chEnd;
144
145		3	p_buffer[p_sizeBarr] = '\0';
146		3	}
147
148			///fonction d'initialisation de ProgressTime
149			/** @param nbSteps : nombre d'étapes à faire pour arriver à 100%
150			* @param chPlein : caractère de remplissage de la barre de chargement
151			* @param chMiddle : caractère entre la partie vide et la partie remplie de la barre de chargement
152			* @param chEnd : caractère de la partie vide de la barre de chargement
153			*/
154		3	void ProgressTime::initialisationProgressTime(size_t nbSteps, char chPlein, char chMiddle, char chEnd){
155		3	p_nbSteps = nbSteps;
156		3	p_chPlein = chPlein;
157		3	p_chMiddle = chMiddle;
158		3	p_chEnd = chEnd;
159		3	start();
160		3	p_consoleWidth = getNbColTerminal();
161		3	p_sizeBarr = (3u*p_consoleWidth)/4u; //on prend 3/4 de la taille de la console
162		3	p_buffer = new char[p_sizeBarr + 1u];
163		3	}
164
165			///affiche la barre de chargement
166			/** @param taille : taille de la barre à afficher
167			*/
168		1003	void ProgressTime::feelbuffer(unsigned int taille){
169	✓✗	1003	if(taille <= p_sizeBarr){
170	✓✓	656467	for(unsigned int i(0); i < taille; ++i){
171		655464	p_buffer[i] = p_chPlein;
172			}
173		1003	p_buffer[taille] = p_chMiddle;
174			}
175	✓✓	654847	for(unsigned int i(taille + 1); i <= p_sizeBarr; ++i){
176		653844	p_buffer[i] = p_chEnd;
177			}
178		1003	p_buffer[p_sizeBarr] = '\0';
179		1003	}
180
181			///fonction qui efface la barre de chargement
182		1003	void ProgressTime::clear(){
183	✓✓	1310311	for(unsigned int i(0); i < p_sizeBarr; ++i){
184		1309308	p_buffer[i] = '\r';
185			}
186		1003	p_buffer[p_sizeBarr] = '\0';
187		1003	}
188