fix unique id, << overload, add some methods

This commit is contained in:
Mylloon 2023-10-21 18:31:34 +02:00
parent 0a11b3c4d3
commit 60c6686ff6
Signed by: Anri
GPG key ID: A82D63DFF8D1317F
2 changed files with 129 additions and 12 deletions

View file

@ -2,21 +2,49 @@
#define TP5_TACHE_HPP 1 #define TP5_TACHE_HPP 1
#include <iostream> #include <iostream>
#include <vector>
class Tache { class Tache {
enum Etat { EnAttente, Realisee }; // Compteur global pour les IDs
static int counter_id;
static int unique_id; // Etat
enum Etat { EnAttente, Realisee };
friend std::ostream &operator<<(std::ostream &, const Etat &);
// ID unique de la tâche
const int unique_id;
// Durée totale pour faire la tâche
int duree_total;
// Etat actuelle de la tâche
enum Etat etat; enum Etat etat;
// Liste des dépendances
std::vector<Tache *> dependances;
friend std::ostream &operator<<(std::ostream &, const Tache &); friend std::ostream &operator<<(std::ostream &, const Tache &);
// Auxilliaire pour simplifier les copies
void _copy(const Tache &);
public: public:
Tache(); // constructor Tache(const int); // constructor
virtual ~Tache(); // destructor virtual ~Tache(); // destructor
Tache(const Tache &); // copy constructor Tache(const Tache &); // copy constructor
const Tache &operator=(const Tache &); // copy assignement const Tache &operator=(const Tache &); // copy assignement
// Déclenche la réalisation de la tâche après vérification
bool realise();
// Indique si la tâche courante dépend d'une autre
bool depends_from(const Tache &) const;
// Ajoute une dépendance si possible
bool ajouteDependance(Tache &);
// Calcule la durée totale max de réalisation d'une tâche et des dépendances
int dureeParal() const;
}; };
#endif #endif

View file

@ -1,21 +1,110 @@
#include "../includes/Tache.hpp" #include "../includes/Tache.hpp"
int Tache::unique_id = 0; int Tache::counter_id = 0;
Tache::Tache() : etat(EnAttente) { Tache::Tache(const int duree)
++unique_id; : unique_id(++counter_id), duree_total(duree), etat(EnAttente),
dependances(std::vector<Tache *>()) {}
std::cout << "Hello, tache!\n"; Tache::~Tache() {}
Tache::Tache(const Tache &src)
: unique_id(++counter_id), duree_total(src.duree_total), etat(src.etat) {
_copy(src);
} }
Tache::~Tache() { --unique_id; }
Tache::Tache(const Tache &src) : etat(src.etat) { ++unique_id; }
const Tache &Tache::operator=(const Tache &src) { const Tache &Tache::operator=(const Tache &src) {
if (this == &src) { if (this == &src) {
return *this; return *this;
} }
duree_total = src.duree_total;
etat = src.etat;
_copy(src);
return *this; return *this;
} }
std::ostream &operator<<(std::ostream &out, const Tache::Etat &data) {
switch (data) {
case Tache::EnAttente:
out << "En Attente";
break;
case Tache::Realisee:
out << "Réalisée";
break;
}
return out;
}
std::ostream &operator<<(std::ostream &out, const Tache &data) {
out << "Tâche #" << data.unique_id << " " << data.etat << " avec "
<< data.dependances.size() << " dépendances";
return out;
}
void Tache::_copy(const Tache &src) {
// Copie des dépendances
dependances.reserve(src.dependances.size());
for (Tache *t : src.dependances) {
dependances.push_back(t);
}
}
// TODO
bool Tache::realise() {
for (const Tache *const it : dependances) {
if (it->etat != Realisee) {
// Une dépendance n'est pas réalisée, donc on peut pas se réaliser
// soi-même
return false;
}
}
// TODO: Ca veux dire quoi déclencher une tâche ?
etat = Realisee;
return false;
}
bool Tache::depends_from(const Tache &x) const {
for (const Tache *const it : dependances) {
if (it->unique_id == x.unique_id) {
return true;
} else {
// On recherche récursivement parmis toutes les dépendance. Ca permett à
// `ajouteDependance` d'être sûre de pas créer de cycles au n-ème degré
return it->depends_from(x);
}
}
return false;
}
bool Tache::ajouteDependance(Tache &x) {
// On ne créer pas de dépendances cyclique aka 2 tâches
// qui dépendent l'une de l'autre
if (depends_from(x)) {
return false;
}
dependances.push_back(&x);
return true;
}
int Tache::dureeParal() const {
int ret_value = duree_total,
// La durée max permet d'éviter d'ajouter plusieurs fois une même
// dépendance
max_duree = 0;
// On regarde toutes nos dépendances
for (const Tache *const it : dependances) {
// On demande la durée max de la dépendance
int val = it->dureeParal();
// De toutes nos dépendances on garde la valeur la plus haute
if (val > max_duree) {
max_duree = val;
}
}
// On ajoute la valeur max à notre durée totale
return ret_value + max_duree;
}