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 from __future__ import absolute_import
24 from __future__ import print_function
25 import types,traceback,sys,os
27 from Extensions.i18n import tr
28 from Extensions.eficas_exception import EficasException
32 from . import I_OBJECT
34 from Noyau.N_ASSD import ASSD
35 #from Noyau.N_LASSD import LASSD
36 from Noyau.N_ETAPE import ETAPE
37 from Noyau.N_Exception import AsException
38 from Extensions import commentaire,parametre,parametre_eval
39 from . import CONNECTOR
45 class JDC(I_OBJECT.OBJECT):
50 self.etapes_niveaux=[]
54 self._etape_context=None
55 self.recorded_units={}
56 self.old_recorded_units={}
59 def get_index(self,objet):
61 Retourne la position d'objet dans la liste self
63 return self.etapes.index(objet)
65 def get_sd_avant_du_bon_type(self,etape,types_permis):
67 Retourne la liste des concepts avant etape d'un type acceptable
69 d=self.get_contexte_avant(etape)
74 if type(v) != types.InstanceType and not isinstance(v,object): continue
75 # On considere que seul assd indique un type quelconque pas CO
76 elif self.assd in types_permis :
77 if v.etape.sdnom != "sansnom" : l.append(k)
78 elif self.est_permis(v,types_permis):
79 if v.etape.sdnom != "sansnom" : l.append(k)
83 def get_variables(self,etape):
86 for etapeTraitee in self.etapes :
87 if etapeTraitee==etapeStop:
89 if etapeTraitee.nom == 'VARIABLE' :
90 variable=etapeTraitee.get_mocle('ModelVariable')
92 l.append(variable.nom)
95 def get_distributions(self,etape):
98 for etapeTraitee in self.etapes :
99 if etapeTraitee==etapeStop: break
100 if etapeTraitee.nom == 'DISTRIBUTION' and etapeTraitee.sd !=None : l.append(etapeTraitee.sd.nom)
104 #def set_Copules_recalcule_etat(self):
105 # for etapeTraitee in self.etapes :
106 # if etapeTraitee.nom == 'CORRELATION' :
107 #Matrix=etapeTraitee.get_child('Matrix')
109 # Correlation=etapeTraitee.get_child('CorrelationMatrix')
110 # if Correlation !=None : Correlation.state='arecalculer'
111 # Matrix.state='arecalculer'
113 #def recalcule_etat_correlation(self):
114 # for etapeTraitee in self.etapes :
115 # if etapeTraitee.nom == 'CORRELATION' :
116 #Matrix=etapeTraitee.get_child('Matrix')
118 # Matrix.state='arecalculer'
119 # Correlation=Matrix.get_child('CorrelationMatrix')
120 # if Correlation !=None : Correlation.state='arecalculer'
121 # Correlation.isvalid()
123 # etapeTraitee.state='arecalculer'
124 # if etapeTraitee.state=='arecalculer': etapeTraitee.isvalid()
126 def recalcule_etat_correlation(self):
127 for etapeTraitee in self.etapes :
128 if etapeTraitee.nom == 'CORRELATION' :
129 Correlation=etapeTraitee.get_child('CorrelationMatrix')
130 if Correlation !=None :
131 Correlation.state='arecalculer'
132 Correlation.isvalid()
133 etapeTraitee.isvalid()
135 def recalcule_validite_apres_changement_global_jdc(self):
136 #print "je passe dans recalcule_validite_apres_changement_global_jdc"
138 liste=self.get_jdc_root().cata[0].liste_condition
141 for etapeTraitee in self.etapes :
142 if etapeTraitee.nom not in liste: continue
143 self.forceRecalculBloc(etapeTraitee)
144 etapeTraitee.state='arecalculer'
145 etapeTraitee.isvalid()
148 def forceRecalculBloc(self,objet):
149 # Attention : certains objets deviennent None quand on recalcule
150 # les conditions d existence des blocs
151 if objet != None: objet.state='arecalculer'
152 if hasattr(objet,'liste_mc_presents'):
153 for childNom in objet.liste_mc_presents():
154 child=objet.get_child(childNom)
155 if hasattr(objet,'_update_condition_bloc'):objet._update_condition_bloc()
156 self.forceRecalculBloc(child)
159 def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
161 Retourne la liste des concepts avant etape d'1 type de base acceptable
162 Attention different de la routine precedente : 1 seul type passe en parametre
163 Teste sur issubclass et par sur le type permis
165 d=self.get_contexte_avant(etape)
168 typeverif=self.cata[0].__dict__[type]
171 for k,v in d.items():
172 if issubclass(v.__class__,typeverif):
177 def cherche_list_avant(self,etape,valeur):
178 d=self.get_contexte_avant(etape)
179 for k,v in d.items():
180 if issubclass(v.__class__,LASSD):
183 # Attention pour enlever les . a la fin des pretendus reels
184 if k == valeur[0:-1] :
188 def est_permis(self,v,types_permis):
189 for type_ok in types_permis:
190 if type_ok in ('R','I','C','TXM') and v in self.params :
192 elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
194 elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
196 elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
198 elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
200 elif type(type_ok) != type and not isinstance(type_ok,type):
202 elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
206 def addentite(self,name,pos):
209 Si name est le nom d une commande ou un commentaire ajoute
211 Sinon remonte une erreur
215 if name == "COMMENTAIRE" :
216 # ajout d'un commentaire
217 self.set_current_step()
219 for child in self.etapes :
220 from Extensions import commentaire
221 if isinstance(child,commentaire.COMMENTAIRE):
223 objet = commentaire.COMMENTAIRE('',parent=self)
224 objet.nom = "_comm_"+repr(ind)
225 if pos == None : pos = 0
226 self.etapes.insert(pos,objet)
230 CONNECTOR.Emit(self,"add",objet)
233 elif name == "PARAMETRE":
234 # ajout d'un parametre
235 self.set_current_step()
236 nom_param = '_param_'+str(len(self.params)+1)
237 objet = parametre.PARAMETRE(nom=nom_param)
238 if pos == None : pos = 0
239 self.etapes.insert(pos,objet)
243 CONNECTOR.Emit(self,"add",objet)
246 elif name == "PARAMETRE_EVAL":
247 # ajout d'un parametre EVAL
248 self.set_current_step()
249 nom_param = '_param_'+str(len(self.params)+1)
250 objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
251 if pos == None : pos = 0
252 self.etapes.insert(pos,objet)
256 CONNECTOR.Emit(self,"add",objet)
259 elif type(name)==types.InstanceType:
260 # on est dans le cas ou on veut ajouter une commande deja
261 # existante (par copie donc)
262 # on est donc necessairement en mode editeur ...
264 # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
265 from Extensions import commentaire
266 if not( isinstance (objet,commentaire.COMMENTAIRE)):
268 self.set_current_step()
269 if isinstance(objet,ETAPE):
270 if objet.nom_niveau_definition == 'JDC':
271 # l'objet depend directement du JDC
274 # l'etape depend d'un niveau et non directement du JDC :
275 # il faut l'enregistrer dans le niveau de parent
276 objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
277 objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
278 self.etapes.insert(pos,objet)
280 # il faut verifier que les concepts utilises par objet existent bien
281 # a ce niveau d'arborescence
282 objet.verif_existence_sd()
283 objet.update_mc_global()
286 CONNECTOR.Emit(self,"add",objet)
290 # On veut ajouter une nouvelle commande
292 self.set_current_step()
293 cmd=self.get_cmd(name)
294 # L'appel a make_objet n'a pas pour effet d'enregistrer l'etape
295 # aupres du step courant car editmode vaut 1
296 # Par contre elle a le bon parent grace a set_current_step
298 if pos == None : pos = 0
299 self.etapes.insert(pos,e)
300 self.reset_current_step()
304 CONNECTOR.Emit(self,"add",e)
307 except AsException as e:
308 traceback.print_exc()
309 self.reset_current_step()
311 raise AsException(tr("Impossible d'ajouter la commande")+name + '\n')
314 traceback.print_exc()
315 self.reset_current_step()
317 raise AsException(tr("Impossible d ajouter la commande")+name)
320 #print "JDC.close",self
321 for etape in self.etapes:
322 if hasattr(etape,"close"):etape.close()
323 CONNECTOR.Emit(self,"close")
325 def set_current_step(self):
326 CONTEXT.unset_current_step()
327 CONTEXT.set_current_step(self)
329 def reset_current_step(self):
330 CONTEXT.unset_current_step()
332 def liste_mc_presents(self):
335 def get_sd_avant_etape(self,nom_sd,etape):
336 return self.get_contexte_avant(etape).get(nom_sd,None)
338 def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
340 Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
341 definie apres etape en tenant compte des concepts detruits
342 Si avec vaut 'non' exclut etape de la recherche
344 #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
345 ietap=self.etapes.index(etape)
346 if avec == 'non':ietap=ietap+1
348 for e in self.etapes[ietap:]:
351 autre_sd=d.get(nom_sd,None)
353 # Le concept a ete detruit. On interrompt la recherche car il n'y a
354 # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
356 if autre_sd is not sd :
357 # L'etape produit un concept different de meme nom. La situation n'est
358 # pas saine (sauf peut etre si reuse ???)
359 if hasattr(e,'reuse') and e.reuse == autre_sd:
360 # Le concept etant reutilise, on interrompt la recherche.
361 # On considere qu'il n'y a pas de nouveau concept defini
362 # meme si dans les etapes suivantes le concept est detruit
363 # et un concept de meme nom cree.
364 # AVERIFIER : avec reuse le concept devrait etre le meme
365 # le passage par ici est tres improbable
368 # Le concept est produit par l'etape (Il y a conflit potentiel).
369 # Le concept est redefini par une etape posterieure.
371 # Pas de destruction du concept ni de redefinition. On retourne le
375 def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
377 Cette methode retourne la SD de nom nom_sd qui est eventuellement
379 Si avec vaut 'non' exclut etape de la recherche
381 ietap=self.etapes.index(etape)
382 if avec == 'non':ietap=ietap+1
383 for e in self.etapes[ietap:]:
384 sd=e.get_sdprods(nom_sd)
386 if hasattr(e,'reuse'):
391 def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
393 Fonction: retourne la SD de nom nom_sd qui est eventuellement
394 definie avant ou apres etape
395 Permet de verifier si un concept de meme nom existe dans le perimetre
397 Si avec vaut 'non' exclut etape de la recherche
399 sd=self.get_sd_avant_etape(nom_sd,etape)
401 return self.get_sd_apres_etape(nom_sd,etape,avec)
403 def get_contexte_apres(self,etape):
405 Retourne le dictionnaire des concepts connus apres etape
406 On tient compte des commandes qui modifient le contexte
407 comme DETRUIRE ou les macros
408 Si etape == None, on retourne le contexte en fin de JDC
410 if not etape: return self.get_contexte_avant(etape)
412 d=self.get_contexte_avant(etape)
413 if etape.isactif():etape.update_context(d)
414 self.index_etape_courante=self.index_etape_courante+1
417 def active_etapes(self):
419 Cette methode a pour fonction de desactiver les etapes qui doivent
420 l'etre cad, dans le cas d'ASTER, les etapes qui ne sont pas
421 comprises entre le premier DEBUT/POURSUITE et le premier FIN
422 et rendre actives les autres
424 if self.definition.code == 'ASTER' :
425 # Seulement pour ASTER :
426 # Avant DEBUT actif vaut 0
427 # Apres DEBUT et avant le 1er FIN actif vaut 1
428 # Apres le 1er FIN actif vaut -1
432 for etape in self.etapes:
433 if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
438 if etape.nom == 'FIN':actif=-1
440 def deplaceEntite(self,indexNoeudACopier,indexNoeudOuColler,pos):
444 if indexNoeudACopier==indexNoeudOuColler:return
445 etapeACopier=self.etapes[indexNoeudACopier]
447 sd=self.etapes[indexNoeudACopier].sd
450 if pos=='before' and indexNoeudOuColler==0 :
451 self.etapes2=[etapeACopier,]+self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
452 elif indexNoeudACopier < indexNoeudOuColler :
453 self.etapes2=self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:]
455 self.etapes2=self.etapes[0:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
456 self.etapes=self.etapes2
457 if indexNoeudACopier < indexNoeudOuColler :
458 self.delete_concept_entre_etapes(indexNoeudACopier,indexNoeudOuColler,sd)
460 for e in self.etapes :
462 self.control_context_apres(None)
466 def suppentite(self,etape) :
468 Cette methode a pour fonction de supprimer une etape dans
470 Retourne 1 si la suppression a pu etre effectuee,
471 Retourne 0 dans le cas contraire
473 #PN correction de bugs
474 if etape not in self.etapes: return 0
477 index_etape=self.etapes.index(etape)
479 self.etapes.remove(etape)
481 if etape.niveau is not self:
482 # Dans ce cas l'etape est enregistree dans un niveau
483 # Il faut la desenregistrer
484 etape.niveau.unregister(etape)
486 etape.supprime_sdprods()
491 # Apres suppression de l'etape il faut controler que les etapes
492 # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
494 index_etape=index_etape-1
495 etape=self.etapes[index_etape]
498 self.control_context_apres(etape)
501 CONNECTOR.Emit(self,"supp",etape)
505 def control_context_apres(self,etape):
507 Cette methode verifie que les etapes apres l'etape etape
508 ont bien des concepts produits acceptables (pas de conflit de
510 Si des concepts produits ne sont pas acceptables ils sont supprimes.
511 Effectue les verifications sur les etapes du jdc mais aussi sur les
512 jdc parents s'ils existent.
514 #print "control_context_apres",self,etape
515 #Regularise les etapes du jdc apres l'etape etape
516 self.control_jdc_context_apres(etape)
518 def control_jdc_context_apres(self,etape):
520 Methode semblable a control_context_apres mais ne travaille
521 que sur les etapes et sous etapes du jdc
523 #print "control_jdc_context_apres",self,etape
525 # on demarre de la premiere etape
528 index_etape=self.etapes.index(etape)+1
531 etape=self.etapes[index_etape]
533 #derniere etape du jdc : rien a faire
536 context=self.get_contexte_avant(etape)
538 for e in self.etapes[index_etape:]:
539 e.control_sdprods(context)
540 e.update_context(context)
544 if not self.cr.estvide():return
548 def register_parametre(self,param):
550 Cette methode sert a ajouter un parametre dans la liste des parametres
552 self.params.append(param)
554 def register_fonction(self,fonction):
556 Cette methode sert a ajouter une fonction dans la liste des fonctions
558 self.fonctions.append(fonction)
560 def delete_param(self,param):
562 Supprime le parametre param de la liste des parametres
565 if param in self.params : self.params.remove(param)
566 if param.nom in self.g_context : del self.g_context[param.nom]
568 def get_parametres_fonctions_avant_etape(self,etape):
570 Retourne deux elements :
571 - une liste contenant les noms des parametres (constantes ou EVAL)
573 - une liste contenant les formules definies avant etape
577 # on recupere le contexte avant etape
578 # on ne peut mettre dans les deux listes que des elements de ce contexte
579 d=self.get_contexte_avant(etape)
580 # construction de l_constantes
581 for param in self.params:
583 if not nom : continue
584 if nom in d: l_constantes.append(nom)
585 # construction de l_fonctions
586 for form in self.fonctions:
588 if not nom : continue
589 if nom in d: l_fonctions.append(form.get_formule())
591 # on ajoute les concepts produits par DEFI_VALEUR
592 # XXX On pourrait peut etre faire plutot le test sur le type
593 # de concept : entier, reel, complexe, etc.
594 for k,v in d.items():
595 if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
596 l_constantes.append(k)
598 # on retourne les deux listes
599 return l_constantes,l_fonctions
601 def get_nb_etapes_avant(self,niveau):
603 Retourne le nombre d etapes avant le debut de niveau
606 for niv in self.etapes_niveaux:
607 if niv == niveau:break
608 nb=nb+len(niv.etapes)
611 def init_modif(self):
613 Methode appelee au moment ou une modification va etre faite afin de
614 declencher d'eventuels traitements pre-modification
616 #print "init_modif",self
617 self.state = 'modified'
620 #print "fin_modif",self
621 CONNECTOR.Emit(self,"valid")
625 def deep_update_condition_bloc(self):
626 # pour le moment, on ne fait rien
627 self.get_jdc_root().recalcule_validite_apres_changement_global_jdc()
628 #raise EficasException(tr("Pas implemente"))
630 def update_condition_bloc(self):
631 # pour le moment, on ne fait rien
632 raise EficasException(tr("Pas implemente"))
634 def get_liste_mc_inconnus(self):
636 Retourne une liste contenant les mots-cles inconnus a la relecture du JDC
638 # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
640 for etape in self.etapes :
642 if not etape.isvalid() :
643 l = etape.get_liste_mc_inconnus()
644 if l : l_mc.extend(l)
647 def get_genealogie_precise(self):
650 def get_genealogie(self):
652 Retourne la liste des noms des ascendants de l'objet self
653 jusqu'a la premiere ETAPE parent.
657 def get_liste_cmd(self):
659 Retourne la liste des commandes du catalogue
661 return self.niveau.definition.get_liste_cmd()
663 def get_groups(self):
665 Retourne la liste des groupes
667 return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
669 def set_etape_context(self,etape):
671 Positionne l'etape qui sera utilisee dans NommerSdProd pour
672 decider si le concept passe pourra etre nomme
674 self._etape_context=etape
676 def reset_context(self):
678 Cette methode reinitialise le contexte glissant pour pouvoir
679 tenir compte des modifications de l'utilisateur : craation
680 de commandes, nommage de concepts, etc.
682 #print "reset_context",self,self.nom
683 self.current_context={}
684 self.index_etape_courante=0
686 for i,etape in enumerate(self.etapes):
688 self.index_etapes=ind
690 # for etape in self.etapes:
691 # etape.reset_context()
693 def del_sdprod(self,sd):
695 Supprime la SD sd de la liste des sd et des dictionnaires de contexte
697 #print "del_sdprod",self,sd
698 #print "del_sdprod",self.sds
699 #print "del_sdprod",self.g_context
700 #print "del_sdprod",self.sds_dict
701 #if sd in self.sds : self.sds.remove(sd)
702 if sd.nom in self.g_context : del self.g_context[sd.nom]
703 if sd.nom in self.sds_dict : del self.sds_dict[sd.nom]
705 def del_param(self,param):
707 Supprime le parametre param de la liste des paramatres
710 if param in self.params : self.params.remove(param)
711 if param.nom in self.g_context : del self.g_context[param.nom]
713 def del_fonction(self,fonction):
715 Supprime la fonction fonction de la liste des fonctions
718 if fonction in self.fonctions : self.fonctions.remove(fonction)
719 if fonction.nom in self.g_context: del self.g_context[fonction.nom]
721 def append_sdprod(self,sd):
723 Ajoute la SD sd a la liste des sd en verifiant au prealable qu'une SD de
724 meme nom n'existe pas deja
726 if sd == None or sd.nom == None:return
728 o=self.sds_dict.get(sd.nom,None)
729 if isinstance(o,ASSD):
730 raise AsException(tr("Nom de concept deja defini "+ sd.nom))
731 self.sds_dict[sd.nom]=sd
732 self.g_context[sd.nom] = sd
733 #if sd not in self.sds : self.sds.append(sd)
735 def append_param(self,param):
737 Ajoute le parametre param a la liste des params
738 et au contexte global
740 # il faudrait verifier qu'un parametre de meme nom n'existe pas deja !!!
741 if param not in self.params : self.params.append(param)
742 self.g_context[param.nom]=param
744 def append_fonction(self,fonction):
746 Ajoute la fonction fonction a la liste des fonctions
747 et au contexte global
749 # il faudrait verifier qu'une fonction de meme nom n'existe pas deja !!!
750 if fonction not in self.fonctions : self.fonctions.append(fonction)
751 self.g_context[fonction.nom]=fonction
753 def delete_concept(self,sd):
758 Mettre a jour les etapes du JDC suite a la disparition du
760 Seuls les mots cles simples MCSIMP font un traitement autre
761 que de transmettre aux fils
763 for etape in self.etapes :
764 etape.delete_concept(sd)
765 #PN PN PN pour les matrices ????
766 #self.get_variables_avant(etape)
768 def replace_concept_after_etape(self,etape,old_sd,sd):
770 Met a jour les etapes du JDC qui sont apres etape en fonction
771 du remplacement du concept sd
773 index = self.etapes.index(etape)+1
774 if index == len(self.etapes) :
775 return # etape est la derniere etape du jdc ...on ne fait rien !
776 for child in self.etapes[index:]:
777 child.replace_concept(old_sd,sd)
779 def update_concept_after_etape(self,etape,sd):
781 Met a jour les etapes du JDC qui sont apres etape en fonction
782 de la modification (principalement nommage) du concept sd
785 #On traite toutes les etapes
788 index = self.etapes.index(etape)+1
789 if index == len(self.etapes) :
790 return # etape est la derniere etape du jdc ...on ne fait rien !
791 for child in self.etapes[index:]:
792 child.update_concept(sd)
794 def dump_state(self):
795 print(("JDC.state: ",self.state))
796 for etape in self.etapes :
797 print((etape.nom+".state: ",etape.state))
799 def change_unit(self,unit,etape,old_unit):
800 #print "change_unit",unit,etape,old_unit
801 #print id(self.recorded_units),self.recorded_units
802 #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
803 self.record_unit(unit,etape)
805 def record_unit(self,unit,etape):
806 """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
807 #print "record_unit",unit,etape
810 self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
812 self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
813 #print id(self.recorded_units),self.recorded_units
814 #print self.recorded_units.get(None,(None,"",{}))[2]
815 #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
817 def changefichier(self,fichier):
820 def eval_in_context(self,valeur,etape):
821 """ Tente d'evaluer valeur dans le contexte courant de etape
822 Retourne le parametre valeur inchange si l'evaluation est impossible
824 #contexte initial du jdc
825 context=self.condition_context.copy()
826 #contexte courant des concepts. Il contient les parametres
827 context.update(self.get_contexte_avant(etape))
829 objet = eval(valeur,context)
832 #traceback.print_exc()
836 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
838 Noyau.N_JDC.JDC.supprime(self)
839 for etape in self.etapes:
843 self.const_context={}
846 self.current_context={}
847 self.condition_context={}
848 self.etapes_niveaux=[]
852 self._etape_context=None
855 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
856 def register(self,etape):
858 Cette methode ajoute etape dans la liste
859 des etapes self.etapes et retourne l identificateur d'etape
860 fourni par l appel a g_register
862 A quoi sert editmode ?
863 - Si editmode vaut 1, on est en mode edition de JDC. On cherche
864 a enregistrer une etape que l'on a creee avec eficas (en passant
865 par addentite) auquel cas on ne veut recuperer que son numero
866 d'enregistrement et c'est addentite qui l'enregistre dans
867 self.etapes a la bonne place...
868 - Si editmode vaut 0, on est en mode relecture d'un fichier de
869 commandes et on doit enregistrer l'etape a la fin de self.etapes
870 (dans ce cas l'ordre des etapes est bien l'ordre chronologique
873 if not self.editmode:
874 self.etapes.append(etape)
875 self.index_etapes[etape] = len(self.etapes) - 1
878 return self.g_register(etape)
880 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
881 def NommerSdprod(self,sd,sdnom,restrict='non'):
883 Nomme la SD apres avoir verifie que le nommage est possible :
885 Si le nom est deja utilise, leve une exception
886 Met le concept cree dans le concept global g_context
888 # XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment
889 # Le dictionnaire g_context ne represente pas le contexte
890 # effectif avant une etape.
891 # Il faut utiliser get_contexte_avant avec indication de l'etape
893 # Cette etape est indiquee par l'attribut _etape_context qui a ete
894 # positionne prealablement par un appel a set_etape_context
896 if CONTEXT.debug : print(("JDC.NommerSdprod ",sd,sdnom))
898 if self._etape_context:
899 o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
901 o=self.sds_dict.get(sdnom,None)
903 if isinstance(o,ASSD):
904 raise AsException(tr(" Nom de concept deja defini : "+ sdnom))
906 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
907 # Ajoute a la creation (appel de reg_sd).
908 self.sds_dict[sdnom]=sd
911 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
912 if restrict == 'non':
913 self.g_context[sdnom]=sd
915 def delete_concept_entre_etapes(self,index1,index2,sd):
916 if index2 <= index1 :return
917 for child in self.etapes[index1:index2]:
918 child.delete_concept(sd)
920 def delete_concept_after_etape(self,etape,sd):
922 Met a jour les etapes du JDC qui sont apres etape en fonction
923 de la disparition du concept sd
925 index = self.etapes.index(etape)+1
926 if index == len(self.etapes) :
927 return # etape est la derniere etape du jdc ...on ne fait rien !
928 for child in self.etapes[index:]:
929 child.delete_concept(sd)
931 #ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer
933 def get_file(self,unite=None,fic_origine=''):
935 Retourne le nom du fichier correspondant a un numero d'unite
936 logique (entier) ainsi que le source contenu dans le fichier
938 if self.appli is not None:
939 # Si le JDC est relie a une application maitre, on delegue la recherche
940 file,text= self.appli.get_file(unite,fic_origine)
944 if os.path.exists(u"fort."+str(unite)):
945 file= "fort."+str(unite)
947 raise AsException(tr("Impossible de trouver le fichier correspondant a l'unite "+str( unite)))
948 if not os.path.exists(file):
949 raise AsException(str(unite)+ tr(" n'est pas un fichier existant"))
953 #if file == None : return None,None
954 text=text.replace('\r\n','\n')
956 linecache.cache[file]=0,0,text.split('\n'),file
959 def isvalid(self,cr='non'):
960 if hasattr(self,'valid'): old_valid=self.valid
962 valid=Validation.V_JDC.JDC.isvalid(self,cr)
963 if valid != old_valid:
964 CONNECTOR.Emit(self,"valid")
967 def get_l_noms_etapes(self):
969 Retourne la liste des noms des etapes de self
972 for etape in self.etapes: