bob.composant
Class TComposant

java.lang.Object
  extended by bob.elementB.TElementB
      extended by bob.composant.TComposant

public class TComposant
extends TElementB

La classe TComposant contient les informations générales sur les composants.

Syntaxe B:

"TNatureComposant" TEnteteComp
liste de TClause
"END"

Version:
1.0 du 25/07/2001
Author:
Aymeric CALLENDRIER
See Also:
TElementB

Field Summary
protected  java.util.Vector<TClause> ClausesComposant
          liste des clauses du composant
protected  TNatureComposant Elem
          nature du composant : machine, raffinement ou implementation
protected  TEnteteComp EnteteComposant
          entete du composant : nom et paramètres
 
Constructor Summary
TComposant()
          constructeurs sans paramètres
TComposant(TNatureComposant el, TEnteteComp et, java.util.Vector<TClause> liste)
          constructeur initialisant
 
Method Summary
 void Afficher(java.io.Writer f)
          affiche le composant dans un fichier le ficher d'écriture est ouvert par l'appelant
 TComposant AplatirSansRenommage(java.lang.String resname)
          Méthode d'aplatissement d'un raffinement sans renommage.
 tatibouet.bparser.Noeud ConstruireNoeud()
          construit un Noeud à partir d'un composant
static void DiviserPredicats(java.util.Vector<TExprIdentificateur> aa, java.util.Vector<TPredicat> VP, java.util.Vector<TPredicat> V1, java.util.Vector<TPredicat> V2)
          Cette méthode est utilisée par l'aplatissement sans renommage.
 TClauseAbstractConstants DonnerClauseAbstractConstants()
          Cet accesseur renvoie la clause ABSTRACT_CONSTANTS.
 TClauseAbstractVariables DonnerClauseAbstractVariables()
          Cet accesseur renvoie la clause ABSTRACT_VARIABLES.
 TClauseAssertions DonnerClauseAssertions()
          Cet accesseur renvoie la clause ASSERTIONS.
 TClauseConcreteConstants DonnerClauseConcreteConstants()
          Cet accesseur renvoie la clause CONCRETE_CONSTANTS.
 TClauseConcreteVariables DonnerClauseConcreteVariables()
          Cet accesseur renvoie la clause CONCRETE_VARIABLES.
 TClauseConstraints DonnerClauseConstraints()
          Cet accesseur renvoie la clause CONSTRAINTS.
 TClauseExtends DonnerClauseExtends()
          Cet accesseur renvoie la clause EXTENDS.
 TClauseImports DonnerClauseImports()
          Cet accesseur renvoie la clause IMPORTS.
 TClauseIncludes DonnerClauseIncludes()
          Cet accesseur renvoie la clause INCLUDES.
 TClauseInitialisation DonnerClauseInitialisation()
          Cet accesseur renvoie la clause INITIALISATION.
 TClauseInvariant DonnerClauseInvariant()
          Cet accesseur renvoie la clause INVARIANT.
 TClauseOperations DonnerClauseOperations()
          Cet accesseur renvoie la clause OPERATIONS.
 TClausePromotes DonnerClausePromotes()
          Cet accesseur renvoie la clause PROMOTES.
 TClauseProperties DonnerClauseProperties()
          Cet accesseur renvoie la clause PROPERTIES.
 TClauseRefines DonnerClauseRefines()
          Cet accesseur renvoie la clause REFINES.
 java.util.Vector<TClause> DonnerClausesComposant()
          sélecteur de la liste des clauses
 TClauseSees DonnerClauseSees()
          Cet accesseur renvoie la clause SEES.
 TClauseSets DonnerClauseSets()
          Cet accesseur renvoie la clause SETS.
 TClauseUses DonnerClauseUses()
          Cet accesseur renvoie la clause USES.
 TClauseValues DonnerClauseValues()
          Cet accesseur renvoie la clause VALUES.
 TNatureComposant DonnerElem()
          sélecteur de la nature du composant
 TEnteteComp DonnerEnteteComposant()
          sélecteur de l'entete du composant
 TElementB Dupliquer()
          Cette méthode duplique un composant.
 TComposant GenererCompPO()
          Méthode qui calcule un composant dans lequel les opérations sont remplacées par des assertions correspondant à leur PO.
 TComposant Inclure(java.lang.String resname)
          Cette méthode procède à la fusion de tous les composants inclus dans un même composant.
 java.util.Vector<TOperation> ListeDesAppelables()
          Cette methode renvoie la liste des operations appelables lorsqu'on est dans un composant donne.
 java.util.Vector<TOperation> ListeDesVisibles(TInstanceComp instance)
          Cette methode donne la liste des operations visibles (exportees) d'un composant
 java.util.Vector<TOperation> ListeDesVisibles2(TInstanceComp instance)
          La même méthode mais n'inclut pas les opérations définies par le composant.
 java.util.Vector<TExprIdentificateur> ListeVarVisibles(TExprIdentificateur renommage)
          Renvoie la liste des variables visibles dans le corps des opérations.
 TComposant Normaliser()
          Cette methode normalise un composant, c'est a dire qu'elle met les clauses dans l'ordre conventionnel : celui employe par l'atelier B.
 void RangerClausesComposant(java.util.Vector<TClause> x)
          initialisation des clauses du composant
 void RangerElem(TNatureComposant x)
          initialisation de la nature du composant
 void RangerEnteteComposant(TEnteteComp x)
          initialisation de l'entete du composant
 
Methods inherited from class bob.elementB.TElementB
Afficher, ListeDesNomsLibres, Remplacer, RemplacerMultiple
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

Elem

protected TNatureComposant Elem
nature du composant : machine, raffinement ou implementation


EnteteComposant

protected TEnteteComp EnteteComposant
entete du composant : nom et paramètres


ClausesComposant

protected java.util.Vector<TClause> ClausesComposant
liste des clauses du composant

Constructor Detail

TComposant

public TComposant()
constructeurs sans paramètres


TComposant

public TComposant(TNatureComposant el,
                  TEnteteComp et,
                  java.util.Vector<TClause> liste)
constructeur initialisant

Method Detail

RangerElem

public void RangerElem(TNatureComposant x)
initialisation de la nature du composant


RangerEnteteComposant

public void RangerEnteteComposant(TEnteteComp x)
initialisation de l'entete du composant


RangerClausesComposant

public void RangerClausesComposant(java.util.Vector<TClause> x)
initialisation des clauses du composant


DonnerElem

public TNatureComposant DonnerElem()
sélecteur de la nature du composant

Returns:
La nature du composant

DonnerEnteteComposant

public TEnteteComp DonnerEnteteComposant()
sélecteur de l'entete du composant

Returns:
L'entete du composant

DonnerClausesComposant

public java.util.Vector<TClause> DonnerClausesComposant()
sélecteur de la liste des clauses

Returns:
La liste des clauses du composant

DonnerClauseConstraints

public TClauseConstraints DonnerClauseConstraints()
Cet accesseur renvoie la clause CONSTRAINTS.
Auteur: Didier Bert.

Returns:
la clause Constraints si trouvee, null sinon.

DonnerClauseRefines

public TClauseRefines DonnerClauseRefines()
Cet accesseur renvoie la clause REFINES.
Auteur: Didier Bert.

Returns:
TClauseRefines si trouvee, null sinon.

DonnerClauseIncludes

public TClauseIncludes DonnerClauseIncludes()
Cet accesseur renvoie la clause INCLUDES.
Auteur Didier Bert.

Returns:
TClauseIncludes si trouvee, null sinon.

DonnerClauseUses

public TClauseUses DonnerClauseUses()
Cet accesseur renvoie la clause USES.
Auteur: Didier Bert.

Returns:
TClauseUses si trouvee, null sinon.

DonnerClauseImports

public TClauseImports DonnerClauseImports()
Cet accesseur renvoie la clause IMPORTS.
Auteur: Didier Bert.

Returns:
TClauseImports si trouvee, null sinon.

DonnerClauseExtends

public TClauseExtends DonnerClauseExtends()
Cet accesseur renvoie la clause EXTENDS.
Auteur: Didier Bert

Returns:
TClauseExtends si trouvee, null sinon.

DonnerClausePromotes

public TClausePromotes DonnerClausePromotes()
Cet accesseur renvoie la clause PROMOTES.
Auteur: Didier Bert

Returns:
TClausePromotes si trouvee, null sinon.

DonnerClauseOperations

public TClauseOperations DonnerClauseOperations()
Cet accesseur renvoie la clause OPERATIONS.
Auteur: Olivier Bert.

Returns:
TClauseOperations si trouvee, null sinon.

DonnerClauseSees

public TClauseSees DonnerClauseSees()
Cet accesseur renvoie la clause SEES.
Auteur: Olivier Bert.

Returns:
TClauseSees si trouvee, null sinon.

DonnerClauseSets

public TClauseSets DonnerClauseSets()
Cet accesseur renvoie la clause SETS.
Auteur: Olivier Bert.

Returns:
TClauseSets si trouvee, null sinon.

DonnerClauseValues

public TClauseValues DonnerClauseValues()
Cet accesseur renvoie la clause VALUES.
Auteur: Olivier Bert.

Returns:
TClauseValues si trouvee, null sinon.

DonnerClauseAssertions

public TClauseAssertions DonnerClauseAssertions()
Cet accesseur renvoie la clause ASSERTIONS.
Auteur: Olivier Bert.

Returns:
TClauseAssertions si trouvee, null sinon.

DonnerClauseInitialisation

public TClauseInitialisation DonnerClauseInitialisation()
Cet accesseur renvoie la clause INITIALISATION.
Auteur: Olivier Bert.

Returns:
TClauseInitialisation si trouvee, null sinon.

DonnerClauseProperties

public TClauseProperties DonnerClauseProperties()
Cet accesseur renvoie la clause PROPERTIES.
Auteur: Olivier Bert.

Returns:
TClauseProperties si trouvee, null sinon.

DonnerClauseInvariant

public TClauseInvariant DonnerClauseInvariant()
Cet accesseur renvoie la clause INVARIANT.
Auteur: Olivier Bert.

Returns:
TClauseInvariant si trouvee, null sinon.

DonnerClauseAbstractVariables

public TClauseAbstractVariables DonnerClauseAbstractVariables()
Cet accesseur renvoie la clause ABSTRACT_VARIABLES.
Auteur: Olivier Bert.

Returns:
TClauseAbstractVariables si trouvee, null sinon.

DonnerClauseConcreteVariables

public TClauseConcreteVariables DonnerClauseConcreteVariables()
Cet accesseur renvoie la clause CONCRETE_VARIABLES.
Auteur: Olivier Bert.

Returns:
TClauseConcreteVariables si trouvee, null sinon.

DonnerClauseConcreteConstants

public TClauseConcreteConstants DonnerClauseConcreteConstants()
Cet accesseur renvoie la clause CONCRETE_CONSTANTS.
Auteur: Olivier Bert.

Returns:
TClauseConcreteVariables si trouvee, null sinon.

DonnerClauseAbstractConstants

public TClauseAbstractConstants DonnerClauseAbstractConstants()
Cet accesseur renvoie la clause ABSTRACT_CONSTANTS.
Auteur: Olivier Bert.

Returns:
TClauseConcreteVariables si trouvee, null sinon.

Normaliser

public TComposant Normaliser()
Cette methode normalise un composant, c'est a dire qu'elle met les clauses dans l'ordre conventionnel : celui employe par l'atelier B. En effet souvent, apres une operation d'inclusion, les clauses qui sont ramenees d'autres composants se retrouvent a la fin.
Auteur: Didier Bert.

Returns:
le composant courant normalisé

ListeVarVisibles

public java.util.Vector<TExprIdentificateur> ListeVarVisibles(TExprIdentificateur renommage)
Renvoie la liste des variables visibles dans le corps des opérations. Ces variables peuvent être en lecture ou en lecture/écriture. Ici on ne fait pas la distinction.

Returns:
Vector de TExprIdentificateur

ListeDesVisibles

public java.util.Vector<TOperation> ListeDesVisibles(TInstanceComp instance)
Cette methode donne la liste des operations visibles (exportees) d'un composant

Parameters:
instance - TInstanceComp qui fournit le renommage éventuel à effectuer (usage récursif interne).
Lorsqu'on appelle cette méthode on doit passer un paramètre null.
Returns:
un vecteur de TOperation
Algorithme :
Si le composant a une clause EXTENDS, on rappelle la methode recursivement sur les composants de la clause EXTENDS en ajoutant le resultat de l'appel au resultat final.
On ajoute egalement les operations de la clause promotes.
Les operations du composant courant doivent etre ajoutees au resultat, elles sont evidemment visibles.
Auteur: Olivier Bert.

ListeDesVisibles2

public java.util.Vector<TOperation> ListeDesVisibles2(TInstanceComp instance)
La même méthode mais n'inclut pas les opérations définies par le composant. Je n'ai rien trouvé de mieux pour cette fonction qu'un copier/coller de la précédente, sorry. Je l'utilise dans l'inclusion de composants. Auteur: Olivier Bert

Parameters:
instance - TInstanceComp qui fournit le renommage éventuel à effectuer (usage récursif interne).
Lorsqu'on appelle cette méthode on doit passer un paramètre null.
Returns:
la liste des opérations exportées dans le composant, sauf les déclarées dans le composant.

ListeDesAppelables

public java.util.Vector<TOperation> ListeDesAppelables()
Cette methode renvoie la liste des operations appelables lorsqu'on est dans un composant donne.
Algorithme :
Le résultat contiendra :
- La liste des opérations exportées par les composants inclus ou importés.
- la liste des opérations des composants vus, attention cependant ces opérations ne modifient pas l'état de la machine vue (voir le man de ref de B). Auteur: Olivier Bert.

Returns:
Vector de TOperation

Dupliquer

public TElementB Dupliquer()
Cette méthode duplique un composant. La méthode existait pour tous les éléments B mais pas pour un composant. Ceci permettra d'opérer de grosse modification sur un composant sans modifier l'original. Le principe est assez crade : on reparse le fichier avec tatibouet pour obtenir un nouveau composant (tout étant nouvellement alloué). Il fautrait songer un jour à faire une vraie méthode TComposant.Dupliquer(), mais cela est long à écrire ...

Auteur: Olivier Bert.

Overrides:
Dupliquer in class TElementB
Returns:
un TComposant qui est la duplication du composant courant.

Inclure

public TComposant Inclure(java.lang.String resname)
Cette méthode procède à la fusion de tous les composants inclus dans un même composant. La procédure est récursive est suit donc la transitivité du lien INCLUDES. Le résultat final est un nouveau composant appelé "resname" dans lequel on n'a plus d'occurence de la clause INCLUDES ni des clauses EXTENDS et PROMOTES. Les clauses USES ont aussi disparues, mais la méthode n'a pas été testée pour la clause USES.

Principales actions de l'inclusion :
- Ramener les constantes, ensembles, assertions...
- Fusionner les invariants avec un AND
- Renommer les variables si il y a lieu (cas de préfixage du composant)
- Remplacer les appels d'opération par leur corps (on le fait avec RempbacerAppelOp)
- Recopier les opérations promues dans le composant qui inclut.
- Remplacement des paramètres formels de la machine incluse par les params effectifs de l'instantiation.

Cette méthode ajoute un nouveau composant au projet qui est le résultat de l'inclusion.
Auteur: Olivier Bert.

Parameters:
resname - le nom du composant résultat (String).
Returns:
le TComposant qui contient l'inclusion.

DiviserPredicats

public static void DiviserPredicats(java.util.Vector<TExprIdentificateur> aa,
                                    java.util.Vector<TPredicat> VP,
                                    java.util.Vector<TPredicat> V1,
                                    java.util.Vector<TPredicat> V2)
Cette méthode est utilisée par l'aplatissement sans renommage.
Elle prend une liste d'identificateurs aa et une liste de prédicats VP.
Elle retourne V1 qui est la liste de prédicats de VP qui ne dépendent pas de aa et V2 qui est la liste de prédicats de VP qui dépendent de aa. Si, l'un des deux vecteurs n'est pas initialisé, il devient null à la sortie.
On suppose à l'entrée que aa et VP ne sont pas null et que V1 et V2 sont non null et vides.

Auteur Didier Bert.

Parameters:
aa - vecteur d'identificateurs
VP - vecteur de prédicats à diviser
V1 - vecteur de prédicats résultat
V2 - vecteur de prédicats résultat

AplatirSansRenommage

public TComposant AplatirSansRenommage(java.lang.String resname)
Méthode d'aplatissement d'un raffinement sans renommage.
Cette méthode s'applique sur un raffinement R. Le paramètre "resname" est le nom du composant machine qui sera généré. Le raffinement R raffine une machine M. La méthode construit une machine resname qui aplatit le niveau de raffinement (voir le poly EJCP 2005, page 53).
Cette version NE RENOMME PAS les variables (constantes) abstraites qui sont réutilisées dans le raffinement. Les prédicats des propriétés et de l'invariant qui ne dépendent pas des variables (constantes) abstraites sont sorties de la quantification existentielle. Cette méthode marche, sauf si les variables (constantes) abstraites réutilisées sont déclarées, dans la machine, de manière "non séparables" des autres variables (constantes) abstraites.

Conditions qui doivent être remplies:
Si ces conditions ne sont pas remplies, le résultat est "null". (Int: pour assembler les inclusions, appliquer d'abord la méthode Inclure(nn) de cette classe).

En sortie, il se peut que la machine ne soit pas une vraie machine pour deux raisons:
Auteur: Didier Bert (juillet 2005)

Parameters:
resname - le nom de la machine résultat.
Returns:
le composant qui est ajouté au projet courant.

GenererCompPO

public TComposant GenererCompPO()
Méthode qui calcule un composant dans lequel les opérations sont remplacées par des assertions correspondant à leur PO. Le composant est déjà enregistré dans un projet. Il est remplacé au même endroit dans le projet.


Afficher

public void Afficher(java.io.Writer f)
              throws java.io.IOException,
                     java.io.FileNotFoundException
affiche le composant dans un fichier le ficher d'écriture est ouvert par l'appelant

Overrides:
Afficher in class TElementB
Parameters:
f - Flux de sortie: fichier de type FileWriter ou terminal(new PrintWriter(System.out)).
Throws:
java.io.IOException
java.io.FileNotFoundException

ConstruireNoeud

public tatibouet.bparser.Noeud ConstruireNoeud()
construit un Noeud à partir d'un composant

Overrides:
ConstruireNoeud in class TElementB
Returns:
Noeud


Copyright OB.