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 # ======================================================================
24 import types,traceback,sys
25 import string,linecache
30 from Noyau.N_ASSD import ASSD
31 from Noyau.N_LASSD import LASSD
32 from Noyau.N_ETAPE import ETAPE
33 from Noyau.N_Exception import AsException
34 from Extensions import commentaire,parametre,parametre_eval
37 class JDC(I_OBJECT.OBJECT):
42 self.etapes_niveaux=[]
46 self._etape_context=None
47 self.recorded_units={}
48 self.old_recorded_units={}
50 def get_index(self,objet):
52 Retourne la position d'objet dans la liste self
54 return self.etapes.index(objet)
56 def get_sd_avant_du_bon_type(self,etape,types_permis):
58 Retourne la liste des concepts avant etape d'un type acceptable
60 d=self.get_contexte_avant(etape)
63 if type(v) != types.InstanceType : continue
64 # On considère que seul assd indique un type quelconque pas CO
65 elif self.assd in types_permis :
67 elif self.est_permis(v,types_permis):
72 def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
74 Retourne la liste des concepts avant etape d'1 type de base acceptable
75 Attention different de la routine précédente : 1 seul type passé en parametre
76 Teste sur issubclass et par sur le type permis
78 d=self.get_contexte_avant(etape)
81 typeverif=self.cata[0].__dict__[type]
85 if issubclass(v.__class__,typeverif):
90 def cherche_list_avant(self,etape,valeur):
91 d=self.get_contexte_avant(etape)
93 if issubclass(v.__class__,LASSD):
96 # Attention pour enlever les . a la fin des pretendus reels
97 if k == valeur[0:-1] :
101 def est_permis(self,v,types_permis):
102 for type_ok in types_permis:
103 if type_ok in ('R','I','C','TXM') and v in self.params :
105 elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
107 elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
109 elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
111 elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
113 elif type(type_ok) != types.ClassType :
115 elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
119 def addentite(self,name,pos):
122 Si name est le nom d une commande ou un commentaire ajoute
124 Sinon remonte une erreur
128 if name == "COMMENTAIRE" :
129 # ajout d'un commentaire
130 self.set_current_step()
132 for child in self.etapes :
133 if isinstance(child,commentaire.COMMENTAIRE):
135 objet = commentaire.COMMENTAIRE('',parent=self)
136 objet.nom = "_comm_"+`ind`
137 if pos == None : pos = 0
138 self.etapes.insert(pos,objet)
141 CONNECTOR.Emit(self,"add",objet)
144 elif name == "PARAMETRE":
145 # ajout d'un parametre
146 self.set_current_step()
147 nom_param = '_param_'+str(len(self.params)+1)
148 objet = parametre.PARAMETRE(nom=nom_param)
149 if pos == None : pos = 0
150 self.etapes.insert(pos,objet)
154 CONNECTOR.Emit(self,"add",objet)
157 elif name == "PARAMETRE_EVAL":
158 # ajout d'un parametre EVAL
159 self.set_current_step()
160 nom_param = '_param_'+str(len(self.params)+1)
161 objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
162 if pos == None : pos = 0
163 self.etapes.insert(pos,objet)
167 CONNECTOR.Emit(self,"add",objet)
170 elif type(name)==types.InstanceType:
171 # on est dans le cas où on veut ajouter une commande déjà
172 # existante (par copie donc)
173 # on est donc nécessairement en mode editeur ...
175 # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
177 self.set_current_step()
178 if isinstance(objet,ETAPE):
179 if objet.nom_niveau_definition == 'JDC':
180 # l'objet dépend directement du JDC
183 # l'étape dépend d'un niveau et non directement du JDC :
184 # il faut l'enregistrer dans le niveau de parent
185 objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
186 objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
187 self.etapes.insert(pos,objet)
188 # il faut vérifier que les concepts utilisés par objet existent bien
189 # à ce niveau d'arborescence
190 objet.verif_existence_sd()
191 objet.update_mc_global()
195 CONNECTOR.Emit(self,"add",objet)
199 # On veut ajouter une nouvelle commande
201 self.set_current_step()
202 cmd=self.get_cmd(name)
203 # L'appel a make_objet n'a pas pour effet d'enregistrer l'étape
204 # auprès du step courant car editmode vaut 1
205 # Par contre elle a le bon parent grace a set_current_step
207 if pos == None : pos = 0
208 self.etapes.insert(pos,e)
209 self.reset_current_step()
213 CONNECTOR.Emit(self,"add",e)
216 except AsException,e:
217 self.reset_current_step()
219 raise AsException("Impossible d ajouter la commande "+name + '\n' +str(e))
221 traceback.print_exc()
222 self.reset_current_step()
224 raise AsException("Impossible d ajouter la commande "+name)
227 #print "JDC.close",self
228 for etape in self.etapes:
229 if hasattr(etape,"close"):etape.close()
230 CONNECTOR.Emit(self,"close")
232 def set_current_step(self):
233 CONTEXT.unset_current_step()
234 CONTEXT.set_current_step(self)
236 def reset_current_step(self):
237 CONTEXT.unset_current_step()
239 def liste_mc_presents(self):
242 def get_sd_avant_etape(self,nom_sd,etape):
243 return self.get_contexte_avant(etape).get(nom_sd,None)
245 def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
247 Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
248 définie apres etape en tenant compte des concepts detruits
249 Si avec vaut 'non' exclut etape de la recherche
251 #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
252 ietap=self.etapes.index(etape)
253 if avec == 'non':ietap=ietap+1
255 for e in self.etapes[ietap:]:
258 autre_sd=d.get(nom_sd,None)
260 # Le concept a ete detruit. On interrompt la recherche car il n'y a
261 # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
263 if autre_sd is not sd :
264 # L'etape produit un concept different de meme nom. La situation n'est
265 # pas saine (sauf peut etre si reuse ???)
266 if hasattr(e,'reuse') and e.reuse == autre_sd:
267 # Le concept etant reutilise, on interrompt la recherche.
268 # On considere qu'il n'y a pas de nouveau concept defini
269 # meme si dans les etapes suivantes le concept est detruit
270 # et un concept de meme nom créé.
271 # AVERIFIER : avec reuse le concept devrait etre le meme
272 # le passage par ici est tres improbable
275 # Le concept est produit par l'etape (Il y a conflit potentiel).
276 # Le concept est redefini par une etape posterieure.
278 # Pas de destruction du concept ni de redefinition. On retourne le
282 def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
284 Cette méthode retourne la SD de nom nom_sd qui est éventuellement
286 Si avec vaut 'non' exclut etape de la recherche
288 ietap=self.etapes.index(etape)
289 if avec == 'non':ietap=ietap+1
290 for e in self.etapes[ietap:]:
291 sd=e.get_sdprods(nom_sd)
293 if hasattr(e,'reuse'):
298 def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
300 Fonction: retourne la SD de nom nom_sd qui est éventuellement
301 définie avant ou apres etape
302 Permet de vérifier si un concept de meme nom existe dans le périmètre
304 Si avec vaut 'non' exclut etape de la recherche
306 sd=self.get_sd_avant_etape(nom_sd,etape)
308 return self.get_sd_apres_etape(nom_sd,etape,avec)
310 def get_contexte_apres(self,etape):
312 Retourne le dictionnaire des concepts connus apres etape
313 On tient compte des commandes qui modifient le contexte
314 comme DETRUIRE ou les macros
315 Si etape == None, on retourne le contexte en fin de JDC
317 if not etape: return self.get_contexte_avant(etape)
319 d=self.get_contexte_avant(etape)
320 if etape.isactif():etape.update_context(d)
321 self.index_etape_courante=self.index_etape_courante+1
324 def active_etapes(self):
326 Cette méthode a pour fonction de désactiver les étapes qui doivent
327 l'être cad, dans le cas d'ASTER, les étapes qui ne sont pas
328 comprises entre le premier DEBUT/POURSUITE et le premier FIN
329 et rendre actives les autres
331 if self.definition.code == 'ASTER' :
332 # Seulement pour ASTER :
333 # Avant DEBUT actif vaut 0
334 # Apres DEBUT et avant le 1er FIN actif vaut 1
335 # Apres le 1er FIN actif vaut -1
339 for etape in self.etapes:
340 if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
345 if etape.nom == 'FIN':actif=-1
347 def suppentite(self,etape) :
349 Cette methode a pour fonction de supprimer une étape dans
351 Retourne 1 si la suppression a pu être effectuée,
352 Retourne 0 dans le cas contraire
354 #print "suppentite",self
355 #PN correction de bugs
356 if etape not in self.etapes:
360 index_etape=self.etapes.index(etape)
361 self.etapes.remove(etape)
363 if etape.niveau is not self:
364 # Dans ce cas l'étape est enregistrée dans un niveau
365 # Il faut la désenregistrer
366 etape.niveau.unregister(etape)
368 etape.supprime_sdprods()
373 # Apres suppression de l'etape il faut controler que les etapes
374 # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
376 index_etape=index_etape-1
377 etape=self.etapes[index_etape]
380 self.control_context_apres(etape)
383 CONNECTOR.Emit(self,"supp",etape)
387 def control_context_apres(self,etape):
389 Cette méthode verifie que les etapes apres l'etape etape
390 ont bien des concepts produits acceptables (pas de conflit de
392 Si des concepts produits ne sont pas acceptables ils sont supprimés.
393 Effectue les verifications sur les etapes du jdc mais aussi sur les
394 jdc parents s'ils existent.
396 #print "control_context_apres",self,etape
397 #Regularise les etapes du jdc apres l'etape etape
398 self.control_jdc_context_apres(etape)
400 def control_jdc_context_apres(self,etape):
402 Methode semblable a control_context_apres mais ne travaille
403 que sur les etapes et sous etapes du jdc
405 #print "control_jdc_context_apres",self,etape
407 # on demarre de la premiere etape
410 index_etape=self.etapes.index(etape)+1
413 etape=self.etapes[index_etape]
415 #derniere etape du jdc : rien a faire
418 context=self.get_contexte_avant(etape)
420 for e in self.etapes[index_etape:]:
421 e.control_sdprods(context)
422 e.update_context(context)
426 if not self.cr.estvide():return
430 def register_parametre(self,param):
432 Cette méthode sert à ajouter un paramètre dans la liste des paramètres
434 self.params.append(param)
436 def register_fonction(self,fonction):
438 Cette méthode sert à ajouter une fonction dans la liste des fonctions
440 self.fonctions.append(fonction)
442 def delete_param(self,param):
444 Supprime le paramètre param de la liste des paramètres
447 if param in self.params : self.params.remove(param)
448 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
450 def get_parametres_fonctions_avant_etape(self,etape):
452 Retourne deux éléments :
453 - une liste contenant les noms des paramètres (constantes ou EVAL)
455 - une liste contenant les formules définies avant etape
459 # on récupère le contexte avant etape
460 # on ne peut mettre dans les deux listes que des éléments de ce contexte
461 d=self.get_contexte_avant(etape)
462 # construction de l_constantes
463 for param in self.params:
465 if not nom : continue
466 if d.has_key(nom): l_constantes.append(nom)
467 # construction de l_fonctions
468 for form in self.fonctions:
470 if not nom : continue
471 if d.has_key(nom): l_fonctions.append(form.get_formule())
473 # on ajoute les concepts produits par DEFI_VALEUR
474 # XXX On pourrait peut etre faire plutot le test sur le type
475 # de concept : entier, reel, complexe, etc.
476 for k,v in d.items():
477 if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
478 l_constantes.append(k)
480 # on retourne les deux listes
481 return l_constantes,l_fonctions
483 def get_nb_etapes_avant(self,niveau):
485 Retourne le nombre d etapes avant le debut de niveau
488 for niv in self.etapes_niveaux:
489 if niv == niveau:break
490 nb=nb+len(niv.etapes)
493 def send_message(self,message):
495 self.appli.send_message(message)
497 def init_modif(self):
499 Méthode appelée au moment où une modification va être faite afin de
500 déclencher d'éventuels traitements pré-modification
502 #print "init_modif",self
503 self.state = 'modified'
506 #print "fin_modif",self
507 CONNECTOR.Emit(self,"valid")
511 def deep_update_condition_bloc(self):
512 # pour le moment, on ne fait rien
513 raise "Not implemented"
515 def update_condition_bloc(self):
516 # pour le moment, on ne fait rien
517 raise "Not implemented"
519 def get_liste_mc_inconnus(self):
521 Retourne une liste contenant les mots-clés inconnus à la relecture du JDC
523 # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
525 for etape in self.etapes :
527 if not etape.isvalid() :
528 l = etape.get_liste_mc_inconnus()
529 if l : l_mc.extend(l)
532 def get_genealogie(self):
534 Retourne la liste des noms des ascendants de l'objet self
535 jusqu'à la première ETAPE parent.
539 def get_liste_cmd(self):
541 Retourne la liste des commandes du catalogue
543 return self.niveau.definition.get_liste_cmd()
545 def get_groups(self):
547 Retourne la liste des groupes
549 return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
551 def set_etape_context(self,etape):
553 Positionne l'etape qui sera utilisee dans NommerSdProd pour
554 decider si le concept passé pourra etre nommé
556 self._etape_context=etape
558 def reset_context(self):
560 Cette methode reinitialise le contexte glissant pour pouvoir
561 tenir compte des modifications de l'utilisateur : création
562 de commandes, nommage de concepts, etc.
564 #print "reset_context",self,self.nom
565 self.current_context={}
566 self.index_etape_courante=0
567 # for etape in self.etapes:
568 # etape.reset_context()
570 def del_sdprod(self,sd):
572 Supprime la SD sd de la liste des sd et des dictionnaires de contexte
574 #print "del_sdprod",self,sd
575 #print "del_sdprod",self.sds
576 #print "del_sdprod",self.g_context
577 #print "del_sdprod",self.sds_dict
578 if sd in self.sds : self.sds.remove(sd)
579 if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
580 if self.sds_dict.has_key(sd.nom) : del self.sds_dict[sd.nom]
582 def del_param(self,param):
584 Supprime le paramètre param de la liste des paramètres
587 if param in self.params : self.params.remove(param)
588 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
590 def del_fonction(self,fonction):
592 Supprime la fonction fonction de la liste des fonctions
595 if fonction in self.fonctions : self.fonctions.remove(fonction)
596 if self.g_context.has_key(fonction.nom) : del self.g_context[fonction.nom]
598 def append_sdprod(self,sd):
600 Ajoute la SD sd à la liste des sd en vérifiant au préalable qu'une SD de
601 même nom n'existe pas déjà
603 if sd == None or sd.nom == None:return
605 o=self.sds_dict.get(sd.nom,None)
606 if isinstance(o,ASSD):
607 raise AsException("Nom de concept deja defini : %s" % sd.nom)
608 self.sds_dict[sd.nom]=sd
609 self.g_context[sd.nom] = sd
610 if sd not in self.sds : self.sds.append(sd)
612 def append_param(self,param):
614 Ajoute le paramètre param à la liste des params
615 et au contexte global
617 # il faudrait vérifier qu'un paramètre de même nom n'existe pas déjà !!!
618 if param not in self.params : self.params.append(param)
619 self.g_context[param.nom]=param
621 def append_fonction(self,fonction):
623 Ajoute la fonction fonction à la liste des fonctions
624 et au contexte global
626 # il faudrait vérifier qu'une fonction de même nom n'existe pas déjà !!!
627 if fonction not in self.fonctions : self.fonctions.append(fonction)
628 self.g_context[fonction.nom]=fonction
630 def delete_concept(self,sd):
635 Mettre a jour les etapes du JDC suite à la disparition du
637 Seuls les mots cles simples MCSIMP font un traitement autre
638 que de transmettre aux fils
640 #print "delete_concept",self,sd
641 for etape in self.etapes :
642 etape.delete_concept(sd)
644 def replace_concept_after_etape(self,etape,old_sd,sd):
646 Met à jour les étapes du JDC qui sont après etape en fonction
647 du remplacement du concept sd
649 index = self.etapes.index(etape)+1
650 if index == len(self.etapes) :
651 return # etape est la dernière étape du jdc ...on ne fait rien !
652 for child in self.etapes[index:]:
653 child.replace_concept(old_sd,sd)
655 def update_concept_after_etape(self,etape,sd):
657 Met à jour les étapes du JDC qui sont après etape en fonction
658 de la modification (principalement nommage) du concept sd
661 #On traite toutes les etapes
664 index = self.etapes.index(etape)+1
665 if index == len(self.etapes) :
666 return # etape est la dernière étape du jdc ...on ne fait rien !
667 for child in self.etapes[index:]:
668 child.update_concept(sd)
670 def dump_state(self):
671 print "JDC.state: ",self.state
672 for etape in self.etapes :
673 print etape.nom+".state: ",etape.state
675 def change_unit(self,unit,etape,old_unit):
676 #print "change_unit",unit,etape,old_unit
677 #print id(self.recorded_units),self.recorded_units
678 #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
679 self.record_unit(unit,etape)
681 def record_unit(self,unit,etape):
682 """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
683 #print "record_unit",unit,etape
686 self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
688 self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
689 #print id(self.recorded_units),self.recorded_units
690 #print self.recorded_units.get(None,(None,"",{}))[2]
691 #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
693 def changefichier(self,fichier):
696 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
697 def register(self,etape):
699 Cette méthode ajoute etape dans la liste
700 des etapes self.etapes et retourne l identificateur d'étape
701 fourni par l appel a g_register
703 A quoi sert editmode ?
704 - Si editmode vaut 1, on est en mode edition de JDC. On cherche
705 à enregistrer une étape que l'on a créée avec eficas (en passant
706 par addentite) auquel cas on ne veut récupérer que son numéro
707 d'enregistrement et c'est addentité qui l'enregistre dans
708 self.etapes à la bonne place...
709 - Si editmode vaut 0, on est en mode relecture d'un fichier de
710 commandes et on doit enregistrer l'étape à la fin de self.etapes
711 (dans ce cas l'ordre des étapes est bien l'ordre chronologique
714 if not self.editmode:
715 self.etapes.append(etape)
718 return self.g_register(etape)
720 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
721 def NommerSdprod(self,sd,sdnom,restrict='non'):
723 Nomme la SD apres avoir verifie que le nommage est possible :
725 Si le nom est deja utilise, leve une exception
726 Met le concept créé dans le concept global g_context
728 # XXX En mode editeur dans EFICAS, le nommage doit etre géré différemment
729 # Le dictionnaire g_context ne représente pas le contexte
730 # effectif avant une étape.
731 # Il faut utiliser get_contexte_avant avec indication de l'étape
733 # Cette etape est indiquee par l'attribut _etape_context qui a ete
734 # positionné préalablement par un appel à set_etape_context
736 if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
738 if self._etape_context:
739 o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
741 o=self.sds_dict.get(sdnom,None)
743 if isinstance(o,ASSD):
744 raise AsException("Nom de concept deja defini : %s" % sdnom)
746 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
747 # Ajoute a la creation (appel de reg_sd).
748 self.sds_dict[sdnom]=sd
751 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
752 if restrict == 'non':
753 self.g_context[sdnom]=sd
755 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
756 def delete_concept_after_etape(self,etape,sd):
758 Met à jour les étapes du JDC qui sont après etape en fonction
759 de la disparition du concept sd
761 index = self.etapes.index(etape)+1
762 if index == len(self.etapes) :
763 return # etape est la dernière étape du jdc ...on ne fait rien !
764 for child in self.etapes[index:]:
765 child.delete_concept(sd)
767 #ATTENTION SURCHARGE : les methodes ci-dessous surchargent des methodes de Noyau et Validation : a reintegrer
769 def get_file(self,unite=None,fic_origine=''):
771 Retourne le nom du fichier correspondant à un numero d'unité
772 logique (entier) ainsi que le source contenu dans le fichier
775 # Si le JDC est relié à une application maitre, on délègue la recherche
776 file,text= self.appli.get_file(unite,fic_origine)
780 if os.path.exists("fort."+str(unite)):
781 file= "fort."+str(unite)
783 raise AsException("Impossible de trouver le fichier correspondant"
784 " a l unite %s" % unite)
785 if not os.path.exists(file):
786 raise AsException("%s n'est pas un fichier existant" % unite)
790 #if file == None : return None,None
791 text=string.replace(text,'\r\n','\n')
793 linecache.cache[file]=0,0,string.split(text,'\n'),file