avancement Projet et ProtoProjet

includes/Projet.hpp

@@ -10,24 +10,34 @@
 class Projet {
   //Héritage de tache ?
   //Tache fin;
-  std::vector<Tache *> taches;
+  std::vector<Tache *, bool> taches;
   friend std::ostream &operator<<(std::ostream &, const Projet &);
 
 public:
-  Projet();          // constructor
+  Projet();
+  Projet(std::vector<Tache *, bool> taches);          // constructor
   virtual ~Projet(); // destructor
 
   Projet(const Projet &);                  // copy constructor
   const Projet &operator=(const Projet &); // copy assignement
 
+  std::vector<Tache *, bool> getTaches(){
+    return taches;
+  }
+
   // Retourne une paire d'indentifiants de tâches au hasard
   std::pair <int, int> pick_two_random_tasks();
 
   // Indique pour une tâche si elle fait partie du projet
-  Tache Projet::contains(int id);
+  Tache* Projet::contains(int id);
 
   // Donne une version du vecteur de tâches non modifiable
-  std::vector<Tache *> consult_tasks();
+  const std::vector<Tache *, bool> consult_tasks() const{
+    return taches;
+  };
+
+  // Corrige les éventuelles anomalies du vector de tâches
+  const std::vector<Tache *, bool> topologicalSort();
 };
 
 #endif

includes/ProtoProjet.hpp

@@ -1,17 +1,30 @@
 #ifndef TP5_PROTOPROJET_HPP
 #define TP5_PROTOPROJET_HPP 1
 
+#include <iostream>
+#include <vector>
 #include "Projet.hpp"
 
 class ProtoProjet : public Projet {
+  Tache debut;
+  Tache fin;
   friend std::ostream &operator<<(std::ostream &, const ProtoProjet &);
 
 public:
-  ProtoProjet();          // constructor
+  ProtoProjet(std::vector<Tache *, bool> taches, Tache debut, Tache fin);          // constructor
   virtual ~ProtoProjet(); // destructor
 
   ProtoProjet(const ProtoProjet &);                  // copy constructor
   const ProtoProjet &operator=(const ProtoProjet &); // copy assignement
+
+  // Remet tous les marquages à leur valeur initiale
+  std::vector<Tache *, bool> cleanMarks(){
+    for(bool t:this->getTaches())
+      t=false;
+  };
+  
+  // Insère une nouvelle tâche en la plaçant entre deux tâches au hasars
+  bool ajoute(std::string nom, int duree);
 };
 
 #endif

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/Projet.cpp

@@ -1,6 +1,8 @@
 #include "../includes/Projet.hpp"
 
-Projet::Projet() { std::cout << "Hello, project!\n"; }
+Projet::Projet(std::vector<Tache *, bool> taches){ taches=taches;}
+
+Projet::Projet() {}
 
 Projet::~Projet() {}
 
@@ -25,18 +27,22 @@ std::pair <int, int> Projet::pick_two_random_tasks(){
   return std::make_pair(id1, id2);
 }
 
-Tache Projet::contains(int id){
+//Comment acceder à unique_id ici ?
+Tache *Projet::contains(int id){
   for(Tache *t:this->taches)
-    if(id==t->unique_id) return *t;
+    if(id==t->unique_id) return t;
   return nullptr;
 }
 
+//Comment acceder à taches ici ?
 std::ostream& operator<<(std::ostream &out, Projet &x){
   for(Tache *t: x.taches)
     out << *t;
     return out;
 }
 
-std::vector<Tache *> consult_tasks(){
+const std::vector<Tache *, bool> topologicalSort(){
-
+  //Recupere le calcul fait par  PP_postfixe et construit son tri
+  //PP_postfixe(this->taches);
 }
+

src/ProtoProjet.cpp

@@ -1,6 +1,11 @@
 #include "../includes/ProtoProjet.hpp"
 
-ProtoProjet::ProtoProjet() { std::cout << "Hello, protoProject!\n"; }
+ProtoProjet::ProtoProjet(std::vector<Tache *, bool> taches, Tache debut, Tache fin) { 
+  taches=taches; 
+  taches.push_back(debut);
+  taches.push_back(fin);
+  debut.ajouteDependance(fin);
+  }
 
 ProtoProjet::~ProtoProjet() {}
 
@@ -13,3 +18,7 @@ const ProtoProjet &ProtoProjet::operator=(const ProtoProjet &src) {
 
   return *this;
 }
+
+bool ajoute(std::string nom, int duree){
+  
+}

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;
+}