refactor

includes/Tache.hpp

@@ -2,16 +2,49 @@
 #define TP5_TACHE_HPP 1
 
 #include <iostream>
+#include <vector>
 
 class Tache {
+  // Compteur global pour les IDs
+  static int counter_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/ProtoProjet.cpp

@@ -4,7 +4,7 @@ ProtoProjet::ProtoProjet() { std::cout << "Hello, protoProject!\n"; }
 
 ProtoProjet::~ProtoProjet() {}
 
-ProtoProjet::ProtoProjet(const ProtoProjet &) {}
+ProtoProjet::ProtoProjet(const ProtoProjet &) : Projet() {}
 
 const ProtoProjet &ProtoProjet::operator=(const ProtoProjet &src) {
   if (this == &src) {

src/RunProjet.cpp

@@ -4,7 +4,7 @@ RunProjet::RunProjet() { std::cout << "Hello, runProject!\n"; }
 
 RunProjet::~RunProjet() {}
 
-RunProjet::RunProjet(const RunProjet &) {}
+RunProjet::RunProjet(const RunProjet &) : ProtoProjet() {}
 
 const RunProjet &RunProjet::operator=(const RunProjet &src) {
   if (this == &src) {

src/Tache.cpp

@@ -1,15 +1,111 @@
 #include "../includes/Tache.hpp"
 
-Tache::Tache() { std::cout << "Hello, tache!\n"; }
+int Tache::counter_id = 0;
+
+Tache::Tache(const int duree)
+    : unique_id(++counter_id), duree_total(duree), etat(EnAttente),
+      dependances(std::vector<Tache *>()) {}
 
 Tache::~Tache() {}
 
-Tache::Tache(const Tache &) {}
+void Tache::_copy(const Tache &src) {
+  // Copie des dépendances
+  dependances.reserve(src.dependances.size());
+  for (Tache *t : src.dependances) {
+    dependances.push_back(t);
+  }
+}
+
+Tache::Tache(const Tache &src)
+    : unique_id(++counter_id), duree_total(src.duree_total), etat(src.etat) {
+  _copy(src);
+}
 
 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;
+}
+
+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 permet à
+      // `ajouteDependance` d'être sûre de pas créer de cycles au n-ème degré
+      if (it->depends_from(x)) {
+        return true;
+      }
+    }
+  }
+  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;
+}