Ajout AutomateHeureMinutes & ajout mode debug & rajout de docs pour tout les...

Ajout AutomateHeureMinutes & ajout mode debug & rajout de docs pour tout les automates et certaines fonctions & ajout classe Color pour couleurs du texte dans terminal & optimisations code

BUT2/Automates/ApplicationAutomates/src/main/kotlin/Automate.kt

@@ -6,19 +6,32 @@
  * @property etats_finaux indique les états finaux possibles de l'automate accepteur
  * @property actions contient tout les elements presents dans l'automate permettant les transitions entre etats
  */
-abstract class Automate(protected var nom : String) {
-    protected var etats : MutableList<Etat> = mutableListOf()//Set
-    protected var etat_initial : Etat? = null
-    protected var etats_finaux : MutableList<Etat> = mutableListOf()//Set
+abstract class Automate(private var nom : String) {
+    private var etats : MutableList<Etat> = mutableListOf()//Set
+    private var etat_initial : Etat? = null
+    private var etats_finaux : MutableList<Etat> = mutableListOf()//Set
     protected var actions : MutableList<String> = arrayListOf()
 
     fun getThisEtats() = this.etats
-    fun getEtatByIndex(index : Int) = this.getThisEtats().get(index-1)
+
+    /**
+     * Retourne l'Etat à la position numero-1 dans etats
+     *
+     * @param numero le numero de l'Etat correspond c-à-d son index+1
+     */
+    fun getEtatByIndex(numero : Int) = this.getThisEtats()[numero-1]
     fun addEtat(etat : Etat) = this.etats.add(etat)
     fun addEtats(etats : Array<Etat>) = this.etats.addAll(etats)
     fun removeEtat(etat : Etat) = this.etats.remove(etat)
-    fun createAndAddEtats(nbr_etats : Int){
-        for (i in 1..nbr_etats){
+
+    /**
+     * Crée et ajoute automatiquement n Etat et les ajoutent à cet Automate
+     *
+     * @param n le nombre d'états à créer
+     * @return création et ajout de n Etat avec leur nom etant E1, E2,..., En
+     */
+    fun createAndAddEtats(n : Int){
+        for (i in 1..n){
             this.addEtat(Etat("E$i"))
         }
     }
@@ -26,17 +39,22 @@ abstract class Automate(protected var nom : String) {
     fun setEtatInitial(index_etat: Int){ this.etat_initial = this.getEtatByIndex(index_etat) }
 
     fun getEtatsFinaux() = this.etats_finaux
-    fun addEtatFinal(index_etat : Int) = this.etats_finaux.add(this.getEtatByIndex(index_etat)!!)
+    fun addEtatFinal(index_etat : Int) = this.etats_finaux.add(this.getEtatByIndex(index_etat))
     fun removeEtatFinal(etat : Etat) = this.etats_finaux.remove(etat)
+
+    /**
+     * Indique si l'Etat donné en parametre est un état final ou pas
+     * @param etat un Etat
+     * @return true si il est final false sinon
+     */
     fun isFinal(etat : Etat?) = etats_finaux.contains(etat)
 
     fun addTransition(index_etat_depart : Int, action: String, index_etat_sortant : Int){
-        var etat_depart = this.getEtatByIndex(index_etat_depart)
-        var etat_sortant = this.getEtatByIndex(index_etat_sortant)
+        val etat_depart = this.getEtatByIndex(index_etat_depart)
+        val etat_sortant = this.getEtatByIndex(index_etat_sortant)
+
+        etat_depart.addTransition(action, etat_sortant)
 
-        if (etat_depart!=null || etat_sortant!=null){
-            etat_depart!!.addTransition(action, etat_sortant!!)
-        }
 
     }
     fun addTransitions(index_etat_depart : Int, actions: List<String>, index_etat_sortant : Int){
@@ -45,7 +63,7 @@ abstract class Automate(protected var nom : String) {
         }
 
     }
-    fun removeTransition(etat_depart : Etat, action: String, etat_sortant : Etat){
+    fun removeTransition(etat_depart : Etat, action: String){
         etat_depart.removeTransition(action)
     }
 
@@ -54,22 +72,38 @@ abstract class Automate(protected var nom : String) {
      *  @param chaine une phrase à analyser
      *  @return affiche dans la sortie standard le résultat de la validation de la phrase selon l'automate actuel
      */
-    fun resolv(chaine : String){
+    fun resolv(chaine : String, debug : Boolean = false){
 
         var etat_courant = this.etat_initial
         var index = 0
-
+        if (debug) {
+            println(Color.DEBUG.code)
+        }
         while ( (!this.isFinal(etat_courant)) && (etat_courant != null) && (index < chaine.length)){
-            var char_courant = chaine[index]
+            val char_courant = chaine[index]
+
+            if (debug){
+                println("char courant : $char_courant")
+                println("état avant transi : $etat_courant")
+            }
+
             etat_courant = etat_courant.getEtatSortant(char_courant)
+
+            if (debug){
+                println("état après transi : $etat_courant")
+            }
+
             index++
         }
 
         //Verifie que l'etat actuel est l'etat final et qu'il ne reste rien a parcourir dans la chaine
-        if (this.isFinal(etat_courant) && (index == chaine.length-1)){
-            println("Bravo.")
+        if (debug){
+            println("état d'arrivée :  $etat_courant \nétats finaux valables : ${this.getEtatsFinaux()}")
+        }
+        if (this.isFinal(etat_courant) && (index == chaine.length)){
+            println(Color.SUCCESS.code + " Mot valide " + Color.RESET.code)
         }else{
-            println("Pas Bravo")
+            println(Color.FAIL.code + " Mot invalide " + Color.RESET.code)
         }
 
     }

BUT2/Automates/ApplicationAutomates/src/main/kotlin/AutomateHeureMinutes.kt

+/**
+ * Automate accepteur permettant la résolution d'heures formatés comme suit :
+ *
+ * HH:MM avec HH = 00..23 et MM = 00.59
+ */
+class AutomateHeureMinutes() : Automate("HH:MM") {
+    init {
+        //ajout des actions
+        this.actions = mutableListOf("0","1","2","3","4","5","6","7","8","9",":")
+
+        //ajout des états
+        this.createAndAddEtats(7)
+
+        //ajout des transitions
+        this.addTransitions(1, listOf("0","1"),2)
+        this.addTransition(1,"2",3)
+
+        this.addTransitions(2, listOf("0","1","2","3","4","5","6","7","8","9") ,4)
+
+        this.addTransitions(3, listOf("0","1","2","3") ,4)
+
+        this.addTransition(4, ":" ,5)
+
+        this.addTransitions(5, listOf("0","1","2","3","4","5") ,6)
+
+        this.addTransitions(6, listOf("0","1","2","3","4","5","6","7","8","9") ,7)
+
+        //ajout des etats initiaux et terminaux
+        this.setEtatInitial(1)
+        this.addEtatFinal(7)
+    }
+}
\ No newline at end of file

BUT2/Automates/ApplicationAutomates/src/main/kotlin/AutomateJourMoisAnnee.kt

+/**
+ * Automate accepteur permettant la résolution de dates formatés comme suit :
+ *
+ * JJ/MM/AAAA avec JJ = 01..31, MM = 01..12 et AAAA = 0001..9999
+ *
+ * /!\Cet Automate ne prend pas en compte les années bissextiles donc fevrier contient toujours 28jours ici/!\
+ */
 class AutomateJourMoisAnnee() : Automate("JJ:MM:AAAA") {
     init {
         //ajout des actions

BUT2/Automates/ApplicationAutomates/src/main/kotlin/AutomateOneToFiftySeven.kt

+/**
+ * Automate accepteur permettant la résolution des nombres de 1 à 57 formatés comme suit :
+ *
+ * XY avec X = 0..5 et Y = 0.9
+ */
 class AutomateOneToFiftySeven() : Automate("01..57") {
     init {
         //ajout des actions

BUT2/Automates/ApplicationAutomates/src/main/kotlin/AutomateSmiley.kt

+/**
+ * Automate accepteur permettant la résolution d'uniquement les smileys suivants :
+ *
+ * :-) | :( | ;-) | :=) | ]-)
+ */
 class AutomateSmiley() : Automate("Smiley") {
     init {
         //ajout des actions

BUT2/Automates/ApplicationAutomates/src/main/kotlin/Etat.kt

@@ -19,4 +19,7 @@ class Etat(private var nom : String) {
     fun addTransition(action: String, etat_sortant : Etat) = this.transitions_sortantes.put(action,etat_sortant)
     fun removeTransition(action: String) = this.transitions_sortantes.remove(action)
 
+    override fun toString(): String {
+        return this.getNom()
+    }
 }
\ No newline at end of file

BUT2/Automates/ApplicationAutomates/src/main/kotlin/Main.kt

 import kotlin.system.exitProcess
 
-fun main(args: Array<String>) {
+/**
+ * Classe stockant les valeurs permettant la coloration de nos textes dans le terminal
+ *
+ * Pour l'utiliser faire :
+ *
+ * Color.COULEUR.code + "texte" + Color.RESET.code
+ */
+enum class Color(val code: String) {
+    MENU("\u001B[36m"),
+    DEBUG("\u001B[38;5;208m"),
+    WARNING("\u001B[33m"),
+    SUCCESS("\u001B[32m"),
+    FAIL("\u001B[31m"),
+    RESET("\u001B[0m")
+}
+
+/**
+ * Fonction principal de notre application
+ *
+ * Cette application permet d'analyser des mots avec différents automates accepteurs pour ainsi vérifier leur validité.
+ *
+ * Un mode debug est aussi disponible pour pouvoir ainsi avoir accès au chemin parcouru pendant la résolution d'un mot.
+ *
+ * @author David CHOCHO
+ */
+fun main() {
+    //Variables "d'environnement" en quelque sorte
     var automate: Automate? = null
     var failedInput = false
-    while (true){
+    var debug = false
 
+    //Boucle infinie du programme, le seul moyen de l'arreter sont sois de forcer l'arret sois d'utiliser une des commandes pré établi
+    while (true){
+        //L'accueil du programme
+        //permet la sélection de l'automate avec prise en charge du mode debug et de la fermeture du programme
         while (automate == null){
-
             if (!failedInput){
                 failedInput = false
-                println(
+                println(Color.MENU.code +
                     """
              --------------- Menu de mon TP -----------------------
                 1. Smiley (pour reconnaitre un des smileys)
                 2. JJ/MM/AAAA (Pour reconnaitre une date bien formée, années bissextiles non supportés)
-                3. HH:MM (pour reconnaitre une heure bien formée) (Pas dispo)
+                3. HH:MM (pour reconnaitre une heure bien formée)
                 4. Adresses électroniques (Pas dispo)
                 5. 01..57 (Pour reconnaitre tout les chiffres de 01 à 57)
                 6. Expressions arithmétiques (Pas dispo)
                 7. Polynômes (Pas dispo) //a voir si fait
                 ...
                 99. Arrêt de l'application
+                0. Activer/Desactiver Mode Debug (permet de voir les chemins parcourus)
             Votre choix (1-99) ?
             Je vous demanderez ensuite la chaîne à analyser, Merci
             -------------------------------------------------------
+            ${if (debug) Color.DEBUG.code + "Mode Debug activé" else ""}
             """
-                )
+               + Color.RESET.code )
 
             }else{
-                println("Veuillez réessayer, entrée non reconnu")
+                println(Color.WARNING.code + "Veuillez réessayer, entrée non reconnu" + Color.RESET.code)
             }
-
-
             when (readlnOrNull()) {
                 "1" -> automate = AutomateSmiley()
                 "2" -> automate = AutomateJourMoisAnnee()
+                "3" -> automate = AutomateHeureMinutes()
                 "5" -> automate = AutomateOneToFiftySeven()
                 "99" -> exitProcess(400)
+                "0" -> debug = !debug
                 else -> failedInput = true
             }
         }
 
 
-        println("ecrivez votre mot")
-        automate.resolv(readLine()!!)
+        //La partie résolution du programme
+        //permet l'ecriture du mot à analyser et sa résolution
+        println(Color.MENU.code + "ecrivez votre mot" + Color.RESET.code)
+        automate.resolv(readLine()!!,debug)
 
-        println(""" 
+
+        //La partie terminaison du programme
+        //permet de revenir a l'accueil, d'analyser un autre mot avec le meme automate ou de terminer le programme
+        println(Color.MENU.code +
+            """ 
             Revenir au menu = m
             Reessayer un autre mot = o
             Appuyez sur n'importe quoi d'autre permet de quitter le programme
-            """)
+            """
+        + Color.RESET.code)
         when ( readLine()!!.lowercase().trim() ){
             "m" -> { automate = null ; failedInput = false }
             "o" -> continue