make it compile

includes/Projet.hpp

@@ -1,43 +1,43 @@
 #ifndef TP5_PROJET_HPP
 #define TP5_PROJET_HPP 1
 
-#include <iostream>
-#include <vector>
-#include <utility>
 #include "../includes/Tache.hpp"
+#include <iostream>
+#include <utility>
+#include <vector>
 
+struct Projet {
+  // Alias parce que le type est long
+  using VecTaches = std::vector<std::pair<Tache *, bool>>;
+
+private:
+  // Héritage de tache ?
+  // Tache fin;
+  VecTaches taches;
 
-class Projet {
-  //Héritage de tache ?
-  //Tache fin;
-  std::vector<Tache *, bool> taches;
   friend std::ostream &operator<<(std::ostream &, const Projet &);
 
 public:
-  Projet();
+  Projet();          // constructor
-  Projet(std::vector<Tache *, bool> taches);          // constructor
+  Projet(VecTaches); // constructor
   virtual ~Projet(); // destructor
 
   Projet(const Projet &);                  // copy constructor
   const Projet &operator=(const Projet &); // copy assignement
 
-  std::vector<Tache *, bool> getTaches(){
+  VecTaches getTaches() { return taches; }
-    return taches;
-  }
 
   // Retourne une paire d'indentifiants de tâches au hasard
-  std::pair <int, int> pick_two_random_tasks();
+  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 *contains(int id);
 
   // Donne une version du vecteur de tâches non modifiable
-  const std::vector<Tache *, bool> consult_tasks() const{
+  const VecTaches consult_tasks() const { return taches; };
-    return taches;
-  };
 
   // Corrige les éventuelles anomalies du vector de tâches
-  const std::vector<Tache *, bool> topologicalSort();
+  const VecTaches topologicalSort();
 };
 
 #endif

includes/ProtoProjet.hpp

@@ -3,25 +3,24 @@
 
 #include <iostream>
 #include <vector>
+
 #include "Projet.hpp"
 
 class ProtoProjet : public Projet {
-  Tache debut;
+  /* Tache taches; */
-  Tache fin;
   friend std::ostream &operator<<(std::ostream &, const ProtoProjet &);
 
 public:
-  ProtoProjet(std::vector<Tache *, bool> taches, Tache debut, Tache fin);          // constructor
+  ProtoProjet();
+  ProtoProjet(VecTaches 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(){
+  void 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);

includes/Tache.hpp

@@ -4,6 +4,8 @@
 #include <iostream>
 #include <vector>
 
+struct Projet;
+
 class Tache {
   // Compteur global pour les IDs
   static int counter_id;
@@ -23,6 +25,7 @@ class Tache {
   std::vector<Tache *> dependances;
 
   friend std::ostream &operator<<(std::ostream &, const Tache &);
+  friend Projet;
 
   // Auxilliaire pour simplifier les copies
   void _copy(const Tache &);

src/Projet.cpp

@@ -1,9 +1,9 @@
 #include "../includes/Projet.hpp"
 
-Projet::Projet(std::vector<Tache *, bool> taches){ taches=taches;}
-
 Projet::Projet() {}
 
+Projet::Projet(VecTaches t) : taches(t) {}
+
 Projet::~Projet() {}
 
 Projet::Projet(const Projet &) {}
@@ -16,33 +16,42 @@ const Projet &Projet::operator=(const Projet &src) {
   return *this;
 }
 
-std::pair <int, int> Projet::pick_two_random_tasks(){
+std::pair<int, int> Projet::pick_two_random_tasks() {
   int size = this->taches.size();
   int rand1 = rand() % size;
   int rand2 = rand() % size;
-  if(this->taches[rand1]->depends_from(*this->taches[rand2])) pick_two_random_tasks();
+  if (this->taches[rand1].first->depends_from(*this->taches[rand2].first))
-  //Heritage de tache ?
+    pick_two_random_tasks();
-  int id1 = this->taches[rand1]->unique_id;
+
-  int id2 = this->taches[rand2]->unique_id;
+  // Heritage de tache ?
+  int id1 = this->taches[rand1].first->unique_id;
+  int id2 = this->taches[rand2].first->unique_id;
   return std::make_pair(id1, id2);
 }
 
-//Comment acceder à unique_id ici ?
+// Comment acceder à unique_id ici ?
-Tache *Projet::contains(int id){
+Tache *Projet::contains(int id) {
-  for(Tache *t:this->taches)
+  for (auto t : this->taches) {
-    if(id==t->unique_id) return t;
+    if (id == t.first->unique_id) {
+      return t.first;
+    }
+  }
+
   return nullptr;
 }
 
-//Comment acceder à taches ici ?
+// Comment acceder à taches ici ?
-std::ostream& operator<<(std::ostream &out, Projet &x){
+std::ostream &operator<<(std::ostream &out, const Projet &data) {
-  for(Tache *t: x.taches)
+  for (auto t : data.taches) {
-    out << *t;
+    out << t.first << " is " << std::boolalpha << t.second;
+  }
+
   return out;
 }
 
-const std::vector<Tache *, bool> topologicalSort(){
+const Projet::VecTaches Projet::topologicalSort() {
-  //Recupere le calcul fait par  PP_postfixe et construit son tri
+  // Recupere le calcul fait par  PP_postfixe et construit son tri
-  //PP_postfixe(this->taches);
+  // PP_postfixe(this->taches);
-}
 
+  return VecTaches(); /* TODO */
+}

src/ProtoProjet.cpp

@@ -1,15 +1,17 @@
 #include "../includes/ProtoProjet.hpp"
 
-ProtoProjet::ProtoProjet(std::vector<Tache *, bool> taches, Tache debut, Tache fin) { 
+ProtoProjet::ProtoProjet() {}
-  taches=taches; 
+
-  taches.push_back(debut);
+ProtoProjet::ProtoProjet(VecTaches t, Tache debut, Tache fin) : Projet(t) {
-  taches.push_back(fin);
+  /* taches.push_back(debut);
+  taches.push_back(fin); */
   debut.ajouteDependance(fin);
-  }
+}
 
 ProtoProjet::~ProtoProjet() {}
 
-ProtoProjet::ProtoProjet(const ProtoProjet &) {}
+ProtoProjet::ProtoProjet(const ProtoProjet &src)
+    : Projet(VecTaches() /* TODO*/) {}
 
 const ProtoProjet &ProtoProjet::operator=(const ProtoProjet &src) {
   if (this == &src) {
@@ -19,6 +21,12 @@ const ProtoProjet &ProtoProjet::operator=(const ProtoProjet &src) {
   return *this;
 }
 
-bool ajoute(std::string nom, int duree){
+void ProtoProjet::cleanMarks() {
+  for (auto t : this->getTaches()) {
+    t.second = false;
+  }
+};
 
+bool ProtoProjet::ajoute(std::string nom, int duree) {
+  return false; /* TODO */
 }