Ajout des classes Alphabet/State/StateColor

include/alphabet.hpp

+/**
+\file alphabet.hpp
+\date 01/05/2021
+\author Arthur Detree
+\version 1
+\brief Alphabet
+
+Représente l'ensemble des états et de leurs informations (couleur, label) d'une configuration.
+                                                             **/
+
+#ifndef ALPHABET_H
+#define ALPHABET_H
+
+#include "state.hpp"
+#include "stateColor.hpp"
+
+#include <exception>
+
+class AlphabetException : public std::exception
+{
+public:
+    AlphabetException(const std::string& what)
+        : m_what(what)
+    {}
+
+    const char* what() const noexcept
+    { return m_what.c_str(); }
+
+private:
+    const std::string m_what;
+};
+
+
+class Alphabet {
+    //! Pointe sur un tableau de pointeurs de states
+    state** etats;
+    //! Nombre d'états réels dans l'alphabet
+    unsigned int nbEtats;
+    //! Nombre d'états désirés par l'utilisateur
+    unsigned int nbMaxEtats;
+
+    //! Constructeur de l'Alphabet
+    Alphabet():etats(nullptr),nbEtats(0),nbMaxEtats(0){}
+    ~Alphabet();
+
+public:
+    //! Renvoie l'alphabet
+    static Alphabet& getAlphabet() {static Alphabet a; return a;}
+    //! Renvoie le nombre d'états de l'alphabet
+    unsigned taille() const { return nbEtats; }
+    //! Crée un nouvel état
+    void newEtat(const state& s);
+    //! Renvoie l'état en fonction de son identifiant
+    state getState(unsigned int it);
+    //! Affecte l'identifiant d'état à un état
+    void setState(unsigned int i, const state& s);
+
+};
+
+#endif // ALPHABET_H

include/state.hpp

+/**
+\file state.hpp
+\date 01/05/2021
+\author Arthur Detree
+\version 1
+\brief state
+
+Représente les données graphiques associées à un état d'un alphabet.
+        **/
+
+#ifndef STATE_H
+#define STATE_H
+
+#include <string>
+
+#include "stateColor.hpp"
+
+class state{
+    //! Couleur de l'état --> C'est un objet stateColor dont les attributs sont rouge, vert, bleu
+    stateColor color;
+    //! Nom de l'état
+    std::string label;
+
+public:
+    //! Constructeur de l'état
+    state(stateColor c, const std::string& l = "sans nom"):color(c),label(l){}
+
+    //! Accesseur en lecture de la couleur
+    stateColor getColor() const { return color; }
+    //! Accesseur en lecture du label
+    std::string getStateLabel() const { return label; }
+
+    //! Accesseur en écriture de la couleur
+    void setColor(stateColor c){ color=c; }
+    //! Accesseur en écriture du label
+    void setStateLabel(const std::string& l){ label=l; }
+};
+
+#endif // STATE_H

include/stateColor.hpp

+/**
+\file stateColor.hpp
+\date 01/05/2021
+\author Arthur Detree
+\version 1
+\brief stateColor
+
+Représente la couleur associée à un état.
+**/
+
+
+#ifndef STATECOLOR_H
+#define STATECOLOR_H
+
+class stateColor{ // Chaque objet stateColor (couleur) est décrit par trois attributs (RGB)
+    unsigned char redColor;
+    unsigned char greenColor;
+    unsigned char blueColor;
+
+public:
+    //! Constructeur d'un objet stateColor prenant en compte 3 arguments (RGB)
+    stateColor(unsigned char r, unsigned char g, unsigned char b):redColor(r),greenColor(g),blueColor(b){}
+
+    //! Méthode de redéfinition d'une couleur prenant en compte 3 arguments (RGB)
+    void setColor(unsigned char r, unsigned char g, unsigned char b)
+    {redColor = r; greenColor = g; blueColor = b;}
+
+    //! Accesseur en lecture de la couleur Rouge
+    char getRed() const{ return redColor; }
+    //! Accesseur en lecture de la couleur Verte
+    char getGreen() const{ return greenColor; }
+    //! Accesseur en lecture de la couleur Bleue
+    char getBlue() const{ return blueColor; }
+};
+
+#endif // STATECOLOR_H

src/alphabet.cpp

+/**
+\file alphabet.cpp
+\date 01/05/2021
+\author Arthur Detree
+\version 1
+\brief Alphabet
+        **/
+
+#include "alphabet.hpp"
+#include "state.hpp"
+#include "stateColor.hpp"
+
+Alphabet::~Alphabet(){ // Définition du destructeur de la classe Alphabet : On supprime tous les états
+    if (etats)
+    {
+        for(unsigned int i=0 ; i<nbEtats ; i++){
+            delete etats[i];
+        }
+        delete[] etats;
+    }
+}
+
+void Alphabet::newEtat(const state& s){ // Définition de la méthode de création d'état
+    if(nbEtats==nbMaxEtats){ // Si l'Alphabet est "plein"
+        state** newtab = new state*[nbMaxEtats+1]; // On alloue dynamiquement un nouveau tableau
+        for(unsigned int i=0 ; i<nbEtats ; i++){
+            newtab[i]=etats[i]; // On affecte les états de etats vers le nouveau tableau
+        }
+        nbMaxEtats=nbMaxEtats+1;
+        state** old=etats;
+        etats=newtab; // Notre etats devient le nouveau tableau
+        delete[] old; // On supprime l'ancien
+    }
+    etats[nbEtats++]=new state(s.getColor(), s.getStateLabel()); // On affecte à notre nbEtats+1 emplacement l'état défini par son identifiant, couleur et nom
+}
+
+state Alphabet::getState(unsigned int it){ // Définition de la méthode de récupération d'un état en fonction de son identifiant
+    if (it < nbEtats)
+    {
+        return *etats[it];
+    }
+    else
+        throw AlphabetException("ID d'état invalide");
+}
+
+void Alphabet::setState(unsigned int it, const state &s){ // Méthode permettant de modifier un identifiant d'un état. On se doit de vérifier si l'identifiant que veut donner n'a pas déjà été attribué
+    if (it < nbEtats)
+    {
+        *etats[it] = s;
+    }
+    else
+        throw AlphabetException("ID d'état invalide");
+}
+

src/src.pro

@@ -12,6 +12,7 @@ TEMPLATE = app
 INCLUDEPATH += ../include
 
 SOURCES += \
+    alphabet.cpp \
     arbitraryneighborhoodrule.cpp \
     gridview.cpp \
     main.cpp \
@@ -40,6 +41,9 @@ HEADERS += \
     ../include/gridview.hpp \
     ../include/interface.hpp \
     ../include/grid.h \
+    ../include/alphabet.hpp \
+    ../include/stateColor.hpp \
+    ../include/state.hpp \
     ../include/history.h
 
 FORMS += \