V. Implémentation du planificateur
Le planificateur est utilisé au niveau de l'agent
médiateur lui permettant de réaliser le but soumis par
l'utilisateur. Or ce qui est abordé dans cette section n'est pas le
planificateur dans sa globalité mais une partie de lui. Cette partie
consiste au un module pour le traitement des différentes réponses
venantes des agents service en réponse à un sous problème
(état initial de l'utilisateur et un sous but) y envoyé par
l'agent médiateur. Le module est implémenté par une
fonction « traiter_réponses_AS() ».
Le principe est le suivant : l'agent médiateur
après qu'il reçoit toutes les réponses des agents service
à un sous problème déjà envoyé, il les met
dans un vecteur pouvant contenir pour chaque agent la réponse
renvoyée ainsi que son type. Il utilise puis ce vecteur comme
entrée à la fonction << traiter_réponses_AS()
». Cette dernière après qu'elle traite les réponses,
renvoie un autre vecteur contenant le résultat du traitement ainsi que
son type.
Le vecteur d'entrée de la fonction est de dimension 3
(nombre des agents service). Pour chaque agent service ce vecteur contient sa
réponse ainsi que le type de cette réponse. Le type de la
réponse peut être :
- Pas_solution_trouvée : si l'agent service ne trouve pas
une solution au sous problème lui est envoyé.
- Solution_trouvée : si l'agent service a trouvé
une solution directe au sous problème lui est envoyé.
- Nouveaux_sousbut : si l'agent service ne trouve pas une
solution directe au sous problème mais il trouve un ou plusieurs
nouveaux sous but pouvant participer à son résolution. Dans ce
cas ces nouveaux sous but son mets dans le vecteur en plus du type de la
réponse.
Le vecteur de sortie de la fonction peut contenir le
résultat retourné par la fonction ainsi que le type de ce
résultat. Ce type de résultat peut être :
- Pas_solution_trouvée_pb_utilisateur : si toutes les
réponses des agents service sont de
type << pas_solution_trouvée » et le graphe
d'états ne contient pas de sous but à traiter.
- Nouveau_sous_but : si toutes les réponses des agents
service sont de type << pas_solution_trouvée » et le graphe
d'états contient encore de sous but à traiter ou dans le cas
où l'une au moins des réponses est de type <<
Nouveaux_sousbut ». Dans ce dernier cas, le graphe d'états doit
être à jour et un nouveau sous but est retourné par la
fonction.
- Solution_trouvée_pb_utilisateur : dans le cas où
l'une au moins des réponses est de type << solution_trouvée
». Dans ce cas un plan solution est retourné par la fonction
En fin, l'agent médiateur suite à la
réception de ces résultat de traitement de la fonction, il va
résonner : soit il renvoie << pas de solution au problème
de l'utilisateur à l'agent utilisateur, soit envoie un nouveau sous
problème aux agents service ou bien, il retourne à l'agent
utilisateur un plan solution au problème de l'utilisateur.
Premièrement, dans son implémentation, l'agent
médiateur doit se doter d'une variable globale représentant le
graphe d'états. Ce dernier est implémenté par une
structure de pile de vecteur. Chaque vecteur est de type <<
structure_graph » défini ci-après. Chaque vecteur doit
contenir dans son premier champ un sous but ainsi que l'opérateur
permettant d'y parvenir et dans les autres champs les différents sous
but permettant d'aller du but de l'utilisateur (noeud principal du graphe)
à ce sous but.
class Structure_graphe{
String sous_but;
String operateur;
}
//Déclaration du graphe d'états
Stack<Vector<Structure_graphe>>
Graphe_Etats=new
Stack<Vector<Structure_graphe>>();
//Initialisation du graphe d'états
Structure_graphe premier_s_b=new
Structure_graphe(); Vector<Structure_graphe> etat=new
Vector<Structure_graphe>(); premier_s_b.sous_but=But_Utilisateur;
premier_s_b.operateur="";
etat.add(premier_s_b);
Graphe_Etats.push(etat);
Notre fonction « traiter_reponses_AS() » correspond
donc à ce qui suit :
Nous définissons encore une autre variable globale
« Dernier_sousbut_choisi » qui peut contenir le dernier sous but
choisi et traité pour l'utiliser en suite dans la fonction de
traitement. C'est une variable de type « Vector<Structure_graphe>
» :
|
Vector<Structure_graphe>
Dernier_sousbut_choisi=new
Vector<Structure_graphe>();
|
Définissons maintenant la structure des deux vecteurs
d'entrée et de sortie de la fonction « traiter_reponses_AS() »
:
|
class Structure_entree_sortie{
String type_reponse;
ArrayList<String> objet_reponse=new
ArrayList<String>();
}
//Reponses_AS est un vecteur pour contenir les réponses
des agents // service et sera utilisé comme entrée à la
fonction de traitement Vector<Structure_entree_sortie>
Reponses_AS=new
Vector<Structure_entree_sortie>();
//Reponse_AM est un vecteur utilisé pour récuperer
le résultat de la //fonction de traitement
Vector<Structure_entree_sortie>
Reponse_AM=new
Vector<Structure_entree_sortie>();
|
Maintenant, il nous reste à présenter notre
fonction de traitement « traiter_reponses_AS() » :
/****************************************************/
/*
Définition de la fonction "traiter_reponses_AS()
*/
/****************************************************/
public Vector<Structure_entree_sortie>
Traiter_reponses_AS(Vector<Structure_entree_sortie> Reponses_AS)
{
//Déclaration des variables locales
// parcours le vecteur de réponses pour compter le nombre
des // différents types de réponses
ListIterator<Structure_entree_sortie>
iter=Reponses_AS.listIterator();
while(iter.hasNext()){
if((iter.next().type_reponse).equalsIgnoreCase("pas_solution"))
nbre_pas_solution++;
if((iter.next().type_reponse).equalsIgnoreCase("soluion_trouvee"))
nbre_soluion_trouvee++;
if((iter.next().type_reponse).equalsIgnoreCase("nouveaux_sousbut"))
nbre_nouveaux_sousbut++;
}
// Maintenant, le type du traitement à effectuer
dépend de ces // nombres comptés :
// 1. Si toutes les réponses des agents service sont de
type
// "pas_solution"(nbre_pas_solution=3),un test sur l'état
du
// graphe d'états est effectué :
// 1.1. Si il est vide, le résultat à retourner
sera
// "pas_solution_pb_utilisateur"
// 1.2. Si il n'est pas vide, le résultat à
retourner sera un
// nouveau sous but à résoudre
// 2. Si nbre_solutiontrouvee>=1, alors le résultat
à retourner sera // un plan solution
// 3. Si les deux cas précédent ne sont pas
trouvés (nbre_nouveaux
// _sousbut>=1), alors le graphe d'états sera met
à jour et le
// résultat à retourner sera un nouveau sous but
à résoudre
if(nbre_pas_solution==3){
if(Graphe_Etats.isEmpty()){
type_reponse_retour="pas_solution_pb_utilisateu";
objet_reponse_retour.clear();
} else {
type_reponse_retour="nouveau_sous_but";
objet_reponse_retour.add(nouv_sousbut);
}
}
else //pas toutes les réponses sont de
type"pas_solution" {
if(nbre_soluion_trouvee>=1) {
type_reponse_retour="solution_trouvee_pb_utilisateur";
objet_reponse_retour.add(iter3 .next().operateur);
}
else // aucune "solution_trouvee" n'est trouvee
// => il existe au moins une réponse de type { //
"nouveaux_sousbut"
type_reponse_retour="nouveau_sousbut";
objet_reponse_retour.add(nouv_sousbut);
}
}
//************************************************************
// mettre les valeurs des deux variables "type_reponse_retour" // et
"objet_reponse_retour" associés dans le traitement
// précédent au vecteur "Resultat_a_retourner"
à retourner par // la fonction
//************************************************************
Resultat_a_retourner.firstElement().type_reponse
=type_reponse_retour;
Resultat_a_retourner.firstElement().objet_reponse
=objet_reponse_retour;
return(Resultat_a_retourner);
}
/****************************************************/
/* Fin de la fonction "traiter_reponses_AS() */
/****************************************************/
| 
