From 4564e76aa3447eb10b8c05e6237c906658f907dc Mon Sep 17 00:00:00 2001 From: Mylloon Date: Fri, 27 Oct 2023 18:52:27 +0200 Subject: [PATCH] a lu le pdf! --- TODO.md | 97 ++++++++++++++++++++++++++++++++++++++++++++-- includes/Tache.hpp | 2 +- src/Tache.cpp | 1 + src/main.cpp | 31 ++++++++++++++- 4 files changed, 125 insertions(+), 6 deletions(-) diff --git a/TODO.md b/TODO.md index 7a46e68..c033098 100644 --- a/TODO.md +++ b/TODO.md @@ -2,7 +2,96 @@ TODO avant rendu : -- [ ] "Vous remettrez en plus de votre code une page rédigée montrant que vous - avez tenu compte de certaines problématiques de copies/sécurité etc en - expliquant en français non technique comment vous les avez traitées" -- [ ] Écrire un "écrirez un petit jeu de test, clair" +- [ ] Page rédigée montrant que l'on a tenu compte des problématiques de copies et sécurité (private/public) en expliquant en français non technique comment vous les avez traitées (`x` à pas accès à `y`) +- [ ] Écrire des tests pour montrer que ça fonctionne + +## Notes + +- [ ] Toute classe doit être surchargée avec `<<` +- [ ] Gestion satisfaisante des copies, affectation, destruction + +### Projet + +- [ ] Se décompose en tâches +- [ ] Durée totale dépend du degré de parallélisme que le gestionnaire décide +- [ ] 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 + - 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` +- [ ] Méthodes utiles qu'à ses sous-classes +- Méthodes (cf. le PDF du prof) + - [ ] `pick_two_random_tasks()` + - [ ] `contains()` + - [ ] Surcharge : afficher toutes les tâches + - [ ] `consult_tasks()` + - [ ] `topologicalSort()` + +#### ProtoProjet + +- [ ] Permet de pouvoir ajouter de nouvelles tâches +- [ ] Ne peut pas progresser (a.k.a ne peut pas lancer les tâches) +- Champs + - [ ] Tâche `début` + - [ ] Tâche `fin` +- Méthodes (cf. le PDF du prof) **⇒ Tout ça avec l'ordre topologique** + - [ ] Pas de méthode d'ajout d'un objet `Tache` + - [ ] `bool ajoute(nom, durée)` : sélectionne au hasard 2 tâches déjà + enregistrer et **ajoute** la nouvelle tâche entres-elles + - [ ] `bool ajoute(nom, durée, id)` : **déplace** une tâche quoi doit se réaliser + **après** la tâche qui à l'`id` correspondant (et avant la tâche finale) + - [ ] `bool ajoute(nom, durée, id1, id2)` : **ajoute** une tâche entre les 2 tâches + qui ont l'identifiant `id1` et `id2` + +#### RunProjet + +- [ ] Construit uniquement via un `ProtoProjet` +- [ ] Avance vers sa conclusion en prenant en compte des tâches ponctuelles +- [ ] Vide le contenu d'un `ProtoProjet` pour se construire, rendre les tâches "read-only" +- Méthodes (cf. le PDF du prof) + - [ ] `run(id)` : Lance une tâche + - [ ] `run(sequence_taches)` : Exécute une liste de tâches dans l'ordre donnée + +### Gestionnaire / Concepteur + +- [ ] Étudie/Analyse des `RunProjet` +- [ ] Interagis avec un `ProtoProjet` pour y mettre des tâches +- [ ] Recommande des ordonnancements pour la suite des exécutions à venir + (ordre d'exécutions des tâches) +- [ ] Calcule la durée totale restante d'un projet +- [ ] Demande un salaire pour travailler +- Méthodes + - [ ] Surcharge `<<` : Affiche une facturation + - [ ] `pair, int> avis(const RunProjet &)` : renvoie l'ordonnancement + et la durée totale restante + +#### Consultant + +Calcule **sans** parallélisation des tâches + +#### Expert + +Calcule **avec** parallélisation des tâches + +### Tâches + +- [x] Dépendantes, entre-elles +- [x] Durée exacte, fixe, propre à elle-même +- [x] Ne peut être lancé que si toutes les dépendances sont réalisées +- [x] Dépendances = autres tâches +- [x] Élément atomique (final) +- Champs + - [ ] Nom + - [x] Numéro unique + - [x] État (réalisée/en attente) + - Réalisée → En attente : **interdit** + - En attente → Réalisée : **autorisé** + - [x] Vision locale des dépendances (`vector`) +- Méthodes (cf. le PDF du prof) + - [x] `bool realise()` + - [x] `bool depends_from(Tache & x)` + - [x] `bool ajouteDependance(Tache & x)` + - [x] `int dureeParal()` diff --git a/includes/Tache.hpp b/includes/Tache.hpp index e939a3f..d8360f4 100644 --- a/includes/Tache.hpp +++ b/includes/Tache.hpp @@ -6,7 +6,7 @@ struct Projet; -class Tache { +class Tache final { // Compteur global pour les IDs static int counter_id; diff --git a/src/Tache.cpp b/src/Tache.cpp index af17f4a..9adda29 100644 --- a/src/Tache.cpp +++ b/src/Tache.cpp @@ -59,6 +59,7 @@ bool Tache::realise() { } } + // TODO: Faire une vérification si le temps est écoulée // TODO: Ca veux dire quoi déclencher une tâche ? etat = Realisee; return false; diff --git a/src/main.cpp b/src/main.cpp index 06e216a..4cff930 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1 +1,30 @@ -int main(int argc, char const *argv[]) { return 0; } +#include "../includes/Consultant.hpp" +#include "../includes/Expert.hpp" +#include "../includes/RunProjet.hpp" + +using namespace std; + +int main() { + + /* ProtoProjet pp; + + pp.ajoute("a", 10); // probablement numero 2 + cout << pp; // avec ses 3 taches + cout << "----------" << endl; + + pp.ajoute("b", 15, 0, 1); // en supposant que 0: fin et 1: début + cout << pp; + cout << "----------" << endl; + + RunProjet rp{pp}; + cout << "----- verification : ProtoProjet vide " << endl; + cout << pp << endl; + + Consultant c; + cout << c.avis(rp).second << endl; // dira 25 + + Expert e; + cout << e.avis(rp).second << endl; // dira 15 */ + + return EXIT_SUCCESS; +}