fix unique id, << overload, add some methods

includes/Tache.hpp

@@ -2,21 +2,49 @@
 #define TP5_TACHE_HPP 1
 
 #include <iostream>
+#include <vector>
 
 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;
+  // Liste des dépendances
+  std::vector<Tache *> dependances;
 
   friend std::ostream &operator<<(std::ostream &, const Tache &);
 
+  // Auxilliaire pour simplifier les copies
+  void _copy(const Tache &);
+
 public:
-  Tache();          // constructor
+  Tache(const int); // constructor
   virtual ~Tache(); // destructor
 
   Tache(const Tache &);                  // copy constructor
   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

src/Tache.cpp

@@ -1,21 +1,110 @@
 #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) {
   if (this == &src) {
     return *this;
   }
-
+  duree_total = src.duree_total;
+  etat = src.etat;
+  _copy(src);
   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;
+}