1 # -*- coding: utf-8 -*-
2 # CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
8 # (AT YOUR OPTION) ANY LATER VERSION.
10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
17 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
20 # ======================================================================
28 # Objet re pour controler les identificateurs Python
29 concept_re=re.compile(r'[a-zA-Z_]\w*$')
31 # import rajoutés suite à l'ajout de Build_sd --> à résorber
34 from Noyau import N_Exception
35 from Noyau.N_Exception import AsException
37 # fin import à résorber
42 from Extensions import commande_comm
44 class ETAPE(I_MCCOMPO.MCCOMPO):
50 if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
52 if self.reuse != None:
53 sdname= self.reuse.get_name()
55 if self.sd:sdname=self.sd.get_name()
56 if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
57 # dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
61 def is_reentrant(self):
63 Indique si la commande est reentrante
65 return self.definition.reentrant == 'o'
69 Met l'état de l'étape à : modifié
70 Propage la modification au parent
72 # init_modif doit etre appelé avant de réaliser une modification
73 # La validité devra etre recalculée apres cette modification
74 # mais dans l'appel à fin_modif pour préserver l'état modified
75 # de tous les objets entre temps
76 #print "init_modif",self,self.parent
77 self.state = 'modified'
79 self.parent.init_modif()
83 Méthode appelée une fois qu'une modification a été faite afin de
84 déclencher d'éventuels traitements post-modification
85 ex : INCLUDE et POURSUITE
87 #print "fin_modif",self,self.parent
88 if self.nom == "DETRUIRE":
89 #Il n'est pas conseillé de mettre des traitements dans fin_modif. Ceci est une
90 # exception qu'il faut supprimer à terme.
91 #une commande DETRUIRE a été modifiée. Il faut verifier les commandes
93 #ATTENTION: aux eventuelles recursions
94 self.parent.control_context_apres(self)
97 CONNECTOR.Emit(self,"valid")
99 self.parent.fin_modif()
101 def nomme_sd(self,nom) :
103 Cette méthode a pour fonction de donner un nom (nom) au concept
104 produit par l'étape (self).
105 - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
106 - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
107 Les valeurs de retour sont :
108 - 0 si le nommage n'a pas pu etre mené à son terme,
109 - 1 dans le cas contraire
111 # Le nom d'un concept doit etre un identificateur Python (toujours vrai ?)
112 if not concept_re.match(nom):
113 return 0,"Un nom de concept doit etre un identificateur Python"
115 if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
116 return 0,"Nom de concept trop long (maxi 8 caractères)"
120 # On verifie d'abord si les mots cles sont valides
122 if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
124 # Cas particulier des opérateurs obligatoirement réentrants
126 if self.definition.reentrant == 'o':
127 self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
129 self.sdnom=self.sd.nom
131 return 1,"Concept existant"
133 return 0,"Opérateur réentrant mais concept non existant"
135 # Cas particulier des opérateurs facultativement réentrants
138 if self.definition.reentrant == 'f' :
139 sd = self.jdc.get_sd_avant_etape(nom,self)
141 # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
142 if isinstance(sd,self.get_type_produit()) :
143 self.sd = self.reuse = sd
146 return 1,"Opérateur facultativement réentrant et concept existant trouvé"
148 return 0,"Concept déjà existant et de mauvais type"
150 # il faut enlever le lien vers une SD existante car si on passe ici
151 # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
152 # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
155 self.sd = self.reuse = self.sdnom = None
157 # On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
158 # mais est utilisé en mode non réentrant
161 #Pas de concept produit preexistant
162 if self.parent.get_sd_autour_etape(nom,self):
163 # Un concept de ce nom existe dans le voisinage de l'etape courante
164 # On retablit l'ancien concept reentrant s'il existait
166 self.sd=self.reuse=old_reuse
167 self.sdnom=old_reuse.nom
168 return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
170 # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
171 # On peut donc créer le concept retourné.
172 # Il est créé sans nom mais enregistré dans la liste des concepts existants
175 # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
178 self.parent.update_concept_after_etape(self,self.sd)
180 return 1,"Nommage du concept effectué"
182 return 0,"Nommage impossible"+str(sys.exc_info()[1])
184 #Un concept produit preexiste
186 if string.find(old_nom,'sansnom') :
187 # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
188 # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
189 # on peut donc le nommer sans test préalable
190 if self.parent.get_sd_autour_etape(nom,self):
191 return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
193 # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
196 self.parent.update_concept_after_etape(self,self.sd)
198 return 1,"Nommage du concept effectué"
200 # Normalement l appel de isvalid a mis a jour le concept produit (son type)
201 # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
203 if self.parent.get_sd_autour_etape(nom,self):
204 return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
206 # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
209 self.parent.update_concept_after_etape(self,self.sd)
211 return 1,"Nommage du concept effectué"
213 # Normalement on ne devrait pas passer ici
214 return 0,'Normalement on ne devrait pas passer ici'
216 def get_sdprods(self,nom_sd):
218 Fonction : retourne le concept produit par l etape de nom nom_sd
219 s il existe sinon None
222 if self.sd.nom == nom_sd:return self.sd
226 Rend l'etape courante active.
227 Il faut ajouter la sd si elle existe au contexte global du JDC
235 self.jdc.append_sdprod(self.sd)
238 CONNECTOR.Emit(self,"add",None)
239 CONNECTOR.Emit(self,"valid")
243 Rend l'etape courante inactive
244 Il faut supprimer la sd du contexte global du JDC
245 et de la liste des sd
250 self.jdc.del_sdprod(self.sd)
251 self.jdc.delete_concept_after_etape(self,self.sd)
252 CONNECTOR.Emit(self,"supp",None)
253 CONNECTOR.Emit(self,"valid")
255 def control_sdprods(self,d):
257 Cette methode doit verifier que ses concepts produits ne sont pas
258 deja definis dans le contexte
259 Si c'est le cas, les concepts produits doivent etre supprimes
261 #print "control_sdprods",d.keys(),self.sd and self.sd.nom,self.nom
263 if d.has_key(self.sd.nom):
264 # Le concept est deja defini
265 if self.reuse and self.reuse is d[self.sd.nom]:
266 # Le concept est reutilise : situation normale
269 # Redefinition du concept, on l'annule
270 #XXX on pourrait simplement annuler son nom pour conserver les objets
271 # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
274 self.sd=self.reuse=self.sdnom=None
275 #supprime les references a sd dans les etapes suivantes
276 self.parent.delete_concept_after_etape(self,sd)
279 def supprime_sdprod(self,sd):
281 Supprime le concept produit sd s'il est produit par l'etape
283 if sd is not self.sd:return
286 self.parent.del_sdprod(sd)
289 self.parent.delete_concept(sd)
291 def supprime_sdprods(self):
294 Lors d'une destruction d'etape, detruit tous les concepts produits
295 Un opérateur n a qu un concept produit
296 Une procedure n'en a aucun
297 Une macro en a en général plus d'un
299 #print "supprime_sdprods",self
300 if self.reuse is self.sd :return
301 # l'étape n'est pas réentrante
302 # le concept retourné par l'étape est à supprimer car il était
305 self.parent.del_sdprod(self.sd)
306 self.parent.delete_concept(self.sd)
311 def update_concept(self,sd):
312 for child in self.mc_liste :
313 child.update_concept(sd)
315 def delete_concept(self,sd):
320 Mettre a jour les mots cles de l etape et eventuellement
321 le concept produit si reuse
322 suite à la disparition du concept sd
323 Seuls les mots cles simples MCSIMP font un traitement autre
324 que de transmettre aux fils
326 if self.reuse and self.reuse == sd:
327 self.sd=self.reuse=None
329 for child in self.mc_liste :
330 child.delete_concept(sd)
332 def replace_concept(self,old_sd,sd):
335 - old_sd=concept remplace
336 - sd = nouveau concept
338 Mettre a jour les mots cles de l etape et eventuellement
339 le concept produit si reuse
340 suite au remplacement du concept old_sd
342 if self.reuse and self.reuse == old_sd:
343 self.sd=self.reuse=sd
345 for child in self.mc_liste :
346 child.replace_concept(old_sd,sd)
348 def reset_context(self):
351 def get_noms_sd_oper_reentrant(self):
353 Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
354 qui sont du type que peut retourner cette commande
356 liste_sd = self.get_sd_utilisees()
358 if type(self.definition.sd_prod) == types.FunctionType:
359 d=self.cree_dict_valeurs(self.mc_liste)
361 classe_sd_prod = apply(self.definition.sd_prod,(),d)
365 classe_sd_prod = self.definition.sd_prod
367 if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom)
371 def get_genealogie(self):
373 Retourne la liste des noms des ascendants de l'objet self
374 en s'arretant à la première ETAPE rencontrée
378 def verif_existence_sd(self):
380 Vérifie que les structures de données utilisées dans self existent bien dans le contexte
381 avant étape, sinon enlève la référence à ces concepts
383 #print "verif_existence_sd",self.sd
384 for motcle in self.mc_liste :
385 motcle.verif_existence_sd()
387 def update_mc_global(self):
389 Met a jour les mots cles globaux enregistrés dans l'étape
390 et dans le jdc parent.
391 Une etape ne peut pas etre globale. Elle se contente de passer
392 la requete a ses fils apres avoir reinitialisé le dictionnaire
393 des mots cles globaux.
396 I_MCCOMPO.MCCOMPO.update_mc_global(self)
398 def update_condition_bloc(self):
400 Realise l'update des blocs conditionnels fils de self
402 self._update_condition_bloc()
404 def get_objet_commentarise(self,format):
406 Cette méthode retourne un objet commande commentarisée
407 representant la commande self
410 g=generator.plugins[format]()
411 texte_commande = g.gener(self,format='beautifie')
412 # Il faut enlever la première ligne vide de texte_commande que
413 # rajoute le generator
414 #rebut,texte_commande = string.split(texte_commande,'\n',1)
415 # on construit l'objet COMMANDE_COMM repésentatif de self mais non
416 # enregistré dans le jdc (pas ajouté dans jdc.etapes)
418 pos=self.parent.etapes.index(self)
419 commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
422 self.parent.suppentite(self)
423 parent.addentite(commande_comment,pos)
425 return commande_comment
428 #ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
429 def Build_sd(self,nom):
431 Methode de Noyau surchargee pour poursuivre malgre tout
432 si une erreur se produit pendant la creation du concept produit
435 sd=Noyau.N_ETAPE.ETAPE.Build_sd(self,nom)
436 except AsException,e:
437 # Une erreur s'est produite lors de la construction du concept
438 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
439 # Si on poursuit, on a le choix entre deux possibilités :
440 # 1. on annule la sd associée à self
441 # 2. on la conserve mais il faut la retourner
442 # En plus il faut rendre coherents sdnom et sd.nom
445 self.state="unchanged"
450 #ATTENTION SURCHARGE: cette methode doit etre gardée en synchronisation avec Noyau
451 def make_register(self):
453 Initialise les attributs jdc, id, niveau et réalise les
454 enregistrements nécessaires
455 Pour EFICAS, on tient compte des niveaux
456 Surcharge la methode make_register du package Noyau
459 self.jdc = self.parent.get_jdc_root()
460 self.id= self.parent.register(self)
461 self.UserError=self.jdc.UserError
462 if self.definition.niveau :
463 # La définition est dans un niveau. En plus on
464 # l'enregistre dans le niveau
465 self.nom_niveau_definition = self.definition.niveau.nom
466 self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
467 self.niveau.register(self)
469 # La définition est au niveau global
470 self.nom_niveau_definition = 'JDC'
471 self.niveau=self.parent
473 self.jdc = self.parent =None
476 self.UserError="UserError"
479 cr= Validation.V_ETAPE.ETAPE.report(self)
480 #rafraichissement de la validité de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)