| Directory: | ./ |
|---|---|
| File: | src/PComposeType.cpp |
| Date: | 2024-12-09 11:00:39 |
| Exec | Total | Coverage | |
|---|---|---|---|
| Lines: | 107 | 136 | 78.7% |
| Branches: | 5 | 11 | 45.5% |
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /*************************************** | ||
| 2 | Auteur : Pierre Aubert | ||
| 3 | Mail : pierre.aubert@lapp.in2p3.fr | ||
| 4 | Licence : CeCILL-C | ||
| 5 | ****************************************/ | ||
| 6 | |||
| 7 | |||
| 8 | |||
| 9 | |||
| 10 | #include "PComposeType.h" | ||
| 11 | |||
| 12 | ///Constructor of class PComposeType | ||
| 13 | 250 | PComposeType::PComposeType(){ | |
| 14 |
1/1✓ Branch 1 taken 250 times.
|
250 | initialisationPComposeType(); |
| 15 | 250 | } | |
| 16 | |||
| 17 | ///Copy Constructor of class PComposeType | ||
| 18 | /** @param other : PComposeType we want ot copy | ||
| 19 | */ | ||
| 20 | 79 | PComposeType::PComposeType(const PComposeType & other){ | |
| 21 |
1/1✓ Branch 1 taken 79 times.
|
79 | copyPComposeType(other); |
| 22 | 79 | } | |
| 23 | |||
| 24 | ///Destructor of class PComposeType | ||
| 25 | 658 | PComposeType::~PComposeType(){ | |
| 26 | |||
| 27 | } | ||
| 28 | |||
| 29 | ///Operator = of class PComposeType | ||
| 30 | /** @param other : PComposeType we want ot copy | ||
| 31 | * @return copied class PComposeType | ||
| 32 | */ | ||
| 33 | 104 | PComposeType & PComposeType::operator = (const PComposeType & other){ | |
| 34 | 104 | copyPComposeType(other); | |
| 35 | 104 | return *this; | |
| 36 | } | ||
| 37 | |||
| 38 | ///Sets the type of the PComposeType | ||
| 39 | /** @param type : type of the PComposeType | ||
| 40 | */ | ||
| 41 | 123 | void PComposeType::setType(const PType & type){ | |
| 42 | 123 | p_type = type; | |
| 43 | 123 | } | |
| 44 | |||
| 45 | ///Sets the vecType of the PComposeType | ||
| 46 | /** @param vecType : vecType of the PComposeType | ||
| 47 | */ | ||
| 48 | 1 | void PComposeType::setVecType(const std::vector<PComposeType> & vecType){ | |
| 49 | 1 | p_vecType = vecType; | |
| 50 | 1 | } | |
| 51 | |||
| 52 | ///Gets the type of the PComposeType | ||
| 53 | /** @return type of the PComposeType | ||
| 54 | */ | ||
| 55 | 388 | const PType & PComposeType::getType() const{ | |
| 56 | 388 | return p_type; | |
| 57 | } | ||
| 58 | |||
| 59 | ///Gets the type of the PComposeType | ||
| 60 | /** @return type of the PComposeType | ||
| 61 | */ | ||
| 62 | 2 | PType & PComposeType::getType(){ | |
| 63 | 2 | return p_type; | |
| 64 | } | ||
| 65 | |||
| 66 | ///Gets the vecType of the PComposeType | ||
| 67 | /** @return vecType of the PComposeType | ||
| 68 | */ | ||
| 69 | 264 | const std::vector<PComposeType> & PComposeType::getVecType() const{ | |
| 70 | 264 | return p_vecType; | |
| 71 | } | ||
| 72 | |||
| 73 | ///Gets the vecType of the PComposeType | ||
| 74 | /** @return vecType of the PComposeType | ||
| 75 | */ | ||
| 76 | 8 | std::vector<PComposeType> & PComposeType::getVecType(){ | |
| 77 | 8 | return p_vecType; | |
| 78 | } | ||
| 79 | |||
| 80 | ///Copy Function of class PComposeType | ||
| 81 | /** @param other : PComposeType we want ot copy | ||
| 82 | */ | ||
| 83 | 183 | void PComposeType::copyPComposeType(const PComposeType & other){ | |
| 84 | 183 | p_type = other.p_type; | |
| 85 | 183 | p_vecType = other.p_vecType; | |
| 86 | 183 | } | |
| 87 | |||
| 88 | ///Initialisation Function of class PComposeType | ||
| 89 | 250 | void PComposeType::initialisationPComposeType(){ | |
| 90 | 250 | } | |
| 91 | |||
| 92 | ///Constructor of class PComposeVar | ||
| 93 | 75 | PComposeVar::PComposeVar(){ | |
| 94 |
1/1✓ Branch 1 taken 75 times.
|
75 | initialisationPComposeVar(); |
| 95 | 75 | } | |
| 96 | |||
| 97 | ///Copy Constructor of class PComposeVar | ||
| 98 | /** @param other : PComposeVar we want ot copy | ||
| 99 | */ | ||
| 100 | ✗ | PComposeVar::PComposeVar(const PComposeVar & other){ | |
| 101 | ✗ | copyPComposeVar(other); | |
| 102 | } | ||
| 103 | |||
| 104 | ///Destructor of class PComposeVar | ||
| 105 | 150 | PComposeVar::~PComposeVar(){ | |
| 106 | |||
| 107 | } | ||
| 108 | |||
| 109 | ///Operator = of class PComposeVar | ||
| 110 | /** @param other : PComposeVar we want ot copy | ||
| 111 | * @return copied class PComposeVar | ||
| 112 | */ | ||
| 113 | 20 | PComposeVar & PComposeVar::operator = (const PComposeVar & other){ | |
| 114 | 20 | copyPComposeVar(other); | |
| 115 | 20 | return *this; | |
| 116 | } | ||
| 117 | |||
| 118 | ///Sets the type of the PComposeVar | ||
| 119 | /** @param type : type of the PComposeVar | ||
| 120 | */ | ||
| 121 | 55 | void PComposeVar::setType(const PComposeType & type){ | |
| 122 | 55 | p_type = type; | |
| 123 | 55 | } | |
| 124 | |||
| 125 | ///Sets the name of the PComposeVar | ||
| 126 | /** @param name : name of the PComposeVar | ||
| 127 | */ | ||
| 128 | 55 | void PComposeVar::setName(const std::string & name){ | |
| 129 | 55 | p_name = name; | |
| 130 | 55 | } | |
| 131 | |||
| 132 | ///Sets the value of the PComposeVar | ||
| 133 | /** @param value : value of the PComposeVar | ||
| 134 | */ | ||
| 135 | ✗ | void PComposeVar::setValue(const std::vector<char> & value){ | |
| 136 | ✗ | p_value = value; | |
| 137 | } | ||
| 138 | |||
| 139 | ///Gets the type of the PComposeVar | ||
| 140 | /** @return type of the PComposeVar | ||
| 141 | */ | ||
| 142 | 179 | const PComposeType & PComposeVar::getType() const{ | |
| 143 | 179 | return p_type; | |
| 144 | } | ||
| 145 | |||
| 146 | ///Gets the type of the PComposeVar | ||
| 147 | /** @return type of the PComposeVar | ||
| 148 | */ | ||
| 149 | 101 | PComposeType & PComposeVar::getType(){ | |
| 150 | 101 | return p_type; | |
| 151 | } | ||
| 152 | |||
| 153 | ///Gets the name of the PComposeVar | ||
| 154 | /** @return name of the PComposeVar | ||
| 155 | */ | ||
| 156 | 264 | const std::string & PComposeVar::getName() const{ | |
| 157 | 264 | return p_name; | |
| 158 | } | ||
| 159 | |||
| 160 | ///Gets the name of the PComposeVar | ||
| 161 | /** @return name of the PComposeVar | ||
| 162 | */ | ||
| 163 | 90 | std::string & PComposeVar::getName(){ | |
| 164 | 90 | return p_name; | |
| 165 | } | ||
| 166 | |||
| 167 | ///Gets the value of the PComposeVar | ||
| 168 | /** @return value of the PComposeVar | ||
| 169 | */ | ||
| 170 | 30 | const std::vector<char> & PComposeVar::getValue() const{ | |
| 171 | 30 | return p_value; | |
| 172 | } | ||
| 173 | |||
| 174 | ///Gets the value of the PComposeVar | ||
| 175 | /** @return value of the PComposeVar | ||
| 176 | */ | ||
| 177 | 70 | std::vector<char> & PComposeVar::getValue(){ | |
| 178 | 70 | return p_value; | |
| 179 | } | ||
| 180 | |||
| 181 | ///Copy Function of class PComposeVar | ||
| 182 | /** @param other : PComposeVar we want ot copy | ||
| 183 | */ | ||
| 184 | 20 | void PComposeVar::copyPComposeVar(const PComposeVar & other){ | |
| 185 | 20 | p_type = other.p_type; | |
| 186 | 20 | p_name = other.p_name; | |
| 187 | 20 | p_value = other.p_value; | |
| 188 | 20 | } | |
| 189 | |||
| 190 | ///Initialisation Function of class PComposeVar | ||
| 191 | 75 | void PComposeVar::initialisationPComposeVar(){ | |
| 192 | 75 | p_name = ""; | |
| 193 | 75 | } | |
| 194 | |||
| 195 | ///Constructor of class PFunctionPrototype | ||
| 196 | 35 | PFunctionPrototype::PFunctionPrototype(){ | |
| 197 |
1/1✓ Branch 1 taken 35 times.
|
35 | initialisationPFunctionPrototype(); |
| 198 | 35 | } | |
| 199 | |||
| 200 | ///Copy Constructor of class PFunctionPrototype | ||
| 201 | /** @param other : PFunctionPrototype we want ot copy | ||
| 202 | */ | ||
| 203 | ✗ | PFunctionPrototype::PFunctionPrototype(const PFunctionPrototype & other){ | |
| 204 | ✗ | copyPFunctionPrototype(other); | |
| 205 | } | ||
| 206 | |||
| 207 | ///Destructor of class PFunctionPrototype | ||
| 208 | 70 | PFunctionPrototype::~PFunctionPrototype(){ | |
| 209 | |||
| 210 | } | ||
| 211 | |||
| 212 | ///Operator = of class PFunctionPrototype | ||
| 213 | /** @param other : PFunctionPrototype we want ot copy | ||
| 214 | * @return copied class PFunctionPrototype | ||
| 215 | */ | ||
| 216 | 8 | PFunctionPrototype & PFunctionPrototype::operator = (const PFunctionPrototype & other){ | |
| 217 | 8 | copyPFunctionPrototype(other); | |
| 218 | 8 | return *this; | |
| 219 | } | ||
| 220 | |||
| 221 | ///Sets the name of the PFunctionPrototype | ||
| 222 | /** @param name : name of the PFunctionPrototype | ||
| 223 | */ | ||
| 224 | 24 | void PFunctionPrototype::setName(const std::string & name){ | |
| 225 | 24 | p_name = name; | |
| 226 | 24 | } | |
| 227 | |||
| 228 | ///Sets the vecReturnType of the PFunctionPrototype | ||
| 229 | /** @param vecReturnType : vecReturnType of the PFunctionPrototype | ||
| 230 | */ | ||
| 231 | ✗ | void PFunctionPrototype::setVecReturnType(const std::vector<PComposeType> & vecReturnType){ | |
| 232 | ✗ | p_vecReturnType = vecReturnType; | |
| 233 | } | ||
| 234 | |||
| 235 | ///Sets the vecParam of the PFunctionPrototype | ||
| 236 | /** @param vecParam : vecParam of the PFunctionPrototype | ||
| 237 | */ | ||
| 238 | ✗ | void PFunctionPrototype::setVecParam(const std::vector<PComposeType> & vecParam){ | |
| 239 | ✗ | p_vecParam = vecParam; | |
| 240 | } | ||
| 241 | |||
| 242 | ///Gets the name of the PFunctionPrototype | ||
| 243 | /** @return name of the PFunctionPrototype | ||
| 244 | */ | ||
| 245 | 40 | const std::string & PFunctionPrototype::getName() const{ | |
| 246 | 40 | return p_name; | |
| 247 | } | ||
| 248 | |||
| 249 | ///Gets the name of the PFunctionPrototype | ||
| 250 | /** @return name of the PFunctionPrototype | ||
| 251 | */ | ||
| 252 | 30 | std::string & PFunctionPrototype::getName(){ | |
| 253 | 30 | return p_name; | |
| 254 | } | ||
| 255 | |||
| 256 | ///Gets the vecReturnType of the PFunctionPrototype | ||
| 257 | /** @return vecReturnType of the PFunctionPrototype | ||
| 258 | */ | ||
| 259 | 68 | const std::vector<PComposeType> & PFunctionPrototype::getVecReturnType() const{ | |
| 260 | 68 | return p_vecReturnType; | |
| 261 | } | ||
| 262 | |||
| 263 | ///Gets the vecReturnType of the PFunctionPrototype | ||
| 264 | /** @return vecReturnType of the PFunctionPrototype | ||
| 265 | */ | ||
| 266 | 4 | std::vector<PComposeType> & PFunctionPrototype::getVecReturnType(){ | |
| 267 | 4 | return p_vecReturnType; | |
| 268 | } | ||
| 269 | |||
| 270 | ///Gets the vecParam of the PFunctionPrototype | ||
| 271 | /** @return vecParam of the PFunctionPrototype | ||
| 272 | */ | ||
| 273 | 34 | const std::vector<PComposeType> & PFunctionPrototype::getVecParam() const{ | |
| 274 | 34 | return p_vecParam; | |
| 275 | } | ||
| 276 | |||
| 277 | ///Gets the vecParam of the PFunctionPrototype | ||
| 278 | /** @return vecParam of the PFunctionPrototype | ||
| 279 | */ | ||
| 280 | 44 | std::vector<PComposeType> & PFunctionPrototype::getVecParam(){ | |
| 281 | 44 | return p_vecParam; | |
| 282 | } | ||
| 283 | |||
| 284 | ///Copy Function of class PFunctionPrototype | ||
| 285 | /** @param other : PFunctionPrototype we want ot copy | ||
| 286 | */ | ||
| 287 | 8 | void PFunctionPrototype::copyPFunctionPrototype(const PFunctionPrototype & other){ | |
| 288 | 8 | p_name = other.p_name; | |
| 289 | 8 | p_vecReturnType = other.p_vecReturnType; | |
| 290 | 8 | p_vecParam = other.p_vecParam; | |
| 291 | 8 | } | |
| 292 | |||
| 293 | ///Initialisation Function of class PFunctionPrototype | ||
| 294 | 35 | void PFunctionPrototype::initialisationPFunctionPrototype(){ | |
| 295 | 35 | p_name = ""; | |
| 296 | 35 | } | |
| 297 | |||
| 298 | ///Constructor of class PFunctionCall | ||
| 299 | 20 | PFunctionCall::PFunctionCall(){ | |
| 300 |
1/1✓ Branch 1 taken 20 times.
|
20 | initialisationPFunctionCall(); |
| 301 | 20 | } | |
| 302 | |||
| 303 | ///Copy Constructor of class PFunctionCall | ||
| 304 | /** @param other : PFunctionCall we want ot copy | ||
| 305 | */ | ||
| 306 | ✗ | PFunctionCall::PFunctionCall(const PFunctionCall & other){ | |
| 307 | ✗ | copyPFunctionCall(other); | |
| 308 | } | ||
| 309 | |||
| 310 | ///Destructor of class PFunctionCall | ||
| 311 | 40 | PFunctionCall::~PFunctionCall(){ | |
| 312 | |||
| 313 | } | ||
| 314 | |||
| 315 | ///Operator = of class PFunctionCall | ||
| 316 | /** @param other : PFunctionCall we want ot copy | ||
| 317 | * @return copied class PFunctionCall | ||
| 318 | */ | ||
| 319 | ✗ | PFunctionCall & PFunctionCall::operator = (const PFunctionCall & other){ | |
| 320 | ✗ | copyPFunctionCall(other); | |
| 321 | ✗ | return *this; | |
| 322 | } | ||
| 323 | |||
| 324 | ///Sets the prototype of the PFunctionCall | ||
| 325 | /** @param prototype : prototype of the PFunctionCall | ||
| 326 | */ | ||
| 327 | ✗ | void PFunctionCall::setPrototype(const PFunctionPrototype & prototype){ | |
| 328 | ✗ | p_prototype = prototype; | |
| 329 | } | ||
| 330 | |||
| 331 | ///Sets the vecParam of the PFunctionCall | ||
| 332 | /** @param vecParam : vecParam of the PFunctionCall | ||
| 333 | */ | ||
| 334 | ✗ | void PFunctionCall::setVecParam(const std::vector<std::vector<char> > & vecParam){ | |
| 335 | ✗ | p_vecParam = vecParam; | |
| 336 | } | ||
| 337 | |||
| 338 | ///Sets the vecResult of the PFunctionCall | ||
| 339 | /** @param vecResult : vecResult of the PFunctionCall | ||
| 340 | */ | ||
| 341 | ✗ | void PFunctionCall::setVecResult(const std::vector<std::vector<char> > & vecResult){ | |
| 342 | ✗ | p_vecResult = vecResult; | |
| 343 | } | ||
| 344 | |||
| 345 | ///Gets the prototype of the PFunctionCall | ||
| 346 | /** @return prototype of the PFunctionCall | ||
| 347 | */ | ||
| 348 | 30 | const PFunctionPrototype & PFunctionCall::getPrototype() const{ | |
| 349 | 30 | return p_prototype; | |
| 350 | } | ||
| 351 | |||
| 352 | ///Gets the prototype of the PFunctionCall | ||
| 353 | /** @return prototype of the PFunctionCall | ||
| 354 | */ | ||
| 355 | 70 | PFunctionPrototype & PFunctionCall::getPrototype(){ | |
| 356 | 70 | return p_prototype; | |
| 357 | } | ||
| 358 | |||
| 359 | ///Gets the vecParam of the PFunctionCall | ||
| 360 | /** @return vecParam of the PFunctionCall | ||
| 361 | */ | ||
| 362 | ✗ | const std::vector<std::vector<char> > & PFunctionCall::getVecParam() const{ | |
| 363 | ✗ | return p_vecParam; | |
| 364 | } | ||
| 365 | |||
| 366 | ///Gets the vecParam of the PFunctionCall | ||
| 367 | /** @return vecParam of the PFunctionCall | ||
| 368 | */ | ||
| 369 | 50 | std::vector<std::vector<char> > & PFunctionCall::getVecParam(){ | |
| 370 | 50 | return p_vecParam; | |
| 371 | } | ||
| 372 | |||
| 373 | ///Gets the vecResult of the PFunctionCall | ||
| 374 | /** @return vecResult of the PFunctionCall | ||
| 375 | */ | ||
| 376 | ✗ | const std::vector<std::vector<char> > & PFunctionCall::getVecResult() const{ | |
| 377 | ✗ | return p_vecResult; | |
| 378 | } | ||
| 379 | |||
| 380 | ///Gets the vecResult of the PFunctionCall | ||
| 381 | /** @return vecResult of the PFunctionCall | ||
| 382 | */ | ||
| 383 | 30 | std::vector<std::vector<char> > & PFunctionCall::getVecResult(){ | |
| 384 | 30 | return p_vecResult; | |
| 385 | } | ||
| 386 | |||
| 387 | ///Copy Function of class PFunctionCall | ||
| 388 | /** @param other : PFunctionCall we want ot copy | ||
| 389 | */ | ||
| 390 | ✗ | void PFunctionCall::copyPFunctionCall(const PFunctionCall & other){ | |
| 391 | ✗ | p_prototype = other.p_prototype; | |
| 392 | ✗ | p_vecParam = other.p_vecParam; | |
| 393 | ✗ | p_vecResult = other.p_vecResult; | |
| 394 | } | ||
| 395 | |||
| 396 | ///Initialisation Function of class PFunctionCall | ||
| 397 | 20 | void PFunctionCall::initialisationPFunctionCall(){ | |
| 398 | 20 | } | |
| 399 | |||
| 400 |