1 # CONFIGURATION MANAGEMENT OF EDF VERSION
2 # ======================================================================
3 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
7 # (AT YOUR OPTION) ANY LATER VERSION.
9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
16 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
19 # ======================================================================
26 # import rajoutés suite à l'ajout de Build_sd --> à résorber
29 from Noyau import N_Exception
30 from Noyau.N_Exception import AsException
31 # fin import à résorber
36 class ETAPE(I_MCCOMPO.MCCOMPO):
42 if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
43 if self.reuse != None:
44 sdname= self.reuse.get_name()
46 sdname=self.sd.get_name()
47 if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
48 # dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
52 def is_reentrant(self):
54 Indique si la commande est reentrante
56 return self.definition.reentrant == 'o'
60 Met l'état de l'étape à : modifié
61 Propage la modification au parent
62 Si la fonction op_init existe, l'active
65 # doit etre realisée apres init_modif et la validite reevaluée
66 # apres cette action. L'état modified de tous les objets doit etre
68 self.state = 'modified'
70 self.parent.init_modif()
74 Méthode appelée une fois qu'une modification a été faite afin de
75 déclencher d'éventuels traitements post-modification
76 ex : INCLUDE et POURSUITE
79 if type(self.definition.op_init) == types.FunctionType :
80 # XXX Normalement en mode editeur g_context ne peut pas etre utilisé
81 apply(self.definition.op_init,(self,self.parent.g_context))
82 self.state = 'modified'
84 def nomme_sd(self,nom) :
86 Cette méthode a pour fonction de donner un nom (nom) au concept
87 produit par l'étape (self).
88 - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
89 - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
90 Les valeurs de retour sont :
91 0 si le nommage n'a pas pu etre mené à son terme,
92 1 dans le cas contraire
94 if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
95 return 0,"Nom de concept trop long (maxi 8 caractères)"
98 # On verifie d'abord si les mots cles sont valides
100 if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
102 # Cas particulier des opérateurs obligatoirement réentrants
104 if self.definition.reentrant == 'o':
105 self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
107 self.sdnom=self.sd.nom
108 return 1,"Concept existant"
110 return 0,"Opérateur réentrant mais concept non existant"
112 # Cas particulier des opérateurs facultativement réentrants
115 if self.definition.reentrant == 'f' :
116 sd = self.jdc.get_sd_avant_etape(nom,self)
118 # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
119 if isinstance(sd,self.get_type_produit()) :
120 self.sd = self.reuse = sd
122 return 1,"Opérateur facultativement réentrant et concept existant trouvé"
124 return 0,"Concept déjà existant et de mauvais type"
126 # il faut enlever le lien vers une SD existante car si on passe ici
127 # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
128 # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
131 self.sd = self.reuse = self.sdnom = None
133 # On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
134 # mais est utilisé en mode non réentrant
137 if self.parent.get_sd_autour_etape(nom,self):
138 # Un concept de ce nom existe dans le voisinage de l'etape courante
139 # On retablit l'ancien concept reentrant s'il existait
141 self.sd=self.reuse=old_reuse
142 self.sdnom=old_reuse.nom
143 return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
145 # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
146 # On peut donc créer le concept retourné.
147 # Il est créé sans nom mais enregistré dans la liste des concepts existants
149 # Il suffit de changer son attribut nom pour le nommer
152 return 1,"Nommage du concept effectué"
155 if string.find(old_nom,'sansnom') :
156 # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
157 # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
158 # on peut donc le nommer sans test préalable
159 if self.parent.get_sd_autour_etape(nom,self):
160 return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
164 return 1,"Nommage du concept effectué"
166 # Normalement l appel de isvalid a mis a jour le concept produit (son type)
167 # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
169 if self.parent.get_sd_autour_etape(nom,self):
170 return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
174 return 1,"Nommage du concept effectué"
176 # Normalement on ne devrait pas passer ici
177 return 0,'Normalement on ne devrait pas passer ici'
179 def get_sdprods(self,nom_sd):
181 Fonction : retourne le concept produit par l etape de nom nom_sd
182 s il existe sinon None
185 if self.sd.nom == nom_sd:return self.sd
189 Rend l'etape courante active.
190 Il faut ajouter la sd si elle existe au contexte global du JDC
194 if not self.sd : return
195 # XXX Pourquoi faut-il faire ce qui suit ??? par defaut les etapes sont actives
197 self.jdc.append_sdprod(self.sd)
203 Rend l'etape courante inactive
204 Il faut supprimer la sd du contexte global du JDC
205 et de la liste des sd
208 if not self.sd : return
209 self.jdc.del_sdprod(self.sd)
210 self.jdc.delete_concept_after_etape(self,self.sd)
212 def supprime_sdprods(self):
215 Lors d'une destruction d'etape, detruit tous les concepts produits
216 Un opérateur n a qu un concept produit
217 Une procedure n'en a aucun
218 Une macro en a en général plus d'un
220 # XXX pour les macros il faudrait peut etre aussi
221 # supprimer les concepts a droite du = ???
222 if not self.is_reentrant() :
223 # l'étape n'est pas réentrante
224 # le concept retourné par l'étape est à supprimer car il était
227 self.parent.del_sdprod(self.sd)
228 self.parent.delete_concept(self.sd)
230 def delete_concept(self,sd):
235 Mettre a jour les mots cles de l etape et eventuellement
236 le concept produit si reuse
237 suite à la disparition du concept sd
238 Seuls les mots cles simples MCSIMP font un traitement autre
239 que de transmettre aux fils
241 if self.reuse and self.reuse == sd:
242 self.sd=self.reuse=None
244 for child in self.mc_liste :
245 child.delete_concept(sd)
247 def make_register(self):
249 Initialise les attributs jdc, id, niveau et réalise les
250 enregistrements nécessaires
251 Pour EFICAS, on tient compte des niveaux
252 Surcharge la methode make_register du package Noyau
255 self.jdc = self.parent.get_jdc_root()
256 self.id= self.parent.register(self)
257 if self.definition.niveau :
258 # La définition est dans un niveau. En plus on
259 # l'enregistre dans le niveau
260 self.nom_niveau_definition = self.definition.niveau.nom
261 self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
262 self.niveau.register(self)
264 # La définition est au niveau global
265 self.nom_niveau_definition = 'JDC'
266 self.niveau=self.parent
268 self.jdc = self.parent =None
273 """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
278 etape.state = 'modified'
283 for objet in self.mc_liste:
284 new_obj = objet.copy()
285 new_obj.reparent(etape)
286 etape.mc_liste.append(new_obj)
289 def get_noms_sd_oper_reentrant(self):
291 Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
292 qui sont du type que peut retourner cette commande
294 liste_sd = self.get_sd_utilisees()
296 if type(self.definition.sd_prod) == types.FunctionType:
297 d=self.cree_dict_valeurs(self.mc_liste)
299 classe_sd_prod = apply(self.definition.sd_prod,(),d)
303 classe_sd_prod = self.definition.sd_prod
305 if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom)
309 def get_sd_utilisees(self):
311 Retourne la liste des concepts qui sont utilisés à l'intérieur d'une commande
312 ( comme valorisation d'un MCS)
315 for child in self.mc_liste:
316 l.extend(child.get_sd_utilisees())
319 def get_genealogie(self):
321 Retourne la liste des noms des ascendants de l'objet self
322 en s'arretant à la première ETAPE rencontrée
326 def reparent(self,parent):
328 Cette methode sert a reinitialiser la parente de l'objet
331 self.jdc=parent.get_jdc_root()
333 for mocle in self.mc_liste:
336 def verif_existence_sd(self):
338 Vérifie que les structures de données utilisées dans self existent bien dans le contexte
339 avant étape, sinon enlève la référence à ces concepts
341 for motcle in self.mc_liste :
342 motcle.verif_existence_sd()
344 def Build_sd(self,nom):
346 Construit le concept produit de l'opérateur. Deux cas
347 peuvent se présenter :
349 - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
350 et le nommage du concept.
352 - le parent est défini. Dans ce cas, l'étape demande au parent la création et
353 le nommage du concept.
356 if not self.isactif():return
357 # FR : attention cette méthode ne devrait pas se trouver là car elle surcharge celle qui
358 # se trouve dans N_ETAPE.py et elle est partie intégrante du noyau, mais, suite à l'absence de
359 # test de validité de l'opérateur avant d'essayer de déterminer la sd produite, on n'arrivait
360 # pas à relire avec EFICAS un fichier contenant une étape encore incomplète du style :
361 # sansnom = AFFE_CHAR_CINE(MODELE=None)
362 # Suite à la stabilisation du noyau d'Aster, je n'ai pas eu d'autre solution que de surcharger
363 # cette méthode ici en rajoutant le test manquant ...
364 # CCAR : cette modification ne corrige le probleme qu'en partie. Il faudrait probablement
365 # supprimer les erreurs fatales (exception ) et retourner systematiquement un objet produit
366 # meme en cas d'erreur et reporter l'emission du message d'erreur a la phase de validation
368 if not self.isvalid(sd='non') : return
372 sd= self.parent.create_sdprod(self,nom)
373 if type(self.definition.op_init) == types.FunctionType:
374 apply(self.definition.op_init,(self,self.parent.g_context))
376 sd=self.get_sd_prod()
377 # On n'utilise pas self.definition.op_init car self.parent
379 if sd != None and self.reuse == None:
380 # On ne nomme le concept que dans le cas de non reutilisation
383 if self.jdc and self.jdc.par_lot == "NON" :
386 except AsException,e:
387 # Une erreur s'est produite lors de la construction du concept
388 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
389 # Si on poursuit, on a le choix entre deux possibilités :
390 # 1. on annule la sd associée à self
391 # 2. on la conserve mais il faut la retourner
392 # En plus il faut rendre coherents sdnom et sd.nom
397 #raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
398 # 'fichier : ',self.appel[1],e)
400 # XXX Normalement le contexte courant doit etre le parent.
401 # Il n'y a pas de raison de remettre le contexte au parent
402 #self.reset_current_step()
405 l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
406 raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
407 'fichier : ',self.appel[1]+'\n',