table de decharge presque fini + electeur presque fini

src/Bulletin.cpp

+#include "Bulletin.hpp"
+
+Bulletin::Bulletin(Personne::Candidat *c):candi_(c){
+    this->validite_ = true;
+};
+
+Bulletin::Bulletin(){
+    this->validite_ = true;
+}
+
+Personne::Candidat Bulletin::getCandi(){
+    return *(this->candi_);
+}

src/Bulletin.hpp

+#ifndef BULLETIN_HPP
+#define BULLETIN_HPP
+
+#include <iostream>
+#include <string>
+#include <queue>
+#include"Personne.hpp"
+using namespace elections;
+
+class Bulletin{
+    private:
+        Personne::Candidat *candi_;
+        bool validite_;
+    public:
+        Bulletin(Personne::Candidat *c);
+        Bulletin();
+        Personne::Candidat getCandi();
+};
+
+#endif
\ No newline at end of file

src/BulletinBlanc.cpp

+#include "BulletinBlanc.hpp"
+
+BulletinBlanc::BulletinBlanc():Bulletin(nullptr){};
\ No newline at end of file

src/BulletinBlanc.hpp

+#ifndef BULLETINBLANC_HPP
+#define BULLETINBLANC_HPP
+
+#include "Bulletin.hpp"
+
+class BulletinBlanc : Bulletin{
+    public:
+        BulletinBlanc(){};
+};
+
+#endif
\ No newline at end of file

src/BureauVote.hpp

@@ -3,7 +3,6 @@
 
 #include <iostream>
 #include <string>
-#include <set>
 #include <queue>
 #include"Personne.hpp"
 #include"TableDeDecharge.hpp"
@@ -14,15 +13,11 @@
 class BureauVote{
     private:
         bool ouverture_;
-        std::queue<elections::Personne> fAttente_;
+        std::queue<Electeur> fAttente_;
         TableDeDecharge tabDech_;
         Isoloirs iso_;
         TableDeVote tabVote_;
-        std::set<Personne> listeElectorale;
     public:
-        BureauVote();//TODO qu'est-ce qu'on initialise ?? 
-        
-
         bool estOuvert();
         void allerTabDecharge(Electeur P);
         void allerIsoloir(Electeur P);

src/Electeur.cpp

+#include "Electeur.hpp"
+
+    /** Constructeur.
+     * \param nom    nom de l'électeur
+     * \param prenom prénom de l'électeur
+     * \param spol   sensibilité politique (entier entre 1 et 10)
+     */
+Electeur::Electeur(const std::string& nom, const std::string& prenom, int spol) : Personne(nom, prenom, spol),duree_(0) {}
+
+
+//Choix de le bultin du candidat ayant le spol le plus proche de la l'électeur
+std::vector<Bulletin> Electeur::prendreBulletinLePlusProche(std::vector<Bulletin> bulletins){
+    Bulletin buletinLePlusProche;
+    int indRetrait;
+    std::vector<Bulletin> bulletinsDispo = bulletins;
+
+    buletinLePlusProche = (bulletinsDispo)[0];
+    indRetrait = 0;
+    
+    for(long unsigned int i = 1; i< (bulletinsDispo).size(); i++){
+        std::cout<<"        test "<<i<<"\n";
+        if( (bulletinsDispo)[i].getCandi().spol() < buletinLePlusProche.getCandi().spol()){
+            std::cout<<"============test "<<i<<"\n";
+            buletinLePlusProche = (bulletinsDispo)[i];
+            indRetrait = i;
+        }
+    }
+    this->listeBulltins_.push_back(buletinLePlusProche);
+    bulletinsDispo.erase(bulletinsDispo.begin()+ indRetrait); //A VERIF que le bon bulletin soit retiré
+    return bulletinsDispo;
+}
+
+//Choisir un nombre aléatoire de bultins aléatoire a mettre en plus dans this->listeBulltins_
+void Electeur::prendreBulletinAleatoire(std::vector<Bulletin> bulletinsDispo, int probaBultinBlanc_){
+    std::srand(std::time(nullptr));
+
+    int indRetrait;
+    int nbBulletinsPris;
+    bool peutEtreBlanc;
+    peutEtreBlanc = true;
+
+    //choix du nombre de bulletins pris
+    nbBulletinsPris = (std::rand()%(bulletinsDispo.size()-1))+1;
+    //choix aléatoire des bulletins
+    while(nbBulletinsPris > 0){
+        if(!peutEtreBlanc){
+            indRetrait = rand()%bulletinsDispo.size()-1;
+            this->listeBulltins_.push_back(bulletinsDispo[indRetrait]);
+            bulletinsDispo.erase(bulletinsDispo.begin()+indRetrait);
+        }
+        else{
+            if(probaBultinBlanc_ > rand()%101){
+                Bulletin B = Bulletin(nullptr);
+                this->listeBulltins_.push_back(B);
+                peutEtreBlanc = false;
+            }
+            else{
+                indRetrait = rand()%bulletinsDispo.size()-1;
+                this->listeBulltins_.push_back(bulletinsDispo[indRetrait]);
+                bulletinsDispo.erase(bulletinsDispo.begin()+indRetrait);
+            }
+        }
+        nbBulletinsPris -=1;
+    }
+}
+
+
+void Electeur::prendreBulletin(std::vector<Bulletin> bulletins, int probaBultinBlanc_){
+    std::cout<<"-----test 1\n";
+    std::vector<Bulletin> bulletinsDispo = prendreBulletinLePlusProche(bulletins);
+    std::cout<<"-----test 2\n";
+    prendreBulletinAleatoire(bulletinsDispo, probaBultinBlanc_);
+    std::cout<<"-----test 3\n";
+}
+
+void Electeur::choisirVote(){
+
+}
+
+int Electeur::getDuree_(){return this->duree_;}
+void Electeur::setDuree_(int duree){this->duree_ = duree;}
+
+    
\ No newline at end of file

src/Electeur.hpp

@@ -4,18 +4,29 @@
 #include <iostream>
 #include <string>
 #include <queue>
+#include <ctime>
+#include <cstdlib>
 #include"Personne.hpp"
-#include"TableDeDecharge.hpp"
-#include"Isoloirs.hpp"
-#include"TableDeVote.hpp"
+#include"BulletinBlanc.hpp"
 
 class Electeur : Personne{
     private:
-        
+        int duree_; // la durée sur chaque étape
+        std::vector<Bulletin> listeBulltins_;
+        std::string bulltinChoisi_;
     public:
-        int tempsSortie;
-        std::vector<std::string> listeBulltins;
-        std::string bulltinChoisi;
+        Electeur(const std::string& nom, const std::string& prenom, int spol);
+        
+        void prendreBulletin(std::vector<Bulletin> bulletinsDispo, int probaBultinBlanc_);
+        std::vector<Bulletin> prendreBulletinLePlusProche(std::vector<Bulletin> bulletins);
+        void prendreBulletinAleatoire(std::vector<Bulletin> bulletinsDispo, int probaBultinBlanc_);
+
+
+        void choisirVote();
+        void voter();
+
+        int getDuree_();
+        void setDuree_(int duree);
 };
 
 #endif
\ No newline at end of file

src/Isoloirs.cpp

@@ -32,9 +32,9 @@ void Isoloirs::avancerQueue(int nbPlaceLibre){
         }
 }
 
-std::queue<elections::Personne> Isoloirs::sortieIsoloirs(){
+std::queue<Electeur> Isoloirs::sortieIsoloirs(){
         //on enleve les membre de la file qui ont dépassé le temps de vote
-        std::queue<elections::Personne> listeSortie;
+        std::queue<Electeur> listeSortie;
         while( !(this->PersVoteEnCours.empty()) && (this->PersVoteEnCours.front().tempsSortie<tempsTotal_)){
                 listeSortie.push(this->PersVoteEnCours.front().pers);
                 this->PersVoteEnCours.pop();
@@ -79,4 +79,4 @@ void Isoloirs::affPersVoteEnCours(){
         else{
                 std::cout<<"file des personnes qui votes vide."<<std::endl;
         }
-}
+}
\ No newline at end of file

src/Isoloirs.hpp

@@ -5,6 +5,7 @@
 #include <string>
 #include <queue>
 #include"Personne.hpp"
+#include"Electeur.hpp"
 using namespace elections;
 
 class Isoloirs{
@@ -64,7 +65,7 @@ class Isoloirs{
             int nbIsoloirOccupe_;
             int dureeIsoloir_;                      //en unité de temps arbitraire (int)
             int tempsTotal_;                        //temps total passé dans le système
-            std::queue<elections::Personne> fAttente_;
+            std::queue<Electeur> fAttente_;
             std::queue<isoloir> PersVoteEnCours;
 };
 

src/Makefile

@@ -3,7 +3,7 @@ CFLAGS=-Wall -std=c++17
 INCLUDES=
 LIBS=
 TARGET=main
-OBJ=main.o Personne.o Isoloirs.o
+OBJ=main.o Personne.o TableDeDecharge.o Bulletin.o Electeur.o
 
 all : $(TARGET)
 
@@ -14,4 +14,4 @@ $(TARGET) : $(OBJ)
 	$(CXX) -o $(TARGET) $(OBJ) $(LIBS)
 
 %.o: %.cpp
-	$(CXX) $(CFLAGS) $(INCLUDES) -o $@ -c $<
+	$(CXX) $(CFLAGS) $(INCLUDES) -o $@ -c $<
\ No newline at end of file

src/Personne.cpp

@@ -40,4 +40,4 @@ std::ostream& operator<<(std::ostream& os, const Personne& psn)
    return os;
 }
 
-} // namespace
+} // namespaces
\ No newline at end of file

src/Personne.hpp

@@ -19,6 +19,8 @@ namespace elections {
  */
 class Personne {
 public:
+   typedef Personne Candidat;
+
    /**
     * Constructeur.
     * \param nom    nom de la personne
@@ -97,4 +99,4 @@ std::ostream& operator<<(std::ostream& os, const Personne& psn);
 
 } // namespace
 
-#endif
+#endif
\ No newline at end of file

src/TableDeDecharge.cpp

 #include "TableDeDecharge.hpp"
 
-TableDeDecharge::TableDeDecharge(std::vector<std::string> bulletins):bulletins_(bulletins){
-    this->occup_ = false;
+TableDeDecharge::TableDeDecharge(std::vector<Bulletin> bulletins,int duree):bulletins_(bulletins),occup_(false),dureeDecharge_(duree){
+    this->occupant_ = nullptr;
 }
 
 bool TableDeDecharge::estOccupe(){
     return this->occup_;
 }
 
-void TableDeDecharge::prendreBultin(){
+void TableDeDecharge::entrerTableDecharge(Electeur* e){
+        (*e).setDuree_(this->dureeDecharge_);
+        //si la table est occupée, l'électeur entre dans la file d'attente sinon il peut entrer directement sur la table de décharge.
+        if(this->estOccupe()){
+                this->fAttente_.push(e);
+        }
+        else{
+                this->occupant_ = e;
+                this->occup_ = true;
+        }
+}
+
+Electeur* TableDeDecharge::sortirTableDecharge(){
+    std::cout<<"---test 1\n";
+    (*this->occupant_).prendreBulletin(this->bulletins_,this->probaBultinBlanc_);  //peut être déplacé dans une autre méthode pour le faire a un autre moment mais fonctionnel quand même
+    std::cout<<"il y a "<<this->bulletins_.size()<<" bulletins."<<std::endl;
+    std::cout<<"---test 2\n";
+    this->occup_ = false;
+    std::cout<<"---test 3\n";
+    return this->occupant_;
+}
+
+//la fonction va faire avancer la file quitte a recouvrir l'occupant actuel de la table
+void TableDeDecharge::avancerFile(){
+    this->occupant_ = this->fAttente_.front();
+    this->fAttente_.pop();
+    this->occup_ = true;
+}
+
+Electeur* TableDeDecharge::avancerTemps(){
+    std::cout<<"test 1\n";
 
+    (*this->occupant_).setDuree_((*this->occupant_).getDuree_() - 1);
+    std::cout<<"test 2\n";
+    if((*this->occupant_).getDuree_() == 0){
+        std::cout<<"test 3\n";
+        
+        Electeur* sorti = sortirTableDecharge();
+        std::cout<<"test 4\n";
+        avancerFile();
+        std::cout<<"test 5\n";
+
+        return sorti;
+    }
+    std::cout<<"test 6\n";
+    return nullptr;
 }
 
+/*
+void TableDeDecharge::afficherTable() {
+    std::cout << "État de la table de décharge :\n";
+    if(this->estOccupe()){
+        std::cout<<" Occupé "<<std::endl;
+    }else{
+        std::cout <<" Libre "<<std::endl;
+    }
+    if (!this->fAttente_.empty()) {
+        std::cout << "File d'attente :\n";
+        std::queue<Electeur*> file = this->fAttente_;
+        int i = 1;
+        if(this->fAttente_.size()>0){
+                std::cout<<"------------------------------------------"<<std::endl;
+                for(long unsigned int i = 0; i< this->fAttente_.size(); i++){
+                        std::cout<< i<<". id : "<<this->fAttente_.front().Personne::id()<<"\n  nom :"<<this->fAttente_.nom()<<"\n  prenom :"<<this->PersVoteEnCours.front().pers.prenom()<<std::endl;
+                        std::cout<<"------------------------------------------"<<std::endl;
+                        this->fAttente_.push(this->fAttente_.front());
+                        this->fAttente_.pop();
+                }
+        } else {
+            std::cout << "Pas d'électeurs en attente\n";
+        }
+    }
+}
+*/
\ No newline at end of file

src/TableDeDecharge.hpp

@@ -5,19 +5,85 @@
 #include <string>
 #include <vector>
 #include <queue>
-#include"Personne.hpp"
+#include <cmath>
+#include"Electeur.hpp"
+#include"Bulletin.hpp"
+
 using namespace elections;
 
 class TableDeDecharge{
     private:
-        std::vector<std::string> bulletins_;
-        bool occup_; // true si la table est occuppée
-        std::queue<elections::Personne> fAttente_;
+        /**
+         * la liste des bulletins disponible sur la table
+        */
+        std::vector<Bulletin> bulletins_;
+        /**
+         * le booléen qui montre si la table est occupée
+         * true -> la table est occupé
+         * false -> la table n'est pas occupée
+        */
+        bool occup_;
+        /**
+         * un pointeur vers l'electeur occupant la table
+        */
+        Electeur* occupant_;
+        /**
+         * la file d'attente
+        */
+        std::queue<Electeur*> fAttente_;
+        /**
+         * la durée que les electeurs passent sur la table de décharge
+        */
+        int dureeDecharge_;
+        /**
+         * La probabilité qu'un bultin blanc sois prit
+        */
+        int probaBultinBlanc_;
 
     public:
-        TableDeDecharge(std::vector<std::string> bulletins);
+        /**
+         * constructeur de la classe TableDeDecharge
+         * @param std::vector<Bulletin> bulletins
+         * @param int duree
+        */
+        TableDeDecharge(std::vector<Bulletin> bulletins, int duree);
+        
+        /**
+         * fonction qui renvoie si la table est occupée
+         * @return true si occupé
+        */
         bool estOccupe();
-        void prendreBultin();
+
+        /**
+         * fonction qui avance le temps de 1 T. Elle avance le temps a passer dans la table et appel SortirTableDecharge() si nécessaire pour les envoyer a l'isoire par la suite.
+         * @return Electeur* un pointeur vers un electeur. Le pointeur est utilisé pour pouvoir ne rien renvoyer si nécessaire. 
+        */
+        Electeur* avancerTemps(); //avance le déroulé du temps sur la table de décharge
+        
+        /**
+         * procédure qui permet a un Electeur de rentrer dans la tableDeDecharge ou au moins dans la file d'attente si elle est déjà occupée.
+         * @param Electeur* un pointeur vers un electeur qui va rentrer dans la table de decharge.
+         * @return void
+        */
+        void entrerTableDecharge(Electeur* e);
+
+        /**
+         * Procédure qui permet de faire avancer la file d'attente en replaçant l'Electeur déjà présent sur la table
+         * @return void
+        */
+        void avancerFile();
+
+        /**
+         * Fonction qui fais sortir un Electeur de la table de décharge en la rendant disponible au suivant
+         * @return Electeur* un pointeur vers un electeur
+        */
+        Electeur* sortirTableDecharge();
+
+        /**
+         * affichage terminal de la table de décharge (non utilisé dans le code final)
+        */
+        //void afficherTable() {};
+
 };
 
 #endif
\ No newline at end of file

src/TableDeVote.hpp

@@ -4,18 +4,16 @@
 #include <iostream>
 #include <string>
 #include <queue>
-#include"Personne.hpp"
+#include "Electeur.hpp"
 using namespace elections;
 
 class TableDeVote{
     public:
 
     private:
-        int nbIsoloir_;
-        int nbIsoloirOccupe_;
-        int dureeIsoloir_;                      //en unité de temps arbitraire (int)
-        int tempsTotal_;                        //temps total passé dans le système
-        std::queue<elections::Personne> fAttente_;
+        //URNE CLASSE ?
+        //EMARGEMENT ENSEMBLE (SET)
+        std::queue<Electeur> fAttente_;
 };
 
 #endif
\ No newline at end of file

src/main.cpp

@@ -7,7 +7,8 @@
 #include <ctime>
 #include <iostream>
 #include <vector>
-#include "Personne.hpp"
+#include "TableDeDecharge.hpp"
+#include <queue>
 
 using namespace std;
 using namespace elections;
@@ -31,6 +32,48 @@ int main(void)
       new Personne("Z", "pat", 8)
    };
 
+    // initialisation du générateur de nombres aléatoires
+    std::srand(static_cast<unsigned int>(std::time(nullptr)));
+
+    // création des bulletins
+    std::vector<Bulletin> bulletins = {
+        Bulletin(vp[1]), // Remplacez nullptr par un pointeur valide vers un candidat
+        Bulletin(vp[2]),
+        Bulletin(vp[3]),
+        Bulletin(vp[4])
+    };
+
+    // Création d'une table de décharge avec une durée de 3 tours
+    TableDeDecharge table(bulletins, 2);
+
+    // Création des électeurs
+    std::vector<Electeur*> electeurs = {
+        new Electeur("Alice", "Dupont", 7),
+        new Electeur("Bob", "Martin", 5),
+        new Electeur("Claire", "Lefevre", 9)
+    };
+
+    // Test de l'entrée des électeurs dans la table de décharge
+    for (Electeur* electeur : electeurs) {
+        table.entrerTableDecharge(electeur);
+    }
+
+    // Avancement du temps sur la table de décharge
+    for (int i = 0; i < 6; ++i) { // Avancer le temps de 4 tours
+        std::cout<<"-------------------------------------------------\n";
+        std::cout << "Tour " << i << " :\n";
+        Electeur* sorti = table.avancerTemps();
+        if (sorti) {
+            std::cout << sorti << " a terminé et est sorti de la table.\n";
+            delete sorti; // N'oubliez pas de supprimer l'électeur après utilisation
+        }
+    }
+/*
+    // Destruction des électeurs
+    for (Electeur* electeur : electeurs) {
+        delete electeur;
+    }
+*/
 
    // TODO
    // Code de simulation dans lequel on manipulera les personnes
@@ -43,4 +86,4 @@ int main(void)
    }
 
    return 0;
-}
+}
\ No newline at end of file