Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	tmp_project/StringUtils/src/ProgressBarr.cpp	Lines:	86	86	100.0 %
Date:	2024-12-09 15:30:52	Branches:	15	18	83.3 %


/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	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){
	p_buffer = NULL;
	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 + 1lu];
	p_size = size;
	p_max = max;
	p_chPlein = chPlein;
	p_chMiddle = chMiddle;
	p_chEnd = chEnd;
	p_old_taille = 0lu;
}

///fonction qui copie la barre de chargement
/**	@param progressBarr : barre de chargement à copier
*/
void ProgressBarr::copy(const ProgressBarr & progressBarr){
	if(p_buffer != NULL){
		delete [] p_buffer;
	}
	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';
}




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 "ProgressBarr.h"
8
9			using namespace std;
10
11
12			///constructeur de la barre de progression en console
13			/** @param max : valeur maximale atteinte par barre de progression pleine
14			@param size : taille de la barre de chargement
15			@param chPlein : charactère de remplissage de la barre plein
16			@param chMiddle : charactère au bout de la ligne de remplissage
17			@param chEnd : charactère de remplissage de la barre vide
18			*/
19		4	ProgressBarr::ProgressBarr(size_t max, size_t size, char chPlein, char chMiddle, char chEnd){
20		4	init(max, size, chPlein, chMiddle, chEnd);
21		4	}
22
23
24			///constreucteur de copie de la barre de progression
25			/** @param progressBarr : barre de progression à copier
26			*/
27		1	ProgressBarr::ProgressBarr(const ProgressBarr & progressBarr){
28		1	p_buffer = NULL;
29		1	copy(progressBarr);
30		1	}
31
32			///destructeur de la barre de progression
33		20	ProgressBarr::~ProgressBarr(){
34	✓✗	10	if(p_buffer != NULL){
35	✓✗	10	delete[] p_buffer;
36			}
37			}
38
39
40			///fonction qui fait avancer (ou reculer) la barre de chargement
41			/** @param avencement : avencement de la barre (plus petit ou égal à max)
42			*/
43		1003	void ProgressBarr::progress(size_t avencement){
44		1003	size_t taille = (avencement*p_size)/p_max;
45	✓✓	1003	if(p_old_taille != taille){
46		102	int pourcent = (avencement*100)/p_max;
47			//on efface la ligne de la console où il y a la barre de chargement
48		102	clear();
49		102	cerr << "\r" << p_buffer << "\r\r\r\r";
50			//on affiche la barre de chargement
51		102	feelbuffer(taille);
52		102	cerr << "[" << p_buffer << "\|" << pourcent << "%]";
53			//on met old_taille à jour
54		102	p_old_taille = taille;
55			}
56		1003	}
57
58			///retourne la valeur max atteinte par la barre
59			/** @return valeur max atteinte par la barre
60			*/
61		2	size_t ProgressBarr::getMax() const{
62		2	return p_max;
63			}
64
65			///retourne la taille maximale de la barre
66			/** @return taille maximale de la barre
67			*/
68		1	size_t ProgressBarr::getSize() const{
69		1	return p_size;
70			}
71
72			///retourne le caractère de remplissage
73			/** @return caractère de remplissage
74			*/
75		1	char ProgressBarr::getChPlein() const{
76		1	return p_chPlein;
77			}
78
79			///retourne le charactère au bout de la ligne de remplissage
80			/** @return charactère au bout de la ligne de remplissage
81			*/
82		1	char ProgressBarr::getChMiddle() const{
83		1	return p_chMiddle;
84			}
85
86			///retourne le charactère de remplissage de la barre vide
87			/** @return charactère de remplissage de la barre vide
88			*/
89		1	char ProgressBarr::getChEnd() const{
90		1	return p_chEnd;
91			}
92
93			///init la valeur max atteinte par la barre
94			/** @param max : valeur max atteinte par la barre
95			*/
96		1	void ProgressBarr::setMax(size_t max){
97		1	p_max = max;
98		1	}
99
100			///init la taille de la barre
101			/** @param size : taille de la barre de chargement pleine
102			*/
103		1	void ProgressBarr::setSize(size_t size){
104		1	p_size = size;
105		1	}
106
107			///init le caractère de remplissage
108			/** @param chPlein : caractère de remplissage
109			*/
110		1	void ProgressBarr::setChPlein(char chPlein){
111		1	p_chPlein = chPlein;
112		1	}
113
114			///init le charactère au bout de la ligne de remplissage
115			/** @param chMiddle : charactère au bout de la ligne de remplissage
116			*/
117		1	void ProgressBarr::setChMiddle(char chMiddle){
118		1	p_chMiddle = chMiddle;
119		1	}
120
121			///init le charactère de remplissage de la barre vide
122			/** @param chEnd : charactère de remplissage de la barre vide
123			*/
124		1	void ProgressBarr::setChEnd(char chEnd){
125		1	p_chEnd = chEnd;
126		1	}
127
128			///affiche la barre de chargement finie
129		1	void ProgressBarr::finish(){
130		1	progress(p_max);
131		1	cout << endl;
132		1	}
133
134			///redéfinition de l'opérateur =
135			/** @param progressBarr : barre de chargement à copier
136			*/
137		2	ProgressBarr & ProgressBarr::operator = (const ProgressBarr & progressBarr){
138		2	copy(progressBarr);
139		2	return *this;
140			}
141
142			///Initialisation de la barre de progression en console
143			/** @param max : valeur maximale atteinte par barre de progression pleine
144			@param size : taille de la barre de chargement
145			@param chPlein : charactère de remplissage de la barre plein
146			@param chMiddle : charactère au bout de la ligne de remplissage
147			@param chEnd : charactère de remplissage de la barre vide
148			*/
149		4	void ProgressBarr::init(size_t max,size_t size, char chPlein, char chMiddle, char chEnd){
150		4	p_buffer = new char[size + 1lu];
151		4	p_size = size;
152		4	p_max = max;
153		4	p_chPlein = chPlein;
154		4	p_chMiddle = chMiddle;
155		4	p_chEnd = chEnd;
156		4	p_old_taille = 0lu;
157		4	}
158
159			///fonction qui copie la barre de chargement
160			/** @param progressBarr : barre de chargement à copier
161			*/
162		3	void ProgressBarr::copy(const ProgressBarr & progressBarr){
163	✓✓	3	if(p_buffer != NULL){
164	✓✗	2	delete [] p_buffer;
165			}
166		3	p_buffer = new char[progressBarr.p_size + 1]; //on pense au caractère \0
167		3	p_size = progressBarr.p_size;
168		3	p_max = progressBarr.p_max;
169		3	p_chPlein = progressBarr.p_chPlein;
170		3	p_chMiddle = progressBarr.p_chMiddle;
171		3	p_chEnd = progressBarr.p_chEnd;
172		3	p_old_taille = progressBarr.p_old_taille;
173		3	}
174
175			///affiche la barre de chargement
176			/** @param taille : taille de la barre à afficher
177			*/
178		102	void ProgressBarr::feelbuffer(size_t taille){
179	✓✓	102	if(taille <= p_size){
180	✓✓	5150	for(size_t i = 0; i < taille; ++i){
181		5050	p_buffer[i] = p_chPlein;
182			}
183		100	p_buffer[taille] = p_chMiddle;
184			}
185	✓✓	4953	for(size_t i = taille + 1; i < p_size; ++i){
186		4851	p_buffer[i] = p_chEnd;
187			}
188		102	p_buffer[p_size] = '\0';
189		102	}
190
191			///fonction qui efface la barre de chargement
192		102	void ProgressBarr::clear(){
193	✓✓	10302	for(size_t i = 0; i < p_size; ++i){
194		10200	p_buffer[i] = '\r';
195			}
196		102	p_buffer[p_size] = '\0';
197		102	}
198
199