1 # -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2017 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
50 class JDC(I_OBJECT.OBJECT):
55 self.etapes_niveaux=[]
59 self._etape_context=None
60 self.recorded_units={}
61 self.old_recorded_units={}
64 def getIndex(self,objet):
66 Retourne la position d'objet dans la liste self
68 return self.etapes.index(objet)
70 def getSdAvantDuBonType(self,etape,types_permis):
72 Retourne la liste des concepts avant etape d'un type acceptable
74 d=self.getContexteAvant(etape)
79 #if type(v) != types.InstanceType and not isinstance(v,object): continue
80 if not isinstance(v,object): continue
81 # On considere que seul assd indique un type quelconque pas CO
82 elif self.assd in types_permis :
83 if v.etape.sdnom != "sansnom" : l.append(k)
84 elif self.estPermis(v,types_permis):
85 if v.etape.sdnom != "sansnom" : l.append(k)
89 def getVariables(self,etape):
92 for etapeTraitee in self.etapes :
93 if etapeTraitee==etapeStop:
95 if etapeTraitee.nom == 'VARIABLE' :
96 variable=etapeTraitee.getMocle('ModelVariable')
98 l.append(variable.nom)
101 def getDistributions(self,etape):
104 for etapeTraitee in self.etapes :
105 if etapeTraitee==etapeStop: break
106 if etapeTraitee.nom == 'DISTRIBUTION' and etapeTraitee.sd !=None : l.append(etapeTraitee.sd.nom)
110 #def set_Copules_recalcule_etat(self):
111 # for etapeTraitee in self.etapes :
112 # if etapeTraitee.nom == 'CORRELATION' :
113 #Matrix=etapeTraitee.getChild('Matrix')
115 # Correlation=etapeTraitee.getChild('CorrelationMatrix')
116 # if Correlation !=None : Correlation.state='arecalculer'
117 # Matrix.state='arecalculer'
119 #def recalculeEtatCorrelation(self):
120 # for etapeTraitee in self.etapes :
121 # if etapeTraitee.nom == 'CORRELATION' :
122 #Matrix=etapeTraitee.getChild('Matrix')
124 # Matrix.state='arecalculer'
125 # Correlation=Matrix.getChild('CorrelationMatrix')
126 # if Correlation !=None : Correlation.state='arecalculer'
127 # Correlation.isValid()
129 # etapeTraitee.state='arecalculer'
130 # if etapeTraitee.state=='arecalculer': etapeTraitee.isValid()
132 def recalculeEtatCorrelation(self):
133 for etapeTraitee in self.etapes :
134 if etapeTraitee.nom == 'CORRELATION' :
135 Correlation=etapeTraitee.getChild('CorrelationMatrix')
136 if Correlation !=None :
137 Correlation.state='arecalculer'
138 Correlation.isValid()
139 etapeTraitee.isValid()
141 def recalculeValiditeApresChangementGlobalJdc(self):
142 #print "je passe dans recalculeValiditeApresChangementGlobalJdc"
144 liste=self.getJdcRoot().cata.liste_condition
147 for etapeTraitee in self.etapes :
148 if etapeTraitee.nom not in liste: continue
149 self.forceRecalculBloc(etapeTraitee)
150 etapeTraitee.state='arecalculer'
151 etapeTraitee.isValid()
154 def forceRecalculBloc(self,objet):
155 # Attention : certains objets deviennent None quand on recalcule
156 # les conditions d existence des blocs
157 if objet != None: objet.state='arecalculer'
158 if hasattr(objet,'listeMcPresents'):
159 for childNom in objet.listeMcPresents():
160 child=objet.getChild(childNom)
161 if hasattr(objet,'_updateConditionBloc'):objet._updateConditionBloc()
162 self.forceRecalculBloc(child)
165 def getSdAvantDuBonTypePourTypeDeBase(self,etape,type):
167 Retourne la liste des concepts avant etape d'1 type de base acceptable
168 Attention different de la routine precedente : 1 seul type passe en parametre
169 Teste sur issubclass et par sur le type permis
171 d=self.getContexteAvant(etape)
174 typeverif=self.cata.__dict__[type]
177 for k,v in d.items():
178 if issubclass(v.__class__,typeverif):
183 def chercheListAvant(self,etape,valeur):
184 d=self.getContexteAvant(etape)
185 for k,v in d.items():
186 if issubclass(v.__class__,LASSD):
189 # Attention pour enlever les . a la fin des pretendus reels
190 if k == valeur[0:-1] :
194 def estPermis(self,v,types_permis):
195 for type_ok in types_permis:
196 if type_ok in ('R','I','C','TXM') and v in self.params :
198 elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
200 elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
202 elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
204 elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
206 elif type(type_ok) != type and not isinstance(type_ok,type):
208 elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
212 def addEntite(self,name,pos):
215 Si name est le nom d une commande ou un commentaire ajoute
217 Sinon remonte une erreur
221 if name == "COMMENTAIRE" :
222 from Extensions import commentaire
223 # ajout d'un commentaire
224 self.setCurrentStep()
226 for child in self.etapes :
227 if isinstance(child,commentaire.COMMENTAIRE):
229 objet = commentaire.COMMENTAIRE('',parent=self)
230 objet.nom = "_comm_"+repr(ind)
231 if pos == None : pos = 0
232 self.etapes.insert(pos,objet)
236 CONNECTOR.Emit(self,"add",objet)
239 elif name == "PARAMETRE":
240 # ajout d'un parametre
241 self.setCurrentStep()
242 nom_param = '_param_'+str(len(self.params)+1)
243 objet = parametre.PARAMETRE(nom=nom_param)
244 if pos == None : pos = 0
245 self.etapes.insert(pos,objet)
249 CONNECTOR.Emit(self,"add",objet)
252 elif name == "PARAMETRE_EVAL":
253 # ajout d'un parametre EVAL
254 self.setCurrentStep()
255 nom_param = '_param_'+str(len(self.params)+1)
256 objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
257 if pos == None : pos = 0
258 self.etapes.insert(pos,objet)
262 CONNECTOR.Emit(self,"add",objet)
265 elif not( isinstance(name, basestring)):
266 #elif type(name)==types.InstanceType:
267 #elif isinstance(name,object):
268 # on est dans le cas ou on veut ajouter une commande deja
269 # existante (par copie donc)
270 # on est donc necessairement en mode editeur ...
272 # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
273 from Extensions import commentaire
274 if not( isinstance (objet,commentaire.COMMENTAIRE)):
276 self.setCurrentStep()
277 if isinstance(objet,ETAPE):
278 if objet.nom_niveau_definition == 'JDC':
279 # l'objet depend directement du JDC
282 # l'etape depend d'un niveau et non directement du JDC :
283 # il faut l'enregistrer dans le niveau de parent
284 objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
285 objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
286 self.etapes.insert(pos,objet)
288 # il faut verifier que les concepts utilises par objet existent bien
289 # a ce niveau d'arborescence
290 objet.verifExistenceSd()
291 objet.updateMcGlobal()
294 CONNECTOR.Emit(self,"add",objet)
298 # On veut ajouter une nouvelle commande
300 self.setCurrentStep()
301 cmd=self.getCmd(name)
302 # L'appel a make_objet n'a pas pour effet d'enregistrer l'etape
303 # aupres du step courant car editmode vaut 1
304 # Par contre elle a le bon parent grace a setCurrentStep
306 if pos == None : pos = 0
307 self.etapes.insert(pos,e)
308 self.resetCurrentStep()
312 CONNECTOR.Emit(self,"add",e)
315 except AsException as e:
316 traceback.print_exc()
317 self.resetCurrentStep()
319 raise AsException(tr("Impossible d'ajouter la commande")+name + '\n')
322 traceback.print_exc()
323 self.resetCurrentStep()
325 raise AsException(tr("Impossible d ajouter la commande")+name)
328 #print "JDC.close",self
329 for etape in self.etapes:
330 if hasattr(etape,"close"):etape.close()
331 CONNECTOR.Emit(self,"close")
333 def setCurrentStep(self):
334 CONTEXT.unsetCurrentStep()
335 CONTEXT.setCurrentStep(self)
337 def resetCurrentStep(self):
338 CONTEXT.unsetCurrentStep()
340 def listeMcPresents(self):
343 def getSdAvantEtape(self,nom_sd,etape):
344 return self.getContexteAvant(etape).get(nom_sd,None)
346 def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
348 Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
349 definie apres etape en tenant compte des concepts detruits
350 Si avec vaut 'non' exclut etape de la recherche
352 #print "JDC.getSdApresEtapeAvecDetruire",nom_sd,sd
353 ietap=self.etapes.index(etape)
354 if avec == 'non':ietap=ietap+1
356 for e in self.etapes[ietap:]:
359 autre_sd=d.get(nom_sd,None)
361 # Le concept a ete detruit. On interrompt la recherche car il n'y a
362 # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
364 if autre_sd is not sd :
365 # L'etape produit un concept different de meme nom. La situation n'est
366 # pas saine (sauf peut etre si reuse ???)
367 if hasattr(e,'reuse') and e.reuse == autre_sd:
368 # Le concept etant reutilise, on interrompt la recherche.
369 # On considere qu'il n'y a pas de nouveau concept defini
370 # meme si dans les etapes suivantes le concept est detruit
371 # et un concept de meme nom cree.
372 # AVERIFIER : avec reuse le concept devrait etre le meme
373 # le passage par ici est tres improbable
376 # Le concept est produit par l'etape (Il y a conflit potentiel).
377 # Le concept est redefini par une etape posterieure.
379 # Pas de destruction du concept ni de redefinition. On retourne le
383 def getSdApresEtape(self,nom_sd,etape,avec='non'):
385 Cette methode retourne la SD de nom nom_sd qui est eventuellement
387 Si avec vaut 'non' exclut etape de la recherche
389 ietap=self.etapes.index(etape)
390 if avec == 'non':ietap=ietap+1
391 for e in self.etapes[ietap:]:
392 sd=e.getSdprods(nom_sd)
394 if hasattr(e,'reuse'):
399 def getSdAutourEtape(self,nom_sd,etape,avec='non'):
401 Fonction: retourne la SD de nom nom_sd qui est eventuellement
402 definie avant ou apres etape
403 Permet de verifier si un concept de meme nom existe dans le perimetre
405 Si avec vaut 'non' exclut etape de la recherche
407 sd=self.getSdAvantEtape(nom_sd,etape)
409 return self.getSdApresEtape(nom_sd,etape,avec)
411 def getContexte_apres(self,etape):
413 Retourne le dictionnaire des concepts connus apres etape
414 On tient compte des commandes qui modifient le contexte
415 comme DETRUIRE ou les macros
416 Si etape == None, on retourne le contexte en fin de JDC
418 if not etape: return self.getContexteAvant(etape)
420 d=self.getContexteAvant(etape)
421 if etape.isActif():etape.updateContext(d)
422 self.index_etape_courante=self.index_etape_courante+1
425 def activeEtapes(self):
427 Cette methode a pour fonction de desactiver les etapes qui doivent
428 l'etre cad, dans le cas d'ASTER, les etapes qui ne sont pas
429 comprises entre le premier DEBUT/POURSUITE et le premier FIN
430 et rendre actives les autres
432 #if self.definition.code == 'ASTER' :
433 # Seulement pour ASTER :
434 # Avant DEBUT actif vaut 0
435 # Apres DEBUT et avant le 1er FIN actif vaut 1
436 # Apres le 1er FIN actif vaut -1
439 for etape in self.etapes:
440 #if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
443 #self.enregistreEtapePyxb(etape)
446 #if etape.nom == 'FIN':actif=-1
448 def deplaceEntite(self,indexNoeudACopier,indexNoeudOuColler,pos):
452 if indexNoeudACopier==indexNoeudOuColler:return
453 etapeACopier=self.etapes[indexNoeudACopier]
455 sd=self.etapes[indexNoeudACopier].sd
458 if pos=='before' and indexNoeudOuColler==0 :
459 self.etapes2=[etapeACopier,]+self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
460 elif indexNoeudACopier < indexNoeudOuColler :
461 self.etapes2=self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:]
463 self.etapes2=self.etapes[0:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
464 self.etapes=self.etapes2
465 if indexNoeudACopier < indexNoeudOuColler :
466 self.deleteConceptEntreEtapes(indexNoeudACopier,indexNoeudOuColler,sd)
468 for e in self.etapes :
470 self.controlContextApres(None)
474 def suppEntite(self,etape) :
476 Cette methode a pour fonction de supprimer une etape dans
478 Retourne 1 si la suppression a pu etre effectuee,
479 Retourne 0 dans le cas contraire
481 #PN correction de bugs
482 if etape not in self.etapes: return 0
485 index_etape=self.etapes.index(etape)
487 #etape.deletePyxbObject()
488 self.etapes.remove(etape)
490 if etape.niveau is not self:
491 # Dans ce cas l'etape est enregistree dans un niveau
492 # Il faut la desenregistrer
493 etape.niveau.unregister(etape)
495 etape.supprimeSdProds()
500 # Apres suppression de l'etape il faut controler que les etapes
501 # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
503 index_etape=index_etape-1
504 etape=self.etapes[index_etape]
507 self.controlContextApres(etape)
510 CONNECTOR.Emit(self,"supp",etape)
514 def controlContextApres(self,etape):
516 Cette methode verifie que les etapes apres l'etape etape
517 ont bien des concepts produits acceptables (pas de conflit de
519 Si des concepts produits ne sont pas acceptables ils sont supprimes.
520 Effectue les verifications sur les etapes du jdc mais aussi sur les
521 jdc parents s'ils existent.
523 #print "controlContextApres",self,etape
524 #Regularise les etapes du jdc apres l'etape etape
525 self.controlJdcContextApres(etape)
527 def controlJdcContextApres(self,etape):
529 Methode semblable a controlContextApres mais ne travaille
530 que sur les etapes et sous etapes du jdc
532 #print "controlJdcContextApres",self,etape
534 # on demarre de la premiere etape
537 index_etape=self.etapes.index(etape)+1
540 etape=self.etapes[index_etape]
542 #derniere etape du jdc : rien a faire
545 context=self.getContexteAvant(etape)
547 for e in self.etapes[index_etape:]:
548 e.controlSdprods(context)
549 e.updateContext(context)
552 if self.editor.format == 'xml' :
553 # il ne faut pas le faire quand le jeu de donnees est vide
554 self.setCurrentContext()
555 self.analyseFromXML()
556 #print ('stop demande'); exit()
557 #self.execCompileFromXML()
561 if not self.cr.estvide():return
564 def registerParametre(self,param):
566 Cette methode sert a ajouter un parametre dans la liste des parametres
568 self.params.append(param)
570 def registerFonction(self,fonction):
572 Cette methode sert a ajouter une fonction dans la liste des fonctions
574 self.fonctions.append(fonction)
576 def deleteParam(self,param):
578 Supprime le parametre param de la liste des parametres
581 if param in self.params : self.params.remove(param)
582 if param.nom in self.g_context : del self.g_context[param.nom]
584 def getParametresFonctionsAvantEtape(self,etape):
586 Retourne deux elements :
587 - une liste contenant les noms des parametres (constantes ou EVAL)
589 - une liste contenant les formules definies avant etape
593 # on recupere le contexte avant etape
594 # on ne peut mettre dans les deux listes que des elements de ce contexte
595 d=self.getContexteAvant(etape)
596 # construction de l_constantes
597 for param in self.params:
599 if not nom : continue
600 if nom in d: l_constantes.append(nom)
601 # construction de l_fonctions
602 for form in self.fonctions:
604 if not nom : continue
605 if nom in d: l_fonctions.append(form.getFormule())
607 # on ajoute les concepts produits par DEFI_VALEUR
608 # XXX On pourrait peut etre faire plutot le test sur le type
609 # de concept : entier, reel, complexe, etc.
610 for k,v in d.items():
611 if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
612 l_constantes.append(k)
614 # on retourne les deux listes
615 return l_constantes,l_fonctions
617 def getNbEtapesAvant(self,niveau):
619 Retourne le nombre d etapes avant le debut de niveau
622 for niv in self.etapes_niveaux:
623 if niv == niveau:break
624 nb=nb+len(niv.etapes)
629 Methode appelee au moment ou une modification va etre faite afin de
630 declencher d'eventuels traitements pre-modification
632 #print "initModif",self
633 self.state = 'modified'
636 #print "finModif",self
637 CONNECTOR.Emit(self,"valid")
641 def deepUpdateConditionBloc(self):
642 # pour le moment, on ne fait rien
643 self.getJdcRoot().recalculeValiditeApresChangementGlobalJdc()
644 #raise EficasException(tr("Pas implemente"))
646 def updateConditionBloc(self):
647 # pour le moment, on ne fait rien
648 raise EficasException(tr("Pas implemente"))
650 def getListeMcInconnus(self):
652 Retourne une liste contenant les mots-cles inconnus a la relecture du JDC
654 # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
656 for etape in self.etapes :
658 if not etape.isValid() :
659 l = etape.getListeMcInconnus()
660 if l : l_mc.extend(l)
663 def getGenealogiePrecise(self):
666 def getGenealogie(self):
668 Retourne la liste des noms des ascendants de l'objet self
669 jusqu'a la premiere ETAPE parent.
673 def getListeCmd(self):
675 Retourne la liste des commandes du catalogue
677 return self.niveau.definition.getListeCmd()
681 Retourne la liste des groupes
683 return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
685 def setEtapeContext(self,etape):
687 Positionne l'etape qui sera utilisee dans NommerSdProd pour
688 decider si le concept passe pourra etre nomme
690 self._etape_context=etape
692 def resetContext(self):
694 Cette methode reinitialise le contexte glissant pour pouvoir
695 tenir compte des modifications de l'utilisateur : craation
696 de commandes, nommage de concepts, etc.
698 #print "resetContext",self,self.nom
699 self.current_context={}
700 self.index_etape_courante=0
702 for i,etape in enumerate(self.etapes):
704 self.index_etapes=ind
706 # for etape in self.etapes:
707 # etape.resetContext()
709 def delSdprod(self,sd):
711 Supprime la SD sd de la liste des sd et des dictionnaires de contexte
713 #print "delSdprod",self,sd
714 #print "delSdprod",self.sds
715 #print "delSdprod",self.g_context
716 #print "delSdprod",self.sds_dict
717 #if sd in self.sds : self.sds.remove(sd)
718 if sd.nom in self.g_context : del self.g_context[sd.nom]
719 if sd.nom in self.sds_dict : del self.sds_dict[sd.nom]
721 def delParam(self,param):
723 Supprime le parametre param de la liste des paramatres
726 if param in self.params : self.params.remove(param)
727 if param.nom in self.g_context : del self.g_context[param.nom]
729 def delFonction(self,fonction):
731 Supprime la fonction fonction de la liste des fonctions
734 if fonction in self.fonctions : self.fonctions.remove(fonction)
735 if fonction.nom in self.g_context: del self.g_context[fonction.nom]
737 def appendSdProd(self,sd):
739 Ajoute la SD sd a la liste des sd en verifiant au prealable qu'une SD de
740 meme nom n'existe pas deja
742 if sd == None or sd.nom == None:return
744 o=self.sds_dict.get(sd.nom,None)
745 if isinstance(o,ASSD):
746 raise AsException(tr("Nom de concept deja defini "+ sd.nom))
747 self.sds_dict[sd.nom]=sd
748 self.g_context[sd.nom] = sd
749 #if sd not in self.sds : self.sds.append(sd)
751 def appendParam(self,param):
753 Ajoute le parametre param a la liste des params
754 et au contexte global
756 # il faudrait verifier qu'un parametre de meme nom n'existe pas deja !!!
757 if param not in self.params : self.params.append(param)
758 self.g_context[param.nom]=param
760 def appendFonction(self,fonction):
762 Ajoute la fonction fonction a la liste des fonctions
763 et au contexte global
765 # il faudrait verifier qu'une fonction de meme nom n'existe pas deja !!!
766 if fonction not in self.fonctions : self.fonctions.append(fonction)
767 self.g_context[fonction.nom]=fonction
769 def deleteConcept(self,sd):
774 Mettre a jour les etapes du JDC suite a la disparition du
776 Seuls les mots cles simples MCSIMP font un traitement autre
777 que de transmettre aux fils
779 for etape in self.etapes :
780 etape.deleteConcept(sd)
781 #PN PN PN pour les matrices ????
782 #self.getVariables_avant(etape)
784 def replaceConceptAfterEtape(self,etape,old_sd,sd):
786 Met a jour les etapes du JDC qui sont apres etape en fonction
787 du remplacement du concept sd
789 index = self.etapes.index(etape)+1
790 if index == len(self.etapes) :
791 return # etape est la derniere etape du jdc ...on ne fait rien !
792 for child in self.etapes[index:]:
793 child.replaceConcept(old_sd,sd)
795 def updateConceptAfterEtape(self,etape,sd):
797 Met a jour les etapes du JDC qui sont apres etape en fonction
798 de la modification (principalement nommage) du concept sd
801 #On traite toutes les etapes
804 index = self.etapes.index(etape)+1
805 if index == len(self.etapes) :
806 return # etape est la derniere etape du jdc ...on ne fait rien !
807 for child in self.etapes[index:]:
808 child.updateConcept(sd)
811 print(("JDC.state: ",self.state))
812 for etape in self.etapes :
813 print((etape.nom+".state: ",etape.state))
815 def changeUnit(self,unit,etape,old_unit):
816 #print "changeUnit",unit,etape,old_unit
817 #print id(self.recorded_units),self.recorded_units
818 #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
819 self.recordUnit(unit,etape)
821 def recordUnit(self,unit,etape):
822 """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
823 #print "recordUnit",unit,etape
826 self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
828 self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
829 #print id(self.recorded_units),self.recorded_units
830 #print self.recorded_units.get(None,(None,"",{}))[2]
831 #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
833 def changeFichier(self,fichier):
836 def evalInContext(self,valeur,etape):
837 """ Tente d'evaluer valeur dans le contexte courant de etape
838 Retourne le parametre valeur inchange si l'evaluation est impossible
840 #contexte initial du jdc
841 context=self.condition_context.copy()
842 #contexte courant des concepts. Il contient les parametres
843 context.update(self.getContexteAvant(etape))
845 objet = eval(valeur,context)
848 #traceback.print_exc()
852 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
854 Noyau.N_JDC.JDC.supprime(self)
855 for etape in self.etapes:
859 self.const_context={}
862 self.current_context={}
863 self.condition_context={}
864 self.etapes_niveaux=[]
868 self._etape_context=None
871 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
872 def register(self,etape):
874 Cette methode ajoute etape dans la liste
875 des etapes self.etapes et retourne l identificateur d'etape
876 fourni par l appel a gRegister
878 A quoi sert editmode ?
879 - Si editmode vaut 1, on est en mode edition de JDC. On cherche
880 a enregistrer une etape que l'on a creee avec eficas (en passant
881 par addEntite) auquel cas on ne veut recuperer que son numero
882 d'enregistrement et c'est addEntite qui l'enregistre dans
883 self.etapes a la bonne place...
884 - Si editmode vaut 0, on est en mode relecture d'un fichier de
885 commandes et on doit enregistrer l'etape a la fin de self.etapes
886 (dans ce cas l'ordre des etapes est bien l'ordre chronologique
889 if not self.editmode:
890 self.etapes.append(etape)
891 self.index_etapes[etape] = len(self.etapes) - 1
894 return self.gRegister(etape)
896 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
897 def NommerSdprod(self,sd,sdnom,restrict='non'):
899 Nomme la SD apres avoir verifie que le nommage est possible :
901 Si le nom est deja utilise, leve une exception
902 Met le concept cree dans le concept global g_context
904 # XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment
905 # Le dictionnaire g_context ne represente pas le contexte
906 # effectif avant une etape.
907 # Il faut utiliser getContexteAvant avec indication de l'etape
909 # Cette etape est indiquee par l'attribut _etape_context qui a ete
910 # positionne prealablement par un appel a setEtapeContext
912 if CONTEXT.debug : print(("JDC.NommerSdprod ",sd,sdnom))
914 if self._etape_context:
915 o=self.getContexteAvant(self._etape_context).get(sdnom,None)
917 o=self.sds_dict.get(sdnom,None)
919 if isinstance(o,ASSD):
920 raise AsException(tr(" Nom de concept deja defini : "+ sdnom))
922 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
923 # Ajoute a la creation (appel de regSD).
924 self.sds_dict[sdnom]=sd
927 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
928 if restrict == 'non':
929 self.g_context[sdnom]=sd
931 def deleteConceptEntreEtapes(self,index1,index2,sd):
932 if index2 <= index1 :return
933 for child in self.etapes[index1:index2]:
934 child.deleteConcept(sd)
936 def deleteConceptAfterEtape(self,etape,sd):
938 Met a jour les etapes du JDC qui sont apres etape en fonction
939 de la disparition du concept sd
941 index = self.etapes.index(etape)+1
942 if index == len(self.etapes) :
943 return # etape est la derniere etape du jdc ...on ne fait rien !
944 for child in self.etapes[index:]:
945 child.deleteConcept(sd)
947 #ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer
949 def getFile(self,unite=None,fic_origine=''):
951 Retourne le nom du fichier correspondant a un numero d'unite
952 logique (entier) ainsi que le source contenu dans le fichier
954 if self.appli is not None:
955 # Si le JDC est relie a une application maitre, on delegue la recherche
956 file,text= self.appli.getFile(unite,fic_origine)
960 if os.path.exists(u"fort."+str(unite)):
961 file= "fort."+str(unite)
963 raise AsException(tr("Impossible de trouver le fichier correspondant a l'unite "+str( unite)))
964 if not os.path.exists(file):
965 raise AsException(str(unite)+ tr(" n'est pas un fichier existant"))
969 #if file == None : return None,None
970 text=text.replace('\r\n','\n')
972 linecache.cache[file]=0,0,text.split('\n'),file
975 def isValid(self,cr='non'):
976 if hasattr(self,'valid'): old_valid=self.valid
978 valid=Validation.V_JDC.JDC.isValid(self,cr)
979 if valid != old_valid:
980 CONNECTOR.Emit(self,"valid")
983 def getLNomsEtapes(self):
985 Retourne la liste des noms des etapes de self
988 for etape in self.etapes: