GCC Code Coverage Report

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