1 # -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2013 EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 import types,traceback,sys,os
24 import string,linecache
25 from Extensions.i18n import tr
26 from Extensions.eficas_exception import EficasException
32 from Noyau.N_ASSD import ASSD
33 #from Noyau.N_LASSD import LASSD
34 from Noyau.N_ETAPE import ETAPE
35 from Noyau.N_Exception import AsException
36 from Extensions import commentaire,parametre,parametre_eval
43 class JDC(I_OBJECT.OBJECT):
48 self.etapes_niveaux=[]
52 self._etape_context=None
53 self.recorded_units={}
54 self.old_recorded_units={}
57 def get_index(self,objet):
59 Retourne la position d'objet dans la liste self
61 return self.etapes.index(objet)
63 def get_sd_avant_du_bon_type(self,etape,types_permis):
65 Retourne la liste des concepts avant etape d'un type acceptable
67 d=self.get_contexte_avant(etape)
72 if type(v) != types.InstanceType and not isinstance(v,object): continue
73 # On considere que seul assd indique un type quelconque pas CO
74 elif self.assd in types_permis :
75 if v.etape.sdnom != "sansnom" : l.append(k)
76 elif self.est_permis(v,types_permis):
77 if v.etape.sdnom != "sansnom" : l.append(k)
81 def get_variables(self,etape):
84 for etapeTraitee in self.etapes :
85 if etapeTraitee==etapeStop:
87 if etapeTraitee.nom == 'VARIABLE' :
88 variable=etapeTraitee.get_mocle('ModelVariable')
90 l.append(variable.nom)
93 def get_distributions(self,etape):
96 for etapeTraitee in self.etapes :
97 if etapeTraitee==etapeStop: break
98 if etapeTraitee.nom == 'DISTRIBUTION' and etapeTraitee.sd !=None : l.append(etapeTraitee.sd.nom)
102 #def set_Copules_recalcule_etat(self):
103 # for etapeTraitee in self.etapes :
104 # if etapeTraitee.nom == 'CORRELATION' :
105 #Matrix=etapeTraitee.get_child('Matrix')
107 # Correlation=etapeTraitee.get_child('CorrelationMatrix')
108 # if Correlation !=None : Correlation.state='arecalculer'
109 # Matrix.state='arecalculer'
111 #def recalcule_etat_correlation(self):
112 # for etapeTraitee in self.etapes :
113 # if etapeTraitee.nom == 'CORRELATION' :
114 #Matrix=etapeTraitee.get_child('Matrix')
116 # Matrix.state='arecalculer'
117 # Correlation=Matrix.get_child('CorrelationMatrix')
118 # if Correlation !=None : Correlation.state='arecalculer'
119 # Correlation.isvalid()
121 # etapeTraitee.state='arecalculer'
122 # if etapeTraitee.state=='arecalculer': etapeTraitee.isvalid()
124 def recalcule_etat_correlation(self):
125 for etapeTraitee in self.etapes :
126 if etapeTraitee.nom == 'CORRELATION' :
127 Correlation=etapeTraitee.get_child('CorrelationMatrix')
128 if Correlation !=None :
129 Correlation.state='arecalculer'
130 Correlation.isvalid()
131 etapeTraitee.isvalid()
133 def recalcule_validite_apres_changement_global_jdc(self):
134 #print "je passe dans recalcule_validite_apres_changement_global_jdc"
136 liste=self.get_jdc_root().cata[0].liste_condition
139 for etapeTraitee in self.etapes :
140 if etapeTraitee.nom not in liste: continue
141 self.forceRecalculBloc(etapeTraitee)
142 etapeTraitee.state='arecalculer'
143 etapeTraitee.isvalid()
146 def forceRecalculBloc(self,objet):
147 # Attention : certains objets deviennent None quand on recalcule
148 # les conditions d existence des blocs
149 if objet != None: objet.state='arecalculer'
150 if hasattr(objet,'liste_mc_presents'):
151 for childNom in objet.liste_mc_presents():
152 child=objet.get_child(childNom)
153 if hasattr(objet,'_update_condition_bloc'):objet._update_condition_bloc()
154 self.forceRecalculBloc(child)
157 def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
159 Retourne la liste des concepts avant etape d'1 type de base acceptable
160 Attention different de la routine precedente : 1 seul type passe en parametre
161 Teste sur issubclass et par sur le type permis
163 d=self.get_contexte_avant(etape)
166 typeverif=self.cata[0].__dict__[type]
169 for k,v in d.items():
170 if issubclass(v.__class__,typeverif):
175 def cherche_list_avant(self,etape,valeur):
176 d=self.get_contexte_avant(etape)
177 for k,v in d.items():
178 if issubclass(v.__class__,LASSD):
181 # Attention pour enlever les . a la fin des pretendus reels
182 if k == valeur[0:-1] :
186 def est_permis(self,v,types_permis):
187 for type_ok in types_permis:
188 if type_ok in ('R','I','C','TXM') and v in self.params :
190 elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
192 elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
194 elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
196 elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
198 elif type(type_ok) != types.ClassType and not isinstance(type_ok,type):
200 elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
204 def addentite(self,name,pos):
207 Si name est le nom d une commande ou un commentaire ajoute
209 Sinon remonte une erreur
213 if name == "COMMENTAIRE" :
214 # ajout d'un commentaire
215 self.set_current_step()
217 for child in self.etapes :
218 from Extensions import commentaire
219 if isinstance(child,commentaire.COMMENTAIRE):
221 objet = commentaire.COMMENTAIRE('',parent=self)
222 objet.nom = "_comm_"+`ind`
223 if pos == None : pos = 0
224 self.etapes.insert(pos,objet)
228 CONNECTOR.Emit(self,"add",objet)
231 elif name == "PARAMETRE":
232 # ajout d'un parametre
233 self.set_current_step()
234 nom_param = '_param_'+str(len(self.params)+1)
235 objet = parametre.PARAMETRE(nom=nom_param)
236 if pos == None : pos = 0
237 self.etapes.insert(pos,objet)
241 CONNECTOR.Emit(self,"add",objet)
244 elif name == "PARAMETRE_EVAL":
245 # ajout d'un parametre EVAL
246 self.set_current_step()
247 nom_param = '_param_'+str(len(self.params)+1)
248 objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
249 if pos == None : pos = 0
250 self.etapes.insert(pos,objet)
254 CONNECTOR.Emit(self,"add",objet)
257 elif type(name)==types.InstanceType:
258 # on est dans le cas ou on veut ajouter une commande deja
259 # existante (par copie donc)
260 # on est donc necessairement en mode editeur ...
262 # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
263 from Extensions import commentaire
264 if not( isinstance (objet,commentaire.COMMENTAIRE)):
266 self.set_current_step()
267 if isinstance(objet,ETAPE):
268 if objet.nom_niveau_definition == 'JDC':
269 # l'objet depend directement du JDC
272 # l'etape depend d'un niveau et non directement du JDC :
273 # il faut l'enregistrer dans le niveau de parent
274 objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
275 objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
276 self.etapes.insert(pos,objet)
278 # il faut verifier que les concepts utilises par objet existent bien
279 # a ce niveau d'arborescence
280 objet.verif_existence_sd()
281 objet.update_mc_global()
284 CONNECTOR.Emit(self,"add",objet)
288 # On veut ajouter une nouvelle commande
290 self.set_current_step()
291 cmd=self.get_cmd(name)
292 # L'appel a make_objet n'a pas pour effet d'enregistrer l'etape
293 # aupres du step courant car editmode vaut 1
294 # Par contre elle a le bon parent grace a set_current_step
296 if pos == None : pos = 0
297 self.etapes.insert(pos,e)
298 self.reset_current_step()
302 CONNECTOR.Emit(self,"add",e)
305 except AsException as e:
306 traceback.print_exc()
307 self.reset_current_step()
309 raise AsException(tr("Impossible d'ajouter la commande")+name + '\n')
312 traceback.print_exc()
313 self.reset_current_step()
315 raise AsException(tr("Impossible d ajouter la commande")+name)
318 #print "JDC.close",self
319 for etape in self.etapes:
320 if hasattr(etape,"close"):etape.close()
321 CONNECTOR.Emit(self,"close")
323 def set_current_step(self):
324 CONTEXT.unset_current_step()
325 CONTEXT.set_current_step(self)
327 def reset_current_step(self):
328 CONTEXT.unset_current_step()
330 def liste_mc_presents(self):
333 def get_sd_avant_etape(self,nom_sd,etape):
334 return self.get_contexte_avant(etape).get(nom_sd,None)
336 def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
338 Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
339 definie apres etape en tenant compte des concepts detruits
340 Si avec vaut 'non' exclut etape de la recherche
342 #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
343 ietap=self.etapes.index(etape)
344 if avec == 'non':ietap=ietap+1
346 for e in self.etapes[ietap:]:
349 autre_sd=d.get(nom_sd,None)
351 # Le concept a ete detruit. On interrompt la recherche car il n'y a
352 # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
354 if autre_sd is not sd :
355 # L'etape produit un concept different de meme nom. La situation n'est
356 # pas saine (sauf peut etre si reuse ???)
357 if hasattr(e,'reuse') and e.reuse == autre_sd:
358 # Le concept etant reutilise, on interrompt la recherche.
359 # On considere qu'il n'y a pas de nouveau concept defini
360 # meme si dans les etapes suivantes le concept est detruit
361 # et un concept de meme nom cree.
362 # AVERIFIER : avec reuse le concept devrait etre le meme
363 # le passage par ici est tres improbable
366 # Le concept est produit par l'etape (Il y a conflit potentiel).
367 # Le concept est redefini par une etape posterieure.
369 # Pas de destruction du concept ni de redefinition. On retourne le
373 def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
375 Cette methode retourne la SD de nom nom_sd qui est eventuellement
377 Si avec vaut 'non' exclut etape de la recherche
379 ietap=self.etapes.index(etape)
380 if avec == 'non':ietap=ietap+1
381 for e in self.etapes[ietap:]:
382 sd=e.get_sdprods(nom_sd)
384 if hasattr(e,'reuse'):
389 def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
391 Fonction: retourne la SD de nom nom_sd qui est eventuellement
392 definie avant ou apres etape
393 Permet de verifier si un concept de meme nom existe dans le perimetre
395 Si avec vaut 'non' exclut etape de la recherche
397 sd=self.get_sd_avant_etape(nom_sd,etape)
399 return self.get_sd_apres_etape(nom_sd,etape,avec)
401 def get_contexte_apres(self,etape):
403 Retourne le dictionnaire des concepts connus apres etape
404 On tient compte des commandes qui modifient le contexte
405 comme DETRUIRE ou les macros
406 Si etape == None, on retourne le contexte en fin de JDC
408 if not etape: return self.get_contexte_avant(etape)
410 d=self.get_contexte_avant(etape)
411 if etape.isactif():etape.update_context(d)
412 self.index_etape_courante=self.index_etape_courante+1
415 def active_etapes(self):
417 Cette methode a pour fonction de desactiver les etapes qui doivent
418 l'etre cad, dans le cas d'ASTER, les etapes qui ne sont pas
419 comprises entre le premier DEBUT/POURSUITE et le premier FIN
420 et rendre actives les autres
422 if self.definition.code == 'ASTER' :
423 # Seulement pour ASTER :
424 # Avant DEBUT actif vaut 0
425 # Apres DEBUT et avant le 1er FIN actif vaut 1
426 # Apres le 1er FIN actif vaut -1
430 for etape in self.etapes:
431 if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
436 if etape.nom == 'FIN':actif=-1
438 def deplaceEntite(self,indexNoeudACopier,indexNoeudOuColler,pos):
442 if indexNoeudACopier==indexNoeudOuColler:return
443 etapeACopier=self.etapes[indexNoeudACopier]
445 sd=self.etapes[indexNoeudACopier].sd
448 if pos=='before' and indexNoeudOuColler==0 :
449 self.etapes2=[etapeACopier,]+self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
450 elif indexNoeudACopier < indexNoeudOuColler :
451 self.etapes2=self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:]
453 self.etapes2=self.etapes[0:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
454 self.etapes=self.etapes2
455 if indexNoeudACopier < indexNoeudOuColler :
456 self.delete_concept_entre_etapes(indexNoeudACopier,indexNoeudOuColler,sd)
458 for e in self.etapes :
460 self.control_context_apres(None)
464 def suppentite(self,etape) :
466 Cette methode a pour fonction de supprimer une etape dans
468 Retourne 1 si la suppression a pu etre effectuee,
469 Retourne 0 dans le cas contraire
471 #PN correction de bugs
472 if etape not in self.etapes: return 0
475 index_etape=self.etapes.index(etape)
477 self.etapes.remove(etape)
479 if etape.niveau is not self:
480 # Dans ce cas l'etape est enregistree dans un niveau
481 # Il faut la desenregistrer
482 etape.niveau.unregister(etape)
484 etape.supprime_sdprods()
489 # Apres suppression de l'etape il faut controler que les etapes
490 # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
492 index_etape=index_etape-1
493 etape=self.etapes[index_etape]
496 self.control_context_apres(etape)
499 CONNECTOR.Emit(self,"supp",etape)
503 def control_context_apres(self,etape):
505 Cette methode verifie que les etapes apres l'etape etape
506 ont bien des concepts produits acceptables (pas de conflit de
508 Si des concepts produits ne sont pas acceptables ils sont supprimes.
509 Effectue les verifications sur les etapes du jdc mais aussi sur les
510 jdc parents s'ils existent.
512 #print "control_context_apres",self,etape
513 #Regularise les etapes du jdc apres l'etape etape
514 self.control_jdc_context_apres(etape)
516 def control_jdc_context_apres(self,etape):
518 Methode semblable a control_context_apres mais ne travaille
519 que sur les etapes et sous etapes du jdc
521 #print "control_jdc_context_apres",self,etape
523 # on demarre de la premiere etape
526 index_etape=self.etapes.index(etape)+1
529 etape=self.etapes[index_etape]
531 #derniere etape du jdc : rien a faire
534 context=self.get_contexte_avant(etape)
536 for e in self.etapes[index_etape:]:
537 e.control_sdprods(context)
538 e.update_context(context)
542 if not self.cr.estvide():return
546 def register_parametre(self,param):
548 Cette methode sert a ajouter un parametre dans la liste des parametres
550 self.params.append(param)
552 def register_fonction(self,fonction):
554 Cette methode sert a ajouter une fonction dans la liste des fonctions
556 self.fonctions.append(fonction)
558 def delete_param(self,param):
560 Supprime le parametre param de la liste des parametres
563 if param in self.params : self.params.remove(param)
564 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
566 def get_parametres_fonctions_avant_etape(self,etape):
568 Retourne deux elements :
569 - une liste contenant les noms des parametres (constantes ou EVAL)
571 - une liste contenant les formules definies avant etape
575 # on recupere le contexte avant etape
576 # on ne peut mettre dans les deux listes que des elements de ce contexte
577 d=self.get_contexte_avant(etape)
578 # construction de l_constantes
579 for param in self.params:
581 if not nom : continue
582 if d.has_key(nom): l_constantes.append(nom)
583 # construction de l_fonctions
584 for form in self.fonctions:
586 if not nom : continue
587 if d.has_key(nom): l_fonctions.append(form.get_formule())
589 # on ajoute les concepts produits par DEFI_VALEUR
590 # XXX On pourrait peut etre faire plutot le test sur le type
591 # de concept : entier, reel, complexe, etc.
592 for k,v in d.items():
593 if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
594 l_constantes.append(k)
596 # on retourne les deux listes
597 return l_constantes,l_fonctions
599 def get_nb_etapes_avant(self,niveau):
601 Retourne le nombre d etapes avant le debut de niveau
604 for niv in self.etapes_niveaux:
605 if niv == niveau:break
606 nb=nb+len(niv.etapes)
609 def init_modif(self):
611 Methode appelee au moment ou une modification va etre faite afin de
612 declencher d'eventuels traitements pre-modification
614 #print "init_modif",self
615 self.state = 'modified'
618 #print "fin_modif",self
619 CONNECTOR.Emit(self,"valid")
623 def deep_update_condition_bloc(self):
624 # pour le moment, on ne fait rien
625 self.get_jdc_root().recalcule_validite_apres_changement_global_jdc()
626 #raise EficasException(tr("Pas implemente"))
628 def update_condition_bloc(self):
629 # pour le moment, on ne fait rien
630 raise EficasException(tr("Pas implemente"))
632 def get_liste_mc_inconnus(self):
634 Retourne une liste contenant les mots-cles inconnus a la relecture du JDC
636 # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
638 for etape in self.etapes :
640 if not etape.isvalid() :
641 l = etape.get_liste_mc_inconnus()
642 if l : l_mc.extend(l)
645 def get_genealogie_precise(self):
648 def get_genealogie(self):
650 Retourne la liste des noms des ascendants de l'objet self
651 jusqu'a la premiere ETAPE parent.
655 def get_liste_cmd(self):
657 Retourne la liste des commandes du catalogue
659 return self.niveau.definition.get_liste_cmd()
661 def get_groups(self):
663 Retourne la liste des groupes
665 return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
667 def set_etape_context(self,etape):
669 Positionne l'etape qui sera utilisee dans NommerSdProd pour
670 decider si le concept passe pourra etre nomme
672 self._etape_context=etape
674 def reset_context(self):
676 Cette methode reinitialise le contexte glissant pour pouvoir
677 tenir compte des modifications de l'utilisateur : craation
678 de commandes, nommage de concepts, etc.
680 #print "reset_context",self,self.nom
681 self.current_context={}
682 self.index_etape_courante=0
684 for i,etape in enumerate(self.etapes):
686 self.index_etapes=ind
688 # for etape in self.etapes:
689 # etape.reset_context()
691 def del_sdprod(self,sd):
693 Supprime la SD sd de la liste des sd et des dictionnaires de contexte
695 #print "del_sdprod",self,sd
696 #print "del_sdprod",self.sds
697 #print "del_sdprod",self.g_context
698 #print "del_sdprod",self.sds_dict
699 #if sd in self.sds : self.sds.remove(sd)
700 if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
701 if self.sds_dict.has_key(sd.nom) : del self.sds_dict[sd.nom]
703 def del_param(self,param):
705 Supprime le parametre param de la liste des paramatres
708 if param in self.params : self.params.remove(param)
709 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
711 def del_fonction(self,fonction):
713 Supprime la fonction fonction de la liste des fonctions
716 if fonction in self.fonctions : self.fonctions.remove(fonction)
717 if self.g_context.has_key(fonction.nom) : del self.g_context[fonction.nom]
719 def append_sdprod(self,sd):
721 Ajoute la SD sd a la liste des sd en verifiant au prealable qu'une SD de
722 meme nom n'existe pas deja
724 if sd == None or sd.nom == None:return
726 o=self.sds_dict.get(sd.nom,None)
727 if isinstance(o,ASSD):
728 raise AsException(tr("Nom de concept deja defini "+ sd.nom))
729 self.sds_dict[sd.nom]=sd
730 self.g_context[sd.nom] = sd
731 #if sd not in self.sds : self.sds.append(sd)
733 def append_param(self,param):
735 Ajoute le parametre param a la liste des params
736 et au contexte global
738 # il faudrait verifier qu'un parametre de meme nom n'existe pas deja !!!
739 if param not in self.params : self.params.append(param)
740 self.g_context[param.nom]=param
742 def append_fonction(self,fonction):
744 Ajoute la fonction fonction a la liste des fonctions
745 et au contexte global
747 # il faudrait verifier qu'une fonction de meme nom n'existe pas deja !!!
748 if fonction not in self.fonctions : self.fonctions.append(fonction)
749 self.g_context[fonction.nom]=fonction
751 def delete_concept(self,sd):
756 Mettre a jour les etapes du JDC suite a la disparition du
758 Seuls les mots cles simples MCSIMP font un traitement autre
759 que de transmettre aux fils
761 for etape in self.etapes :
762 etape.delete_concept(sd)
763 #PN PN PN pour les matrices ????
764 #self.get_variables_avant(etape)
766 def replace_concept_after_etape(self,etape,old_sd,sd):
768 Met a jour les etapes du JDC qui sont apres etape en fonction
769 du remplacement du concept sd
771 index = self.etapes.index(etape)+1
772 if index == len(self.etapes) :
773 return # etape est la derniere etape du jdc ...on ne fait rien !
774 for child in self.etapes[index:]:
775 child.replace_concept(old_sd,sd)
777 def update_concept_after_etape(self,etape,sd):
779 Met a jour les etapes du JDC qui sont apres etape en fonction
780 de la modification (principalement nommage) du concept sd
783 #On traite toutes les etapes
786 index = self.etapes.index(etape)+1
787 if index == len(self.etapes) :
788 return # etape est la derniere etape du jdc ...on ne fait rien !
789 for child in self.etapes[index:]:
790 child.update_concept(sd)
792 def dump_state(self):
793 print ("JDC.state: ",self.state)
794 for etape in self.etapes :
795 print (etape.nom+".state: ",etape.state)
797 def change_unit(self,unit,etape,old_unit):
798 #print "change_unit",unit,etape,old_unit
799 #print id(self.recorded_units),self.recorded_units
800 #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
801 self.record_unit(unit,etape)
803 def record_unit(self,unit,etape):
804 """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
805 #print "record_unit",unit,etape
808 self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
810 self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
811 #print id(self.recorded_units),self.recorded_units
812 #print self.recorded_units.get(None,(None,"",{}))[2]
813 #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
815 def changefichier(self,fichier):
818 def eval_in_context(self,valeur,etape):
819 """ Tente d'evaluer valeur dans le contexte courant de etape
820 Retourne le parametre valeur inchange si l'evaluation est impossible
822 #contexte initial du jdc
823 context=self.condition_context.copy()
824 #contexte courant des concepts. Il contient les parametres
825 context.update(self.get_contexte_avant(etape))
827 objet = eval(valeur,context)
830 #traceback.print_exc()
834 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
836 Noyau.N_JDC.JDC.supprime(self)
837 for etape in self.etapes:
841 self.const_context={}
844 self.current_context={}
845 self.condition_context={}
846 self.etapes_niveaux=[]
850 self._etape_context=None
853 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
854 def register(self,etape):
856 Cette methode ajoute etape dans la liste
857 des etapes self.etapes et retourne l identificateur d'etape
858 fourni par l appel a g_register
860 A quoi sert editmode ?
861 - Si editmode vaut 1, on est en mode edition de JDC. On cherche
862 a enregistrer une etape que l'on a creee avec eficas (en passant
863 par addentite) auquel cas on ne veut recuperer que son numero
864 d'enregistrement et c'est addentite qui l'enregistre dans
865 self.etapes a la bonne place...
866 - Si editmode vaut 0, on est en mode relecture d'un fichier de
867 commandes et on doit enregistrer l'etape a la fin de self.etapes
868 (dans ce cas l'ordre des etapes est bien l'ordre chronologique
871 if not self.editmode:
872 self.etapes.append(etape)
873 self.index_etapes[etape] = len(self.etapes) - 1
876 return self.g_register(etape)
878 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
879 def NommerSdprod(self,sd,sdnom,restrict='non'):
881 Nomme la SD apres avoir verifie que le nommage est possible :
883 Si le nom est deja utilise, leve une exception
884 Met le concept cree dans le concept global g_context
886 # XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment
887 # Le dictionnaire g_context ne represente pas le contexte
888 # effectif avant une etape.
889 # Il faut utiliser get_contexte_avant avec indication de l'etape
891 # Cette etape est indiquee par l'attribut _etape_context qui a ete
892 # positionne prealablement par un appel a set_etape_context
894 if CONTEXT.debug : print ("JDC.NommerSdprod ",sd,sdnom)
896 if self._etape_context:
897 o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
899 o=self.sds_dict.get(sdnom,None)
901 if isinstance(o,ASSD):
902 raise AsException(tr(" Nom de concept deja defini : "+ sdnom))
904 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
905 # Ajoute a la creation (appel de reg_sd).
906 self.sds_dict[sdnom]=sd
909 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
910 if restrict == 'non':
911 self.g_context[sdnom]=sd
913 def delete_concept_entre_etapes(self,index1,index2,sd):
914 if index2 <= index1 :return
915 for child in self.etapes[index1:index2]:
916 child.delete_concept(sd)
918 def delete_concept_after_etape(self,etape,sd):
920 Met a jour les etapes du JDC qui sont apres etape en fonction
921 de la disparition du concept sd
923 index = self.etapes.index(etape)+1
924 if index == len(self.etapes) :
925 return # etape est la derniere etape du jdc ...on ne fait rien !
926 for child in self.etapes[index:]:
927 child.delete_concept(sd)
929 #ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer
931 def get_file(self,unite=None,fic_origine=''):
933 Retourne le nom du fichier correspondant a un numero d'unite
934 logique (entier) ainsi que le source contenu dans le fichier
936 if self.appli is not None:
937 # Si le JDC est relie a une application maitre, on delegue la recherche
938 file,text= self.appli.get_file(unite,fic_origine)
942 if os.path.exists(u"fort."+str(unite)):
943 file= "fort."+str(unite)
945 raise AsException(tr("Impossible de trouver le fichier correspondant a l'unite "+str( unite)))
946 if not os.path.exists(file):
947 raise AsException(str(unite)+ tr(" n'est pas un fichier existant"))
951 #if file == None : return None,None
952 text=string.replace(text,'\r\n','\n')
954 linecache.cache[file]=0,0,string.split(text,'\n'),file
957 def isvalid(self,cr='non'):
958 if hasattr(self,'valid'): old_valid=self.valid
960 valid=Validation.V_JDC.JDC.isvalid(self,cr)
961 if valid != old_valid:
962 CONNECTOR.Emit(self,"valid")
965 def get_l_noms_etapes(self):
967 Retourne la liste des noms des etapes de self
970 for etape in self.etapes: