Version 1.1 (l'utilisable...)

Author: blastfk

.idea/workspace.xml

@@ -2,19 +2,25 @@ package main
 
 import main.generator.{Generator, SeqGenerator}
 import main.log.Log
-import main.log.models.LogBuilder
+import main.log.examples.SpecialLog
 
 /**
   * Objet MAIN !
+  * Réalise l'affichage d'un certain nombre de logs produit par le
+  * format donné.
   */
 object Main {
   def main(args: Array[String]): Unit = {
     // Mécanisme de génération des log
     val generator = new SeqGenerator[Log](new Generator[Log] {
-      override def getValue = LogBuilder.getMeteoLog
-    }, 10)
+      /*
+       * Modifiez la surchage de cette fonction
+       * pour indiquer le type de log à utiliser
+       */
+      override def getValue = new SpecialLog()
+    }, 10) // Modifiez ce nombre pour augmenter/diminuer le nombre produit
 
-    // Affichage sur la sortie standard
+    // Affichage des logs sur la sortie standard
     for (log <- generator.getValue) println(log)
-  }
+  }s
 }

out/production/LogGenerator/main/Main$$anon$1.class

@@ -1,4 +1,6 @@
-package main.generator
+package main.generator.examples
+
+import main.generator.Generator
 
 /**
   * Génère un nouveau nombre réel à précision double de manière aléatoire,

out/production/LogGenerator/main/generator/RandomDoubleGenerator.class

@@ -0,0 +1,19 @@
+package main.generator.examples
+
+import main.generator.Generator
+
+/**
+  * Génère une chaine de manière aléatoire, décrivant une
+  * heure au format HH:MM:SS
+  */
+class RandomHourTextGenerator extends Generator[String] {
+  // ATTRIBUTS
+  /** Le générateur du nombre de secondes caractéristique de l'heure à générer */
+  private val generator: Generator[Int] = new RandomIntGenerator(0, 86400)
+
+  // COMMANDE
+  def getValue:String = {
+    val s = generator.getValue
+    "%02d:%02d:%02d".format(s/3600, (s % 3600)/60, s%60)
+  }
+}

out/production/LogGenerator/main/generator/RandomIntGenerator.class

@@ -1,4 +1,6 @@
-package main.generator
+package main.generator.examples
+
+import main.generator.Generator
 
 /**
   * Génère un nouveau nombre entier de manière aléatoire, dont

out/production/LogGenerator/main/generator/RandomTextGenerator.class

@@ -1,12 +1,13 @@
-package main.generator
+package main.generator.examples
+
+import main.generator.Generator
 
 /**
   * Génère un nouveau not aléatoire à partir d'un alphabet
   *
   * @construct Construit un nouveau générateur de mots, de longueur comprise entre
   *   minLength et maxLength, et dont les lettres appartiennent
   *   à l'intervalle de lettres [minLetter, maxLetter] spécifié.
-  *
   * @param minLength La longueur minimale des mots pouvant être générés
   * @param maxLength La longueur maximale des mots pouvant être générés
   * @param minLetter La longueur minimale des mots pouvant être générés

out/production/LogGenerator/main/generator/examples/RandomDoubleGenerator.class

@@ -1,23 +1,17 @@
 package main.log
 
 /**
-  * Modélise un log. Un fichier log se décompose en trois parties
+  * Modélise un log. Un fichier log se décompose en deux parties
   * distinctes :
   *   1) Un indice (nombre réel) désignant la valeur d'un certain label
-  *   2) Une entête contenant des informations propres au log (date, heure, ... )
-  *   3) Un contenu, dont la forme et le texte dépend de la nature du log
+  *   2) Un contenu, dont la forme et le texte dépend de la nature du log
   */
 trait Log {
   /**
     * Renvoie la valeur du label associé au log
     */
   def getLabel : Double
 
-  /**
-    * Renvoie la partie correspondant à l'entête du log
-    */
-  def getHeader : String
-
   /**
     * Renvoie la partie correspondant au contenu textuel du log
     */
@@ -26,5 +20,7 @@ trait Log {
   /**
     * Renvoie la chaîne correspondant à l'intégralité du contenu du log
     */
-  def toString : String
+  override def toString : String = new TextBuilder().
+    add("%01.05f".format(getLabel)).
+    add(getContent).toString
 }

out/production/LogGenerator/main/generator/examples/RandomHourTextGenerator.class

@@ -10,6 +10,7 @@ class TextBuilder(val separator: String) {
   /** Le constructeur de texte utilisé */
   private val builder: StringBuilder = new StringBuilder
 
+  // ALTERNATIVE
   def this() = this(" ")
 
   // REQUETE
@@ -21,12 +22,15 @@ class TextBuilder(val separator: String) {
     * à partir de la représentation textuelle d'un objet quelconque
     *
     * @param obj La sous-proposition à ajouter
+    *
+    * @return L'objet lui-même (this)
     */
-  def add(obj: Any) {
+  def add(obj: Any) : TextBuilder = {
     if (builder.length > 0) {
       builder.append(separator)
     }
     builder.append(obj.toString)
+    this
   }
 
   /**
@@ -35,8 +39,10 @@ class TextBuilder(val separator: String) {
     *
     * @param collection La collection des objets à ajouter dans le texte
     * @param separator La chaine de séparation utilisée pour séparer les objets
+    *
+    * @return L'objet lui-même (this)
     */
-  def add(collection: Seq[Any], separator: String) {
+  def add(collection: Seq[Any], separator: String) : TextBuilder = {
     assert(collection != null)
     assert(separator != null)
 
@@ -45,7 +51,5 @@ class TextBuilder(val separator: String) {
 
     add(cs)
   }
-  def add(collection: Seq[Any]) {
-    add(collection, " ")
-  }
+  def add(collection: Seq[Any]) : TextBuilder = add(collection, " ")
 }

out/production/LogGenerator/main/generator/examples/RandomIntGenerator.class

@@ -0,0 +1,33 @@
+package main.log.examples
+
+import main.generator.examples.{RandomDoubleGenerator, RandomHourTextGenerator}
+import main.log.{Log, TextBuilder}
+
+/**
+  * Construit un log décrivant une application fictive
+  * de gestion des données météo
+  */
+class MeteoLog extends Log {
+  // ATTRIBUTS DU LOG
+  /** La température */
+  private val temperature: Double = new RandomDoubleGenerator(-10, 40).getValue
+
+  /** La vitesse vent */
+  private val windSpeed: Double = new RandomDoubleGenerator(0, 130).getValue
+
+  /** L'heure du relevé */
+  private val date: String = new RandomHourTextGenerator().getValue
+
+  // DEFINITION DU CONTENU DU LOG
+  /** Le contenu du log */
+  private val content = new TextBuilder()
+    .add("Heure : " + date)
+    .add("Température : %.2f°C".format(temperature))
+    .add("Vitesse du vent : %.2f km/h".format(windSpeed))
+    .toString
+
+  // REQUETES
+  override def getLabel: Double = temperature / 10.0 + windSpeed / 100.0
+
+  override def getContent : String = content
+}

out/production/LogGenerator/main/generator/examples/RandomTextGenerator.class

@@ -0,0 +1,55 @@
+package main.log.examples
+
+import main.generator.examples.RandomIntGenerator
+import main.log.{Log, TextBuilder}
+
+/**
+  * Construit un log décrivant le danger que représente une personne
+  * en fonction de ses attributs S.P.E.C.I.A.L et son karma.
+  */
+class SpecialLog extends Log {
+  // ATTRIBUTS
+  /** Le générateur des valeurs de S.P.E.C.I.A.L */
+  private val attrGen = new RandomIntGenerator(1, 10)
+
+  /** La table des caractéristiques */
+  private val caracs: Map[String, Int] = defineKeys
+  private def defineKeys = {
+    var caracs = Map.empty[String,Int]
+    caracs += ("Strength" -> attrGen.getValue)
+    caracs += ("Perception" -> attrGen.getValue)
+    caracs += ("Endurance" -> attrGen.getValue)
+    caracs += ("Charisma" -> attrGen.getValue)
+    caracs += ("Intelligence" -> attrGen.getValue)
+    caracs += ("Agility" -> attrGen.getValue)
+    caracs += ("Luck" -> attrGen.getValue)
+    caracs += ("Karma" -> new RandomIntGenerator(-1000, 1000).getValue)
+    caracs
+  }
+
+
+  // DEFINITION DU CONTENU DU LOG
+  /** Le contenu du log */
+  var builder = new TextBuilder()
+  for (key <- caracs.keys) builder.add(key + " = " + caracs(key))
+  private val content = builder.toString
+
+
+  // REQUETES
+  /**
+    * Rédéfinition du label qui représente ici le danger potentiel
+    * de la personne décrite par le log.
+    */
+  override def getLabel: Double = {
+    // Danger de par son Karma
+    var label = caracs("Karma") / 500.0
+
+    // Danger de par son SPECIAL
+    var sum = 0
+    for ((_, v) <- caracs filterKeys (x => !x.equals("Karma"))) sum += v
+    label += sum / 70.0
+    label
+  }
+
+  override def getContent : String = content
+}