diff --git a/includes/Projet.hpp b/includes/Projet.hpp index a10dfed..c89f1fe 100644 --- a/includes/Projet.hpp +++ b/includes/Projet.hpp @@ -10,24 +10,34 @@ class Projet { //Héritage de tache ? //Tache fin; - std::vector taches; + std::vector taches; friend std::ostream &operator<<(std::ostream &, const Projet &); public: - Projet(); // constructor + Projet(); + Projet(std::vector taches); // constructor virtual ~Projet(); // destructor Projet(const Projet &); // copy constructor const Projet &operator=(const Projet &); // copy assignement + std::vector getTaches(){ + return taches; + } + // Retourne une paire d'indentifiants de tâches au hasard std::pair 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 consult_tasks(); + const std::vector consult_tasks() const{ + return taches; + }; + + // Corrige les éventuelles anomalies du vector de tâches + const std::vector topologicalSort(); }; #endif diff --git a/includes/ProtoProjet.hpp b/includes/ProtoProjet.hpp index 2a28556..64ee0d0 100644 --- a/includes/ProtoProjet.hpp +++ b/includes/ProtoProjet.hpp @@ -1,17 +1,30 @@ #ifndef TP5_PROTOPROJET_HPP #define TP5_PROTOPROJET_HPP 1 +#include +#include #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 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 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 diff --git a/includes/Tache.hpp b/includes/Tache.hpp index 563ec3a..93f1fdb 100644 --- a/includes/Tache.hpp +++ b/includes/Tache.hpp @@ -2,16 +2,49 @@ #define TP5_TACHE_HPP 1 #include +#include 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 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 diff --git a/src/Projet.cpp b/src/Projet.cpp index 33844c1..53d9a33 100644 --- a/src/Projet.cpp +++ b/src/Projet.cpp @@ -1,6 +1,8 @@ #include "../includes/Projet.hpp" -Projet::Projet() { std::cout << "Hello, project!\n"; } +Projet::Projet(std::vector taches){ taches=taches;} + +Projet::Projet() {} Projet::~Projet() {} @@ -25,18 +27,22 @@ std::pair 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 consult_tasks(){ - +const std::vector topologicalSort(){ + //Recupere le calcul fait par PP_postfixe et construit son tri + //PP_postfixe(this->taches); } + diff --git a/src/ProtoProjet.cpp b/src/ProtoProjet.cpp index 0a695b5..b4edcb5 100644 --- a/src/ProtoProjet.cpp +++ b/src/ProtoProjet.cpp @@ -1,6 +1,11 @@ #include "../includes/ProtoProjet.hpp" -ProtoProjet::ProtoProjet() { std::cout << "Hello, protoProject!\n"; } +ProtoProjet::ProtoProjet(std::vector 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){ + +} diff --git a/src/Tache.cpp b/src/Tache.cpp index e4f0d9c..af17f4a 100644 --- a/src/Tache.cpp +++ b/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(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; +}