projet stuff

TODO.md

@@ -12,22 +12,23 @@ TODO avant rendu :
 
 ### Projet
 
-- [ ] Se décompose en tâches
+- [x] Ne dois **pas** être instanciée directement
-- [ ] Durée totale dépend du degré de parallélisme que le gestionnaire décide
+- [x] Se décompose en tâches (vecteur de tâches)
-- [ ] Deux natures de projets dépendantent de `Projet`
+- [x] Durée totale dépend du degré de parallélisme que le gestionnaire décide
+- [x] Deux natures de projets dépendantent de `Projet`
   - En cours d'élaboration (`ProtoProjet`)
   - En cours d'exécution (`RunProjet`)
-- Peut être vu comme un graphe acyclique (utilisation de `vector`) des tâches
+- [x] Peut être vu comme un graphe acyclique (utilisation de `vector`) des tâches
   - Les sommets sont des tâches
   - Une tâche `fin` servira de source au graphe
 - Garder un ordre topologique (triée par dépendances)
-- [ ] Mère des deux classes `ProtoProjet` et `RunProjet`
+- [x] Mère des deux classes `ProtoProjet` et `RunProjet`
-- [ ] Méthodes utiles qu'à ses sous-classes
+- [x] Méthodes utiles qu'à ses sous-classes
 - Méthodes (cf. le PDF du prof)
-  - [ ] `pick_two_random_tasks()`
+  - [x] `pick_two_random_tasks()`
   - [ ] `contains()`
-  - [ ] Surcharge : afficher toutes les tâches
+  - [x] Surcharge : afficher toutes les tâches
-  - [ ] `consult_tasks()`
+  - [ ] `consult_tasks()` <!-- faudrait testé si elles sont vraiment pas modifiable avant de cocher cette case -->
   - [ ] `topologicalSort()`
 
 #### ProtoProjet

includes/Projet.hpp

@@ -3,38 +3,37 @@
 
 #include "../includes/Tache.hpp"
 
-struct Projet {
+class Projet {
-  // Alias parce que le type est long
+  // Graphe acyclique
-  using VecTaches = std::vector<std::pair<Tache *, bool>>;
+  std::vector<Tache *> taches;
 
-private:
+  // Première tâche qui sera exécutée
-  // Héritage de tache ?
+  const Tache debut;
-  // Tache fin;
+
-  VecTaches taches;
+  // Source du graphe aka la dernière à être exécutée
+  const Tache fin;
 
   friend std::ostream &operator<<(std::ostream &, const Projet &);
 
-public:
+protected:
   Projet();          // constructor
-  Projet(VecTaches); // constructor
   virtual ~Projet(); // destructor
 
   Projet(const Projet &);                  // copy constructor
   const Projet &operator=(const Projet &); // copy assignement
 
-  VecTaches getTaches() { return taches; }
-
   // Retourne une paire d'indentifiants de tâches au hasard
-  std::pair<int, int> pick_two_random_tasks();
+  const std::pair<const int, const int> pick_two_random_tasks() const;
 
   // Indique pour une tâche si elle fait partie du projet
-  Tache *contains(int id);
+  const Tache *contains(const int) const;
+  const Tache *contains(const std::string) const;
 
   // Donne une version du vecteur de tâches non modifiable
-  const VecTaches consult_tasks() const { return taches; };
+  const std::vector<Tache *> consult_tasks() const;
 
   // Corrige les éventuelles anomalies du vector de tâches
-  const VecTaches topologicalSort();
+  void topologicalSort() const;
 };
 
 #endif

includes/ProtoProjet.hpp

@@ -8,19 +8,17 @@ class ProtoProjet : public Projet {
   friend std::ostream &operator<<(std::ostream &, const ProtoProjet &);
 
 public:
-  ProtoProjet();
+  ProtoProjet();          // constructor
-  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
-  void cleanMarks();
+  /* void cleanMarks();
 
   // Insère une nouvelle tâche en la plaçant entre deux tâches au hasars
-  bool ajoute(std::string nom, int duree);
+  bool ajoute(std::string nom, int duree); */
 };
 
 #endif

src/Projet.cpp

@@ -1,12 +1,12 @@
 #include "../includes/Projet.hpp"
 
-Projet::Projet() {}
+Projet::Projet() : debut(Tache("Début", 0)), fin(Tache("Fin", 0)) {
-
+  fin.depends_from(debut);
-Projet::Projet(VecTaches t) : taches(t) {}
+}
 
 Projet::~Projet() {}
 
-Projet::Projet(const Projet &) {}
+Projet::Projet(const Projet &src) : debut(src.debut), fin(src.fin) {}
 
 const Projet &Projet::operator=(const Projet &src) {
   if (this == &src) {
@@ -16,42 +16,59 @@ const Projet &Projet::operator=(const Projet &src) {
   return *this;
 }
 
-std::pair<int, int> Projet::pick_two_random_tasks() {
+std::ostream &operator<<(std::ostream &out, const Projet &data) {
+  for (Tache *t : data.taches) {
+    out << *t << " ";
+  }
+
+  return out;
+}
+
+const std::pair<const int, const int> Projet::pick_two_random_tasks() const {
+  // Choix aléatoire d'une tâche
   size_t size = this->taches.size();
   size_t rand1 = static_cast<size_t>(rand()) % size;
   size_t rand2 = static_cast<size_t>(rand()) % size;
-  if (this->taches[rand1].first->depends_from(*this->taches[rand2].first))
-    pick_two_random_tasks();
 
-  // Heritage de tache ?
+  Tache *tache1 = this->taches[rand1];
-  int id1 = this->taches[rand1].first->unique_id;
+  Tache *tache2 = this->taches[rand2];
-  int id2 = this->taches[rand2].first->unique_id;
+
+  // - tache2 ne doit pas dépendre transitivement de tache1
+  // - permet aussi de vérifier si tache1 == tache2
+  if (tache2->depends_from(*tache1)) {
+    return pick_two_random_tasks();
+  }
+
+  int id1 = tache1->unique_id;
+  int id2 = tache2->unique_id;
   return std::make_pair(id1, id2);
 }
 
-// Comment acceder à unique_id ici ?
+const Tache *Projet::contains(const int id) const {
-Tache *Projet::contains(int id) {
+  for (Tache *t : this->taches) {
-  for (auto t : this->taches) {
+    if (id == t->unique_id) {
-    if (id == t.first->unique_id) {
+      return t;
-      return t.first;
     }
   }
 
   return nullptr;
 }
 
-// Comment acceder à taches ici ?
+const Tache *Projet::contains(const std::string name) const {
-std::ostream &operator<<(std::ostream &out, const Projet &data) {
+  for (Tache *t : this->taches) {
-  for (auto t : data.taches) {
+    if (name == t->name) {
-    out << t.first << " is " << std::boolalpha << t.second;
+      return t;
+    }
   }
 
-  return out;
+  return nullptr;
 }
 
-const Projet::VecTaches Projet::topologicalSort() {
+const std::vector<Tache *> Projet::consult_tasks() const { return taches; }
+
+void Projet::topologicalSort() const {
   // Recupere le calcul fait par  PP_postfixe et construit son tri
   // PP_postfixe(this->taches);
 
-  return VecTaches(); /* TODO */
+  return;
 }

src/ProtoProjet.cpp

@@ -2,15 +2,9 @@
 
 ProtoProjet::ProtoProjet() {}
 
-ProtoProjet::ProtoProjet(VecTaches t, Tache debut, Tache fin) : Projet(t) {
-  /* taches.push_back(debut);
-  taches.push_back(fin); */
-  debut.ajouteDependance(fin);
-}
-
 ProtoProjet::~ProtoProjet() {}
 
-ProtoProjet::ProtoProjet(const ProtoProjet &) : Projet(VecTaches() /* TODO*/) {}
+ProtoProjet::ProtoProjet(const ProtoProjet &) : Projet() {}
 
 const ProtoProjet &ProtoProjet::operator=(const ProtoProjet &src) {
   if (this == &src) {
@@ -20,12 +14,12 @@ const ProtoProjet &ProtoProjet::operator=(const ProtoProjet &src) {
   return *this;
 }
 
-void ProtoProjet::cleanMarks(){
+/* void ProtoProjet::cleanMarks(){
-    /* for (auto t : this->getTaches()) {
+    for (auto t : this->getTaches()) {
       t.second = false;
-    } */
+    }
 };
 
-bool ProtoProjet::ajoute(std::string /* nom */, int /* duree */) {
+bool ProtoProjet::ajoute(std::string nom, int duree) {
-  return false; /* TODO */
+  return false;
-}
+} */