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={}
56 def get_index(self,objet):
58 Retourne la position d'objet dans la liste self
60 return self.etapes.index(objet)
62 def get_sd_avant_du_bon_type(self,etape,types_permis):
64 Retourne la liste des concepts avant etape d'un type acceptable
66 print "je suis la",self,etape,types_permis
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:
99 if etapeTraitee.nom == 'DISTRIBUTION' :
100 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 :
111 Correlation.state='arecalculer'
112 Matrix.state='arecalculer'
114 def recalcule_etat_correlation(self):
115 for etapeTraitee in self.etapes :
116 if etapeTraitee.nom == 'CORRELATION' :
117 Matrix=etapeTraitee.get_child('Matrix')
119 Matrix.state='arecalculer'
120 Correlation=Matrix.get_child('CorrelationMatrix')
121 if Correlation !=None :
122 Correlation.state='arecalculer'
123 Correlation.isvalid()
125 etapeTraitee.state='arecalculer'
126 if etapeTraitee.state=='arecalculer':
127 etapeTraitee.isvalid()
130 def recalcule_validite_apres_changement_global_jdc(self):
131 #print "je passe dans recalcule_validite_apres_changement_global_jdc"
133 liste=self.get_jdc_root().cata[0].liste_condition
136 for etapeTraitee in self.etapes :
137 if etapeTraitee.nom not in liste: continue
138 self.forceRecalculBloc(etapeTraitee)
139 etapeTraitee.state='arecalculer'
140 etapeTraitee.isvalid()
143 def forceRecalculBloc(self,objet):
144 # Attention : certains objets deviennent None quand on recalcule
145 # les conditions d existence des blocs
146 if objet != None: objet.state='arecalculer'
147 if hasattr(objet,'liste_mc_presents'):
148 for childNom in objet.liste_mc_presents():
149 child=objet.get_child(childNom)
150 if hasattr(objet,'_update_condition_bloc'):objet._update_condition_bloc()
151 self.forceRecalculBloc(child)
154 def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
156 Retourne la liste des concepts avant etape d'1 type de base acceptable
157 Attention different de la routine precedente : 1 seul type passe en parametre
158 Teste sur issubclass et par sur le type permis
160 d=self.get_contexte_avant(etape)
163 typeverif=self.cata[0].__dict__[type]
166 for k,v in d.items():
167 if issubclass(v.__class__,typeverif):
172 def cherche_list_avant(self,etape,valeur):
173 d=self.get_contexte_avant(etape)
174 for k,v in d.items():
175 if issubclass(v.__class__,LASSD):
178 # Attention pour enlever les . a la fin des pretendus reels
179 if k == valeur[0:-1] :
183 def est_permis(self,v,types_permis):
184 for type_ok in types_permis:
185 if type_ok in ('R','I','C','TXM') and v in self.params :
187 elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
189 elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
191 elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
193 elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
195 elif type(type_ok) != types.ClassType and not isinstance(type_ok,type):
197 elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
201 def addentite(self,name,pos):
204 Si name est le nom d une commande ou un commentaire ajoute
206 Sinon remonte une erreur
210 if name == "COMMENTAIRE" :
211 # ajout d'un commentaire
212 self.set_current_step()
214 for child in self.etapes :
215 from Extensions import commentaire
216 if isinstance(child,commentaire.COMMENTAIRE):
218 objet = commentaire.COMMENTAIRE('',parent=self)
219 objet.nom = "_comm_"+`ind`
220 if pos == None : pos = 0
221 self.etapes.insert(pos,objet)
225 CONNECTOR.Emit(self,"add",objet)
228 elif name == "PARAMETRE":
229 # ajout d'un parametre
230 self.set_current_step()
231 nom_param = '_param_'+str(len(self.params)+1)
232 objet = parametre.PARAMETRE(nom=nom_param)
233 if pos == None : pos = 0
234 self.etapes.insert(pos,objet)
238 CONNECTOR.Emit(self,"add",objet)
241 elif name == "PARAMETRE_EVAL":
242 # ajout d'un parametre EVAL
243 self.set_current_step()
244 nom_param = '_param_'+str(len(self.params)+1)
245 objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
246 if pos == None : pos = 0
247 self.etapes.insert(pos,objet)
251 CONNECTOR.Emit(self,"add",objet)
254 elif type(name)==types.InstanceType:
255 # on est dans le cas ou on veut ajouter une commande deja
256 # existante (par copie donc)
257 # on est donc necessairement en mode editeur ...
259 # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
260 from Extensions import commentaire
261 if not( isinstance (objet,commentaire.COMMENTAIRE)):
263 self.set_current_step()
264 if isinstance(objet,ETAPE):
265 if objet.nom_niveau_definition == 'JDC':
266 # l'objet depend directement du JDC
269 # l'etape depend d'un niveau et non directement du JDC :
270 # il faut l'enregistrer dans le niveau de parent
271 objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
272 objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
273 self.etapes.insert(pos,objet)
275 # il faut verifier que les concepts utilises par objet existent bien
276 # a ce niveau d'arborescence
277 objet.verif_existence_sd()
278 objet.update_mc_global()
281 CONNECTOR.Emit(self,"add",objet)
285 # On veut ajouter une nouvelle commande
287 self.set_current_step()
288 cmd=self.get_cmd(name)
289 # L'appel a make_objet n'a pas pour effet d'enregistrer l'etape
290 # aupres du step courant car editmode vaut 1
291 # Par contre elle a le bon parent grace a set_current_step
293 if pos == None : pos = 0
294 self.etapes.insert(pos,e)
295 self.reset_current_step()
299 CONNECTOR.Emit(self,"add",e)
302 except AsException,e:
303 traceback.print_exc()
304 self.reset_current_step()
306 raise AsException(tr("Impossible d'ajouter la commande")+name + '\n')
309 traceback.print_exc()
310 self.reset_current_step()
312 raise AsException(tr("Impossible d ajouter la commande")+name)
315 #print "JDC.close",self
316 for etape in self.etapes:
317 if hasattr(etape,"close"):etape.close()
318 CONNECTOR.Emit(self,"close")
320 def set_current_step(self):
321 CONTEXT.unset_current_step()
322 CONTEXT.set_current_step(self)
324 def reset_current_step(self):
325 CONTEXT.unset_current_step()
327 def liste_mc_presents(self):
330 def get_sd_avant_etape(self,nom_sd,etape):
331 return self.get_contexte_avant(etape).get(nom_sd,None)
333 def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
335 Cette methode retourne la SD sd de nom nom_sd qui est eventuellement
336 definie apres etape en tenant compte des concepts detruits
337 Si avec vaut 'non' exclut etape de la recherche
339 #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
340 ietap=self.etapes.index(etape)
341 if avec == 'non':ietap=ietap+1
343 for e in self.etapes[ietap:]:
346 autre_sd=d.get(nom_sd,None)
348 # Le concept a ete detruit. On interrompt la recherche car il n'y a
349 # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
351 if autre_sd is not sd :
352 # L'etape produit un concept different de meme nom. La situation n'est
353 # pas saine (sauf peut etre si reuse ???)
354 if hasattr(e,'reuse') and e.reuse == autre_sd:
355 # Le concept etant reutilise, on interrompt la recherche.
356 # On considere qu'il n'y a pas de nouveau concept defini
357 # meme si dans les etapes suivantes le concept est detruit
358 # et un concept de meme nom cree.
359 # AVERIFIER : avec reuse le concept devrait etre le meme
360 # le passage par ici est tres improbable
363 # Le concept est produit par l'etape (Il y a conflit potentiel).
364 # Le concept est redefini par une etape posterieure.
366 # Pas de destruction du concept ni de redefinition. On retourne le
370 def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
372 Cette methode retourne la SD de nom nom_sd qui est eventuellement
374 Si avec vaut 'non' exclut etape de la recherche
376 ietap=self.etapes.index(etape)
377 if avec == 'non':ietap=ietap+1
378 for e in self.etapes[ietap:]:
379 sd=e.get_sdprods(nom_sd)
381 if hasattr(e,'reuse'):
386 def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
388 Fonction: retourne la SD de nom nom_sd qui est eventuellement
389 definie avant ou apres etape
390 Permet de verifier si un concept de meme nom existe dans le perimetre
392 Si avec vaut 'non' exclut etape de la recherche
394 sd=self.get_sd_avant_etape(nom_sd,etape)
396 return self.get_sd_apres_etape(nom_sd,etape,avec)
398 def get_contexte_apres(self,etape):
400 Retourne le dictionnaire des concepts connus apres etape
401 On tient compte des commandes qui modifient le contexte
402 comme DETRUIRE ou les macros
403 Si etape == None, on retourne le contexte en fin de JDC
405 if not etape: return self.get_contexte_avant(etape)
407 d=self.get_contexte_avant(etape)
408 if etape.isactif():etape.update_context(d)
409 self.index_etape_courante=self.index_etape_courante+1
412 def active_etapes(self):
414 Cette methode a pour fonction de desactiver les etapes qui doivent
415 l'etre cad, dans le cas d'ASTER, les etapes qui ne sont pas
416 comprises entre le premier DEBUT/POURSUITE et le premier FIN
417 et rendre actives les autres
419 if self.definition.code == 'ASTER' :
420 # Seulement pour ASTER :
421 # Avant DEBUT actif vaut 0
422 # Apres DEBUT et avant le 1er FIN actif vaut 1
423 # Apres le 1er FIN actif vaut -1
427 for etape in self.etapes:
428 if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
433 if etape.nom == 'FIN':actif=-1
435 def deplaceEntite(self,indexNoeudACopier,indexNoeudOuColler,pos):
439 if indexNoeudACopier==indexNoeudOuColler:return
440 etapeACopier=self.etapes[indexNoeudACopier]
442 sd=self.etapes[indexNoeudACopier].sd
445 if pos=='before' and indexNoeudOuColler==0 :
446 self.etapes2=[etapeACopier,]+self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
447 elif indexNoeudACopier < indexNoeudOuColler :
448 self.etapes2=self.etapes[0:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:]
450 self.etapes2=self.etapes[0:indexNoeudOuColler+1]+[etapeACopier,]+self.etapes[indexNoeudOuColler+1:indexNoeudACopier]+self.etapes[indexNoeudACopier+1:]
451 self.etapes=self.etapes2
452 if indexNoeudACopier < indexNoeudOuColler :
453 self.delete_concept_entre_etapes(indexNoeudACopier,indexNoeudOuColler,sd)
455 for e in self.etapes :
457 self.control_context_apres(None)
461 def suppentite(self,etape) :
463 Cette methode a pour fonction de supprimer une etape dans
465 Retourne 1 si la suppression a pu etre effectuee,
466 Retourne 0 dans le cas contraire
468 #PN correction de bugs
469 if etape not in self.etapes:
473 index_etape=self.etapes.index(etape)
474 self.etapes.remove(etape)
476 if etape.niveau is not self:
477 # Dans ce cas l'etape est enregistree dans un niveau
478 # Il faut la desenregistrer
479 etape.niveau.unregister(etape)
481 etape.supprime_sdprods()
486 # Apres suppression de l'etape il faut controler que les etapes
487 # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
489 index_etape=index_etape-1
490 etape=self.etapes[index_etape]
493 self.control_context_apres(etape)
496 CONNECTOR.Emit(self,"supp",etape)
500 def control_context_apres(self,etape):
502 Cette methode verifie que les etapes apres l'etape etape
503 ont bien des concepts produits acceptables (pas de conflit de
505 Si des concepts produits ne sont pas acceptables ils sont supprimes.
506 Effectue les verifications sur les etapes du jdc mais aussi sur les
507 jdc parents s'ils existent.
509 #print "control_context_apres",self,etape
510 #Regularise les etapes du jdc apres l'etape etape
511 self.control_jdc_context_apres(etape)
513 def control_jdc_context_apres(self,etape):
515 Methode semblable a control_context_apres mais ne travaille
516 que sur les etapes et sous etapes du jdc
518 #print "control_jdc_context_apres",self,etape
520 # on demarre de la premiere etape
523 index_etape=self.etapes.index(etape)+1
526 etape=self.etapes[index_etape]
528 #derniere etape du jdc : rien a faire
531 context=self.get_contexte_avant(etape)
533 for e in self.etapes[index_etape:]:
534 e.control_sdprods(context)
535 e.update_context(context)
539 if not self.cr.estvide():return
543 def register_parametre(self,param):
545 Cette methode sert a ajouter un parametre dans la liste des parametres
547 self.params.append(param)
549 def register_fonction(self,fonction):
551 Cette methode sert a ajouter une fonction dans la liste des fonctions
553 self.fonctions.append(fonction)
555 def delete_param(self,param):
557 Supprime le parametre param de la liste des parametres
560 if param in self.params : self.params.remove(param)
561 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
563 def get_parametres_fonctions_avant_etape(self,etape):
565 Retourne deux elements :
566 - une liste contenant les noms des parametres (constantes ou EVAL)
568 - une liste contenant les formules definies avant etape
572 # on recupere le contexte avant etape
573 # on ne peut mettre dans les deux listes que des elements de ce contexte
574 d=self.get_contexte_avant(etape)
575 # construction de l_constantes
576 for param in self.params:
578 if not nom : continue
579 if d.has_key(nom): l_constantes.append(nom)
580 # construction de l_fonctions
581 for form in self.fonctions:
583 if not nom : continue
584 if d.has_key(nom): l_fonctions.append(form.get_formule())
586 # on ajoute les concepts produits par DEFI_VALEUR
587 # XXX On pourrait peut etre faire plutot le test sur le type
588 # de concept : entier, reel, complexe, etc.
589 for k,v in d.items():
590 if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
591 l_constantes.append(k)
593 # on retourne les deux listes
594 return l_constantes,l_fonctions
596 def get_nb_etapes_avant(self,niveau):
598 Retourne le nombre d etapes avant le debut de niveau
601 for niv in self.etapes_niveaux:
602 if niv == niveau:break
603 nb=nb+len(niv.etapes)
606 def init_modif(self):
608 Methode appelee au moment ou une modification va etre faite afin de
609 declencher d'eventuels traitements pre-modification
611 #print "init_modif",self
612 self.state = 'modified'
615 #print "fin_modif",self
616 CONNECTOR.Emit(self,"valid")
620 def deep_update_condition_bloc(self):
621 # pour le moment, on ne fait rien
622 self.get_jdc_root().recalcule_validite_apres_changement_global_jdc()
623 #raise EficasException(tr("Pas implemente"))
625 def update_condition_bloc(self):
626 # pour le moment, on ne fait rien
627 raise EficasException(tr("Pas implemente"))
629 def get_liste_mc_inconnus(self):
631 Retourne une liste contenant les mots-cles inconnus a la relecture du JDC
633 # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
635 for etape in self.etapes :
637 if not etape.isvalid() :
638 l = etape.get_liste_mc_inconnus()
639 if l : l_mc.extend(l)
642 def get_genealogie(self):
644 Retourne la liste des noms des ascendants de l'objet self
645 jusqu'a la premiere ETAPE parent.
649 def get_liste_cmd(self):
651 Retourne la liste des commandes du catalogue
653 return self.niveau.definition.get_liste_cmd()
655 def get_groups(self):
657 Retourne la liste des groupes
659 return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
661 def set_etape_context(self,etape):
663 Positionne l'etape qui sera utilisee dans NommerSdProd pour
664 decider si le concept passe pourra etre nomme
666 self._etape_context=etape
668 def reset_context(self):
670 Cette methode reinitialise le contexte glissant pour pouvoir
671 tenir compte des modifications de l'utilisateur : craation
672 de commandes, nommage de concepts, etc.
674 #print "reset_context",self,self.nom
675 self.current_context={}
676 self.index_etape_courante=0
678 for i,etape in enumerate(self.etapes):
680 self.index_etapes=ind
682 # for etape in self.etapes:
683 # etape.reset_context()
685 def del_sdprod(self,sd):
687 Supprime la SD sd de la liste des sd et des dictionnaires de contexte
689 #print "del_sdprod",self,sd
690 #print "del_sdprod",self.sds
691 #print "del_sdprod",self.g_context
692 #print "del_sdprod",self.sds_dict
693 #if sd in self.sds : self.sds.remove(sd)
694 if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
695 if self.sds_dict.has_key(sd.nom) : del self.sds_dict[sd.nom]
697 def del_param(self,param):
699 Supprime le parametre param de la liste des paramatres
702 if param in self.params : self.params.remove(param)
703 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
705 def del_fonction(self,fonction):
707 Supprime la fonction fonction de la liste des fonctions
710 if fonction in self.fonctions : self.fonctions.remove(fonction)
711 if self.g_context.has_key(fonction.nom) : del self.g_context[fonction.nom]
713 def append_sdprod(self,sd):
715 Ajoute la SD sd a la liste des sd en verifiant au prealable qu'une SD de
716 meme nom n'existe pas deja
718 if sd == None or sd.nom == None:return
720 o=self.sds_dict.get(sd.nom,None)
721 if isinstance(o,ASSD):
722 raise AsException(tr("Nom de concept deja defini "+ sd.nom))
723 self.sds_dict[sd.nom]=sd
724 self.g_context[sd.nom] = sd
725 #if sd not in self.sds : self.sds.append(sd)
727 def append_param(self,param):
729 Ajoute le parametre param a la liste des params
730 et au contexte global
732 # il faudrait verifier qu'un parametre de meme nom n'existe pas deja !!!
733 if param not in self.params : self.params.append(param)
734 self.g_context[param.nom]=param
736 def append_fonction(self,fonction):
738 Ajoute la fonction fonction a la liste des fonctions
739 et au contexte global
741 # il faudrait verifier qu'une fonction de meme nom n'existe pas deja !!!
742 if fonction not in self.fonctions : self.fonctions.append(fonction)
743 self.g_context[fonction.nom]=fonction
745 def delete_concept(self,sd):
750 Mettre a jour les etapes du JDC suite a la disparition du
752 Seuls les mots cles simples MCSIMP font un traitement autre
753 que de transmettre aux fils
755 for etape in self.etapes :
756 etape.delete_concept(sd)
757 #PN PN PN pour les matrices ????
758 #self.get_variables_avant(etape)
760 def replace_concept_after_etape(self,etape,old_sd,sd):
762 Met a jour les etapes du JDC qui sont apres etape en fonction
763 du remplacement du concept sd
765 index = self.etapes.index(etape)+1
766 if index == len(self.etapes) :
767 return # etape est la derniere etape du jdc ...on ne fait rien !
768 for child in self.etapes[index:]:
769 child.replace_concept(old_sd,sd)
771 def update_concept_after_etape(self,etape,sd):
773 Met a jour les etapes du JDC qui sont apres etape en fonction
774 de la modification (principalement nommage) du concept sd
777 #On traite toutes les etapes
780 index = self.etapes.index(etape)+1
781 if index == len(self.etapes) :
782 return # etape est la derniere etape du jdc ...on ne fait rien !
783 for child in self.etapes[index:]:
784 child.update_concept(sd)
786 def dump_state(self):
787 print "JDC.state: ",self.state
788 for etape in self.etapes :
789 print etape.nom+".state: ",etape.state
791 def change_unit(self,unit,etape,old_unit):
792 #print "change_unit",unit,etape,old_unit
793 #print id(self.recorded_units),self.recorded_units
794 #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
795 self.record_unit(unit,etape)
797 def record_unit(self,unit,etape):
798 """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
799 #print "record_unit",unit,etape
802 self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
804 self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
805 #print id(self.recorded_units),self.recorded_units
806 #print self.recorded_units.get(None,(None,"",{}))[2]
807 #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
809 def changefichier(self,fichier):
812 def eval_in_context(self,valeur,etape):
813 """ Tente d'evaluer valeur dans le contexte courant de etape
814 Retourne le parametre valeur inchange si l'evaluation est impossible
816 #contexte initial du jdc
817 context=self.condition_context.copy()
818 #contexte courant des concepts. Il contient les parametres
819 context.update(self.get_contexte_avant(etape))
821 objet = eval(valeur,context)
824 #traceback.print_exc()
828 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
830 #print "supprime",self
831 Noyau.N_JDC.JDC.supprime(self)
832 for etape in self.etapes:
836 self.const_context={}
839 self.current_context={}
840 self.condition_context={}
841 self.etapes_niveaux=[]
845 self._etape_context=None
848 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
849 def register(self,etape):
851 Cette methode ajoute etape dans la liste
852 des etapes self.etapes et retourne l identificateur d'etape
853 fourni par l appel a g_register
855 A quoi sert editmode ?
856 - Si editmode vaut 1, on est en mode edition de JDC. On cherche
857 a enregistrer une etape que l'on a creee avec eficas (en passant
858 par addentite) auquel cas on ne veut recuperer que son numero
859 d'enregistrement et c'est addentite qui l'enregistre dans
860 self.etapes a la bonne place...
861 - Si editmode vaut 0, on est en mode relecture d'un fichier de
862 commandes et on doit enregistrer l'etape a la fin de self.etapes
863 (dans ce cas l'ordre des etapes est bien l'ordre chronologique
866 if not self.editmode:
867 self.etapes.append(etape)
868 self.index_etapes[etape] = len(self.etapes) - 1
871 return self.g_register(etape)
873 #ATTENTION SURCHARGE : cette methode doit etre gardee en synchronisation avec celle de Noyau
874 def NommerSdprod(self,sd,sdnom,restrict='non'):
876 Nomme la SD apres avoir verifie que le nommage est possible :
878 Si le nom est deja utilise, leve une exception
879 Met le concept cree dans le concept global g_context
881 # XXX En mode editeur dans EFICAS, le nommage doit etre gere differemment
882 # Le dictionnaire g_context ne represente pas le contexte
883 # effectif avant une etape.
884 # Il faut utiliser get_contexte_avant avec indication de l'etape
886 # Cette etape est indiquee par l'attribut _etape_context qui a ete
887 # positionne prealablement par un appel a set_etape_context
889 if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
891 if self._etape_context:
892 o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
894 o=self.sds_dict.get(sdnom,None)
896 if isinstance(o,ASSD):
897 raise AsException(tr(" Nom de concept deja defini : "+ sdnom))
899 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
900 # Ajoute a la creation (appel de reg_sd).
901 self.sds_dict[sdnom]=sd
904 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
905 if restrict == 'non':
906 self.g_context[sdnom]=sd
908 def delete_concept_entre_etapes(self,index1,index2,sd):
909 if index2 <= index1 :return
910 for child in self.etapes[index1:index2]:
911 child.delete_concept(sd)
913 def delete_concept_after_etape(self,etape,sd):
915 Met a jour les etapes du JDC qui sont apres etape en fonction
916 de la disparition du concept sd
918 index = self.etapes.index(etape)+1
919 if index == len(self.etapes) :
920 return # etape est la derniere etape du jdc ...on ne fait rien !
921 for child in self.etapes[index:]:
922 child.delete_concept(sd)
924 #ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer
926 def get_file(self,unite=None,fic_origine=''):
928 Retourne le nom du fichier correspondant a un numero d'unite
929 logique (entier) ainsi que le source contenu dans le fichier
931 if self.appli is not None:
932 # Si le JDC est relie a une application maitre, on delegue la recherche
933 file,text= self.appli.get_file(unite,fic_origine)
937 if os.path.exists(u"fort."+str(unite)):
938 file= "fort."+str(unite)
940 raise AsException(tr("Impossible de trouver le fichier correspondant a l'unite "+str( unite)))
941 if not os.path.exists(file):
942 raise AsException(str(unite)+ tr(" n'est pas un fichier existant"))
946 #if file == None : return None,None
947 text=string.replace(text,'\r\n','\n')
949 linecache.cache[file]=0,0,string.split(text,'\n'),file
952 def isvalid(self,cr='non'):
953 if hasattr(self,'valid'): old_valid=self.valid
955 valid=Validation.V_JDC.JDC.isvalid(self,cr)
956 if valid != old_valid:
957 CONNECTOR.Emit(self,"valid")
960 def get_l_noms_etapes(self):
962 Retourne la liste des noms des étapes de self
965 for etape in self.etapes: