====== Réutilisation ======
 
Nous voulons gérer un réseau routier.
Un ''réseau Routier'' est composé de ''PointRoute'' et d'''Arcs Routiers''.
On veut savoir pour un réseau routier les chemins possibles entre deux points routes.

La modélisation initiale imaginée est celle du diagramme ci-dessous.

{{ :2014_2015:s3:concprogobjet:td:reseauroutier.jpg?direct&300 |}}


Voici le jeu de données à utiliser :
<code>
        AR[A8-23:[ Villeneuve:]->[ Sophia:]]
	AR[N7-14:[ Villeneuve:]->[ Sophia:]]
	AR[A8-7:[ Villeneuve:]->[ Cagnes:]]
	AR[N7-14:[ Sophia:]->[ Villeneuve:]]
	AR[A8-23:[ Sophia:]->[ Villeneuve:]]
	AR[A8-7:[ Cagnes:]->[ Villeneuve:]]
	AR[A8-13:[ Cagnes:]->[ Nice:]]
	AR[A8-13:[ Nice:]->[ Cagnes:]]
</code>

Voici des exemples de chemins :

**de Nice a Sophia :** 
  - [dist.=34, paths=[AR[A8-13:[ Nice:]->[ Cagnes:]], AR[A8-7:[Cagnes:]->[ Villeneuve:]], AR[N7-14:[ Villeneuve:]->[ Sophia:]]]]
  - [dist.=43, paths=[AR[A8-13:[ Nice:]->[ Cagnes:]], AR[A8-7:[ Cagnes:]->[ Villeneuve:]], AR[A8-23:[ Villeneuve:]->[ Sophia:]]]]

**de Sophia a Nice :** 
  - [dist.=34, paths=[AR[N7-14:[ Sophia:]->[ Villeneuve:]], AR[A8-7:[ Villeneuve:]->[ Cagnes:]], AR[A8-13:[ Cagnes:]->[ Nice:]]]]
  - [dist.=43, paths=[AR[A8-23:[ Sophia:]->[ Villeneuve:]], AR[A8-7:[ Villeneuve:]->[ Cagnes:]], AR[A8-13:[ Cagnes:]->[ Nice:]]]]

**de Sophia a villeneuve :** 
  - [dist.=14, paths=[AR[N7-14:[ Sophia:]->[ Villeneuve:]]]]
  - [dist.=23, paths=[AR[A8-23:[ Sophia:]->[ Villeneuve:]]]]

**de Sophia a Cagnes :** 
  - [dist.=21, paths=[AR[N7-14:[ Sophia:]->[ Villeneuve:]], AR[A8-7:[ Villeneuve:]->[ Cagnes:]]]]
  - [dist.=30, paths=[AR[A8-23:[ Sophia:]->[ Villeneuve:]], AR[A8-7:[ Villeneuve:]->[ Cagnes:]]]]



Pour cela on vous donne les classes suivantes :
     - Le package {{ :2014_2015:s3:concprogobjet:td:graphex.zip?direct&300 |grapheX}} duquel ont été extraits les classes utiles à notre problème; ce package a été récupéré sur le web à l'"X"
     - Le package {{:2014_2015:s3:concprogobjet:td:parcours.zip|parcours}} a été créé pour vous simplifier la tâche et vous permettre de gérer des graphes comportant des sommets reliés par plusieurs arcs.

Les 2 diagrammes suivants ont été obtenus par reverse Engineering:
{{ :2014_2015:s3:concprogobjet:td:graphex.jpg?direct&300 |}}
{{ :2014_2015:s3:concprogobjet:td:parcours.jpg?direct&300 |}}


===== Questions =====
   - Imaginer comment vous pourriez définir un réseau routier comme un graphe : quels sont les sommets? quels sont les arcs? etc. Compléter/Modifier le diagramme de classe donné au début pour réseau routier avec ces informations. Faire cet exercice sur papier.
   - Dessiner le diagramme de séquence qui, à partir d'un réseau, vous permet d'obtenir tous les chemins entre deux points routes ordonnés sur la distance entre les noeuds. Faire cet exercice sur papier.
   - Ecrivez les tests et les codes correspondants. Vous avez comme hypothèse qu'il n'existe pas deux arcs différents entre deux même points qui ont exactement la même distance.
   - Nous voulons prendre en compte dans notre modélisation, les faits suivants, que devons-nous modifier? 
         - un point route est en ville ou à la campagne, 
         - un point route est déterminé par une coordonnée GPS
   - Nous voulons calculer les distances entre deux points routes à partir des coordonnées GPS pour associer une distance à un arcRoutier, que devez-vous faire?
   - Nous voulons à présent utiliser cette modélisation pour obtenir les chemins les plus courts, les chemins qui ne passent pas par l'autoroute, .... A vous !




<box round rgb(150,290,190) rgb(198,226,150) 75%|Rendu en fonction du groupe de TD Pour le Groupe 2 le 30/11 à 23h59 (Pour S3D: pas de rendu, notation en TD) > 
  * Mettez un mail à votre encadreur avec soit l'adresse où récupérer le TD soit le TD lui-même
  * Dans votre répertoire de projet, sous TD6, se trouvent (s'il y a des doutes sur le répertoire de livraison, mettez un mail à votre encadreur) : 
       - Un document contenant 
             * votre modèle final (Tout le monde n'aboutit pas au même modèle, c'est certain) (merci de l'intégrer dans un document pour que nous n'ayons pas à ouvrir différents modèles dans différentes versions de l'outil).
             * des explications sur les raisons de ce modèle (dont vous êtes très fiers) et les leçons apprises.
       - Les codes et les tests. 
</box>



<html>
<!--

====== Polymorphisme ======

Le bus supporte à présent différents types de messages : Rémanent, Ephemere, Fondamental, Protegé, Intelligent ...

Chacun de ces types de messages répond aux exigences suivantes concernant leur cycle de vie.

^  ^ Création ^ Lecture ^ MiseAJour ^ Destruction^
^ Rémanent| Il connait son créateur | --- | Peut être mis à jour par son créateur| Ne peut être détruit que pas son créateur|
^ Ephemere| --- | Est automatiquement retiré de sa boîte dès qu'il est lu| Ne peut pas être mis à jour| Ne peut être détruit que s'il n'est plus dans une boite|
^Temporel|Il connait la date où il a été créé et sa durée |Il ne peut être lu que s'il n'est pas périmé. S'il est périmé, il est détruit lorsque l'on demande à le lire|Peut être mis à jour| Est automatiquement détruit quand il est périmé|
^ Intelligent|Il connait son créateur|N'est proposé qu'à ceux qui ne l'ont pas encore lu| Ne peut pas être mis à jour|Ne peut être détruit que si il a été lu au moins une fois||
^ Re-armable | --- | --- | Il peut être réactivé | Il disparait en lecture au bout d'un temps donné, il doit alors être réactivé et s'il n'est pas re-armé, au bout d'un certain temps il est détruit|
 
**A FAIRE**
  - Proposer un modèle de classes en conception
  - Vérifier que tous les scénarios sont "faisables"...
  - Vérifier les propriétés vues en cours 
  - Implémenter et tester votre code sur les scénarios donnés.
  - Vérifier que tous vos scénarios précédents sont toujours fonctionnels, en utilisant les tests. Si ce n'est pas le cas, mettez vos codes à jour pour satisfaire les tests.
  - Quel impact sur le calcul du nombre de messages dans une boîte ?

Proposer un modele d'IHM de reception des messages pour les aider à comprendre... ou les laisser faire?
ou la leur donner et les laisser la connecter?



===== Responsabilités =====

En fonction des mots clefs qui constituent le contenu des messages, ils sont automatiquement associés à une boîte de message. Si aucune correspondance n'est détectée une boîte "Divers" est utilisée.

Exemples :
     - "Accident " conduit à poster le message dans la boite "URGENCE"
     - "Danger " conduit à poster le message dans la boite "URGENCE"
     - "photo " conduit à poster le message dans la boite "SNAPCHAT"

**A FAIRE**
    - Qui crée les messages?
    - Qui est responsable de filtrer les mots clefs? 
    - Quel est la complexité du filtrage?
    - Déterminer le couplage de vos classes


===== Abstraction =====

Si maintenant, on veut créer une nouvelle boîte qui reçoit les messages contenant contenant "photo", que faut-il faire pour que votre système le prenne en compte?

Si maintenant on veut que tout message dans la boite SNAPCHAT soit ephemere ?


===== Estimation de performance =====


Une route est définie par des Tronçons. Un tronçon est défini par deux Positions et une longueur. Une Position est définie par un nom.

Calculer le plus cours chemin entre deux positions.
Déterminer la complexité de votre algorithme.


=> Outils de recherche de code dupliqué?


===== Suites prévues pour ce projet ===== 

  * //Objectifs  : refactoring, incrémentalité et agilité// : Le bus est maintenant composée de boîtes à messages : 
Le bus gère des "boîtes à message". Plusieurs producteurs peuvent émettre des messages vers une même boîte, plusieurs consommateurs peuvent lire les messages dans une boite. 
Dans le scénario de base, la voiture A a choisi d'émettre son message vers la queue "Etat Des Routes". Les consommateurs déclarent les boîtes qui les intéressent. Ils peuvent lire les messages qui les intéressent sur une boîte donnée ou obtenir tous les messages qui les intéressent indépendamment des boîtes.  Plusieurs types de messages? Qui est responsable de créer les messages? Qui connait les boîtes de messages ? 
  * //Objectifs : Apprentissage d'une famille courante de patterns (fabrique, builder) mais uniquement par l'usage, la formalisation se fera en S4//: Les messages pouvant être de différentes natures, un bus devient "porteur" d'une fabrique à messages.
  * //Objectifs : Prise en compte des IHMs et mise en place du pattern MVC à tous les niveaux// : Définir les interfaces graphiques qui nous permettraient d'accéder "simplement" à un bus pour émettre, lire et effacer des messages uniquement.
  * //Objectifs : Prise en considération des responsabilités uniques// : Routage en fonction des messages : La voiture A emet un message et le bus décide de la ou des boîtes à messages concernées.
  * //Objectifs : mise en oeuvre du pattern DAO + différents modèles de persistance + intégration par les interfaces + travail en équipe// : Les messages seront rendus persistants. Pour certaines boîtes les messages sont persistants, pour d'autres non :  
  * Il est assez surprenant d'effacer les messages au bout d'un certain temps alors que certains consommateurs ne les ont pas lu et de redonner le même message au même consommateur qui l'a déjà lu. Que feriez-vous pour : a) ne pas redonner le même message au même consommateur; b) donner les messages aux consommateurs qui ne les ont pas encore lu? quel écueil( le bus ne connait pas ses consommateurs!) ? quelle solution envisageriez-vous (un consommateur se déclare, une file d'attente par consommateur, et le message est détuit lorsque plus aucune file n'y fait référence)? 
- Il sera possible de définir différentes formes de souscription.

Nous n'aborderons, hélas, pas les aspects distribués.

!-->
</html>