1 # -*- coding: iso-8859-1 -*-
2 # CONFIGURATION MANAGEMENT OF EDF VERSION
3 # ======================================================================
4 # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
8 # (AT YOUR OPTION) ANY LATER VERSION.
10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
17 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
20 # ======================================================================
24 import types,traceback,sys,os
25 import string,linecache
30 from Noyau.N_ASSD import ASSD
31 #from Noyau.N_LASSD import LASSD
32 from Noyau.N_ETAPE import ETAPE
33 from Noyau.N_Exception import AsException
34 from Extensions import commentaire,parametre,parametre_eval
41 class JDC(I_OBJECT.OBJECT):
46 self.etapes_niveaux=[]
50 self._etape_context=None
51 self.recorded_units={}
52 self.old_recorded_units={}
54 def get_index(self,objet):
56 Retourne la position d'objet dans la liste self
58 return self.etapes.index(objet)
60 def get_sd_avant_du_bon_type(self,etape,types_permis):
62 Retourne la liste des concepts avant etape d'un type acceptable
64 d=self.get_contexte_avant(etape)
67 if type(v) != types.InstanceType and not isinstance(v,object): continue
68 # On considère que seul assd indique un type quelconque pas CO
69 elif self.assd in types_permis :
71 elif self.est_permis(v,types_permis):
76 def get_variables(self,etape):
79 for etapeTraitee in self.etapes :
80 if etapeTraitee==etapeStop:
82 if etapeTraitee.nom == 'VARIABLE' :
83 variable=etapeTraitee.get_mocle('ModelVariable')
85 l.append(variable.nom)
88 def set_Copules_recalcule_etat(self):
89 for etapeTraitee in self.etapes :
90 if etapeTraitee.nom == 'CORRELATION' :
91 Matrix=etapeTraitee.get_child('Matrix')
93 Correlation=etapeTraitee.get_child('CorrelationMatrix')
94 if Correlation !=None :
95 Correlation.state='arecalculer'
96 Matrix.state='arecalculer'
98 def recalcule_etat_correlation(self):
99 for etapeTraitee in self.etapes :
100 if etapeTraitee.nom == 'CORRELATION' :
101 Matrix=etapeTraitee.get_child('Matrix')
103 Matrix.state='arecalculer'
104 Correlation=Matrix.get_child('CorrelationMatrix')
105 if Correlation !=None :
106 Correlation.state='arecalculer'
107 Correlation.isvalid()
109 etapeTraitee.state='arecalculer'
110 if etapeTraitee.state=='arecalculer':
111 etapeTraitee.isvalid()
114 def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
116 Retourne la liste des concepts avant etape d'1 type de base acceptable
117 Attention different de la routine précédente : 1 seul type passé en parametre
118 Teste sur issubclass et par sur le type permis
120 d=self.get_contexte_avant(etape)
123 typeverif=self.cata[0].__dict__[type]
126 for k,v in d.items():
127 if issubclass(v.__class__,typeverif):
132 def cherche_list_avant(self,etape,valeur):
133 d=self.get_contexte_avant(etape)
134 for k,v in d.items():
135 if issubclass(v.__class__,LASSD):
138 # Attention pour enlever les . a la fin des pretendus reels
139 if k == valeur[0:-1] :
143 def est_permis(self,v,types_permis):
144 for type_ok in types_permis:
145 if type_ok in ('R','I','C','TXM') and v in self.params :
147 elif type_ok == 'R' and v.__class__.__name__ == 'reel' :
149 elif type_ok == 'I' and v.__class__.__name__ == 'entier' :
151 elif type_ok == 'C' and v.__class__.__name__ == 'complexe' :
153 elif type_ok == 'TXM' and v.__class__.__name__ == 'chaine' :
155 elif type(type_ok) != types.ClassType and not isinstance(type_ok,type):
157 elif v.__class__ == type_ok or issubclass(v.__class__,type_ok):
161 def addentite(self,name,pos):
164 Si name est le nom d une commande ou un commentaire ajoute
166 Sinon remonte une erreur
170 if name == "COMMENTAIRE" :
171 # ajout d'un commentaire
172 self.set_current_step()
174 for child in self.etapes :
175 if isinstance(child,commentaire.COMMENTAIRE):
177 objet = commentaire.COMMENTAIRE('',parent=self)
178 objet.nom = "_comm_"+`ind`
179 if pos == None : pos = 0
180 self.etapes.insert(pos,objet)
184 CONNECTOR.Emit(self,"add",objet)
187 elif name == "PARAMETRE":
188 # ajout d'un parametre
189 self.set_current_step()
190 nom_param = '_param_'+str(len(self.params)+1)
191 objet = parametre.PARAMETRE(nom=nom_param)
192 if pos == None : pos = 0
193 self.etapes.insert(pos,objet)
197 CONNECTOR.Emit(self,"add",objet)
200 elif name == "PARAMETRE_EVAL":
201 # ajout d'un parametre EVAL
202 self.set_current_step()
203 nom_param = '_param_'+str(len(self.params)+1)
204 objet = parametre_eval.PARAMETRE_EVAL(nom=nom_param)
205 if pos == None : pos = 0
206 self.etapes.insert(pos,objet)
210 CONNECTOR.Emit(self,"add",objet)
213 elif type(name)==types.InstanceType:
214 # on est dans le cas où on veut ajouter une commande déjà
215 # existante (par copie donc)
216 # on est donc nécessairement en mode editeur ...
218 # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
220 self.set_current_step()
221 if isinstance(objet,ETAPE):
222 if objet.nom_niveau_definition == 'JDC':
223 # l'objet dépend directement du JDC
226 # l'étape dépend d'un niveau et non directement du JDC :
227 # il faut l'enregistrer dans le niveau de parent
228 objet.parent.dict_niveaux[objet.nom_niveau_definition].register(objet)
229 objet.niveau = objet.parent.dict_niveaux[objet.nom_niveau_definition]
230 self.etapes.insert(pos,objet)
232 # il faut vérifier que les concepts utilisés par objet existent bien
233 # à ce niveau d'arborescence
234 objet.verif_existence_sd()
235 objet.update_mc_global()
238 CONNECTOR.Emit(self,"add",objet)
242 # On veut ajouter une nouvelle commande
244 self.set_current_step()
245 cmd=self.get_cmd(name)
246 # L'appel a make_objet n'a pas pour effet d'enregistrer l'étape
247 # auprès du step courant car editmode vaut 1
248 # Par contre elle a le bon parent grace a set_current_step
250 if pos == None : pos = 0
251 self.etapes.insert(pos,e)
252 self.reset_current_step()
256 CONNECTOR.Emit(self,"add",e)
259 except AsException,e:
260 self.reset_current_step()
262 raise AsException("Impossible d ajouter la commande "+name + '\n' +str(e))
264 traceback.print_exc()
265 self.reset_current_step()
267 raise AsException("Impossible d ajouter la commande "+name)
270 #print "JDC.close",self
271 for etape in self.etapes:
272 if hasattr(etape,"close"):etape.close()
273 CONNECTOR.Emit(self,"close")
275 def set_current_step(self):
276 CONTEXT.unset_current_step()
277 CONTEXT.set_current_step(self)
279 def reset_current_step(self):
280 CONTEXT.unset_current_step()
282 def liste_mc_presents(self):
285 def get_sd_avant_etape(self,nom_sd,etape):
286 return self.get_contexte_avant(etape).get(nom_sd,None)
288 def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
290 Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
291 définie apres etape en tenant compte des concepts detruits
292 Si avec vaut 'non' exclut etape de la recherche
294 #print "JDC.get_sd_apres_etape_avec_detruire",nom_sd,sd
295 ietap=self.etapes.index(etape)
296 if avec == 'non':ietap=ietap+1
298 for e in self.etapes[ietap:]:
301 autre_sd=d.get(nom_sd,None)
303 # Le concept a ete detruit. On interrompt la recherche car il n'y a
304 # pas eu de redefinition du concept (il n'y a pas de conflit potentiel).
306 if autre_sd is not sd :
307 # L'etape produit un concept different de meme nom. La situation n'est
308 # pas saine (sauf peut etre si reuse ???)
309 if hasattr(e,'reuse') and e.reuse == autre_sd:
310 # Le concept etant reutilise, on interrompt la recherche.
311 # On considere qu'il n'y a pas de nouveau concept defini
312 # meme si dans les etapes suivantes le concept est detruit
313 # et un concept de meme nom créé.
314 # AVERIFIER : avec reuse le concept devrait etre le meme
315 # le passage par ici est tres improbable
318 # Le concept est produit par l'etape (Il y a conflit potentiel).
319 # Le concept est redefini par une etape posterieure.
321 # Pas de destruction du concept ni de redefinition. On retourne le
325 def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
327 Cette méthode retourne la SD de nom nom_sd qui est éventuellement
329 Si avec vaut 'non' exclut etape de la recherche
331 ietap=self.etapes.index(etape)
332 if avec == 'non':ietap=ietap+1
333 for e in self.etapes[ietap:]:
334 sd=e.get_sdprods(nom_sd)
336 if hasattr(e,'reuse'):
341 def get_sd_autour_etape(self,nom_sd,etape,avec='non'):
343 Fonction: retourne la SD de nom nom_sd qui est éventuellement
344 définie avant ou apres etape
345 Permet de vérifier si un concept de meme nom existe dans le périmètre
347 Si avec vaut 'non' exclut etape de la recherche
349 sd=self.get_sd_avant_etape(nom_sd,etape)
351 return self.get_sd_apres_etape(nom_sd,etape,avec)
353 def get_contexte_apres(self,etape):
355 Retourne le dictionnaire des concepts connus apres etape
356 On tient compte des commandes qui modifient le contexte
357 comme DETRUIRE ou les macros
358 Si etape == None, on retourne le contexte en fin de JDC
360 if not etape: return self.get_contexte_avant(etape)
362 d=self.get_contexte_avant(etape)
363 if etape.isactif():etape.update_context(d)
364 self.index_etape_courante=self.index_etape_courante+1
367 def active_etapes(self):
369 Cette méthode a pour fonction de désactiver les étapes qui doivent
370 l'être cad, dans le cas d'ASTER, les étapes qui ne sont pas
371 comprises entre le premier DEBUT/POURSUITE et le premier FIN
372 et rendre actives les autres
374 if self.definition.code == 'ASTER' :
375 # Seulement pour ASTER :
376 # Avant DEBUT actif vaut 0
377 # Apres DEBUT et avant le 1er FIN actif vaut 1
378 # Apres le 1er FIN actif vaut -1
382 for etape in self.etapes:
383 if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
388 if etape.nom == 'FIN':actif=-1
390 def suppentite(self,etape) :
392 Cette methode a pour fonction de supprimer une étape dans
394 Retourne 1 si la suppression a pu être effectuée,
395 Retourne 0 dans le cas contraire
397 #print "suppentite",self
398 #PN correction de bugs
399 if etape not in self.etapes:
403 index_etape=self.etapes.index(etape)
404 self.etapes.remove(etape)
406 if etape.niveau is not self:
407 # Dans ce cas l'étape est enregistrée dans un niveau
408 # Il faut la désenregistrer
409 etape.niveau.unregister(etape)
411 etape.supprime_sdprods()
416 # Apres suppression de l'etape il faut controler que les etapes
417 # suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
419 index_etape=index_etape-1
420 etape=self.etapes[index_etape]
423 self.control_context_apres(etape)
426 CONNECTOR.Emit(self,"supp",etape)
430 def control_context_apres(self,etape):
432 Cette méthode verifie que les etapes apres l'etape etape
433 ont bien des concepts produits acceptables (pas de conflit de
435 Si des concepts produits ne sont pas acceptables ils sont supprimés.
436 Effectue les verifications sur les etapes du jdc mais aussi sur les
437 jdc parents s'ils existent.
439 #print "control_context_apres",self,etape
440 #Regularise les etapes du jdc apres l'etape etape
441 self.control_jdc_context_apres(etape)
443 def control_jdc_context_apres(self,etape):
445 Methode semblable a control_context_apres mais ne travaille
446 que sur les etapes et sous etapes du jdc
448 #print "control_jdc_context_apres",self,etape
450 # on demarre de la premiere etape
453 index_etape=self.etapes.index(etape)+1
456 etape=self.etapes[index_etape]
458 #derniere etape du jdc : rien a faire
461 context=self.get_contexte_avant(etape)
463 for e in self.etapes[index_etape:]:
464 e.control_sdprods(context)
465 e.update_context(context)
469 if not self.cr.estvide():return
473 def register_parametre(self,param):
475 Cette méthode sert à ajouter un paramètre dans la liste des paramètres
477 self.params.append(param)
479 def register_fonction(self,fonction):
481 Cette méthode sert à ajouter une fonction dans la liste des fonctions
483 self.fonctions.append(fonction)
485 def delete_param(self,param):
487 Supprime le paramètre param de la liste des paramètres
490 if param in self.params : self.params.remove(param)
491 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
493 def get_parametres_fonctions_avant_etape(self,etape):
495 Retourne deux éléments :
496 - une liste contenant les noms des paramètres (constantes ou EVAL)
498 - une liste contenant les formules définies avant etape
502 # on récupère le contexte avant etape
503 # on ne peut mettre dans les deux listes que des éléments de ce contexte
504 d=self.get_contexte_avant(etape)
505 # construction de l_constantes
506 for param in self.params:
508 if not nom : continue
509 if d.has_key(nom): l_constantes.append(nom)
510 # construction de l_fonctions
511 for form in self.fonctions:
513 if not nom : continue
514 if d.has_key(nom): l_fonctions.append(form.get_formule())
516 # on ajoute les concepts produits par DEFI_VALEUR
517 # XXX On pourrait peut etre faire plutot le test sur le type
518 # de concept : entier, reel, complexe, etc.
519 for k,v in d.items():
520 if hasattr(v,'etape') and v.etape.nom in ('DEFI_VALEUR',):
521 l_constantes.append(k)
523 # on retourne les deux listes
524 return l_constantes,l_fonctions
526 def get_nb_etapes_avant(self,niveau):
528 Retourne le nombre d etapes avant le debut de niveau
531 for niv in self.etapes_niveaux:
532 if niv == niveau:break
533 nb=nb+len(niv.etapes)
536 def init_modif(self):
538 Méthode appelée au moment où une modification va être faite afin de
539 déclencher d'éventuels traitements pré-modification
541 #print "init_modif",self
542 self.state = 'modified'
545 #print "fin_modif",self
546 CONNECTOR.Emit(self,"valid")
550 def deep_update_condition_bloc(self):
551 # pour le moment, on ne fait rien
552 raise "Not implemented"
554 def update_condition_bloc(self):
555 # pour le moment, on ne fait rien
556 raise "Not implemented"
558 def get_liste_mc_inconnus(self):
560 Retourne une liste contenant les mots-clés inconnus à la relecture du JDC
562 # cette liste a le format suivant : [etape,(bloc,mcfact,...),nom_mc,valeur_mc]
564 for etape in self.etapes :
566 if not etape.isvalid() :
567 l = etape.get_liste_mc_inconnus()
568 if l : l_mc.extend(l)
571 def get_genealogie(self):
573 Retourne la liste des noms des ascendants de l'objet self
574 jusqu'à la première ETAPE parent.
578 def get_liste_cmd(self):
580 Retourne la liste des commandes du catalogue
582 return self.niveau.definition.get_liste_cmd()
584 def get_groups(self):
586 Retourne la liste des groupes
588 return self.niveau.definition.liste_groupes,self.niveau.definition.dict_groupes
590 def set_etape_context(self,etape):
592 Positionne l'etape qui sera utilisee dans NommerSdProd pour
593 decider si le concept passé pourra etre nommé
595 self._etape_context=etape
597 def reset_context(self):
599 Cette methode reinitialise le contexte glissant pour pouvoir
600 tenir compte des modifications de l'utilisateur : création
601 de commandes, nommage de concepts, etc.
603 #print "reset_context",self,self.nom
604 self.current_context={}
605 self.index_etape_courante=0
607 for i,etape in enumerate(self.etapes):
609 self.index_etapes=ind
611 # for etape in self.etapes:
612 # etape.reset_context()
614 def del_sdprod(self,sd):
616 Supprime la SD sd de la liste des sd et des dictionnaires de contexte
618 #print "del_sdprod",self,sd
619 #print "del_sdprod",self.sds
620 #print "del_sdprod",self.g_context
621 #print "del_sdprod",self.sds_dict
622 if sd in self.sds : self.sds.remove(sd)
623 if self.g_context.has_key(sd.nom) : del self.g_context[sd.nom]
624 if self.sds_dict.has_key(sd.nom) : del self.sds_dict[sd.nom]
626 def del_param(self,param):
628 Supprime le paramètre param de la liste des paramètres
631 if param in self.params : self.params.remove(param)
632 if self.g_context.has_key(param.nom) : del self.g_context[param.nom]
634 def del_fonction(self,fonction):
636 Supprime la fonction fonction de la liste des fonctions
639 if fonction in self.fonctions : self.fonctions.remove(fonction)
640 if self.g_context.has_key(fonction.nom) : del self.g_context[fonction.nom]
642 def append_sdprod(self,sd):
644 Ajoute la SD sd à la liste des sd en vérifiant au préalable qu'une SD de
645 même nom n'existe pas déjà
647 if sd == None or sd.nom == None:return
649 o=self.sds_dict.get(sd.nom,None)
650 if isinstance(o,ASSD):
651 raise AsException("Nom de concept deja defini : %s" % sd.nom)
652 self.sds_dict[sd.nom]=sd
653 self.g_context[sd.nom] = sd
654 if sd not in self.sds : self.sds.append(sd)
656 def append_param(self,param):
658 Ajoute le paramètre param à la liste des params
659 et au contexte global
661 # il faudrait vérifier qu'un paramètre de même nom n'existe pas déjà !!!
662 if param not in self.params : self.params.append(param)
663 self.g_context[param.nom]=param
665 def append_fonction(self,fonction):
667 Ajoute la fonction fonction à la liste des fonctions
668 et au contexte global
670 # il faudrait vérifier qu'une fonction de même nom n'existe pas déjà !!!
671 if fonction not in self.fonctions : self.fonctions.append(fonction)
672 self.g_context[fonction.nom]=fonction
674 def delete_concept(self,sd):
679 Mettre a jour les etapes du JDC suite à la disparition du
681 Seuls les mots cles simples MCSIMP font un traitement autre
682 que de transmettre aux fils
684 for etape in self.etapes :
685 etape.delete_concept(sd)
686 #PN PN PN pour les matrices ????
687 #self.get_variables_avant(etape)
689 def replace_concept_after_etape(self,etape,old_sd,sd):
691 Met à jour les étapes du JDC qui sont après etape en fonction
692 du remplacement du concept sd
694 index = self.etapes.index(etape)+1
695 if index == len(self.etapes) :
696 return # etape est la dernière étape du jdc ...on ne fait rien !
697 for child in self.etapes[index:]:
698 child.replace_concept(old_sd,sd)
700 def update_concept_after_etape(self,etape,sd):
702 Met à jour les étapes du JDC qui sont après etape en fonction
703 de la modification (principalement nommage) du concept sd
706 #On traite toutes les etapes
709 index = self.etapes.index(etape)+1
710 if index == len(self.etapes) :
711 return # etape est la dernière étape du jdc ...on ne fait rien !
712 for child in self.etapes[index:]:
713 child.update_concept(sd)
715 def dump_state(self):
716 print "JDC.state: ",self.state
717 for etape in self.etapes :
718 print etape.nom+".state: ",etape.state
720 def change_unit(self,unit,etape,old_unit):
721 #print "change_unit",unit,etape,old_unit
722 #print id(self.recorded_units),self.recorded_units
723 #if self.recorded_units.has_key(old_unit):del self.recorded_units[old_unit]
724 self.record_unit(unit,etape)
726 def record_unit(self,unit,etape):
727 """Enregistre les unites logiques incluses et les infos relatives a l'etape"""
728 #print "record_unit",unit,etape
731 self.recorded_units[None]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
733 self.recorded_units[unit]=(etape.fichier_ini ,etape.fichier_text,etape.recorded_units)
734 #print id(self.recorded_units),self.recorded_units
735 #print self.recorded_units.get(None,(None,"",{}))[2]
736 #print self.recorded_units.get(None,(None,"",{}))[2].get(None,(None,"",{}))
738 def changefichier(self,fichier):
741 def eval_in_context(self,valeur,etape):
742 """ Tente d'evaluer valeur dans le contexte courant de etape
743 Retourne le parametre valeur inchange si l'evaluation est impossible
745 #contexte initial du jdc
746 context=self.condition_context.copy()
747 #contexte courant des concepts. Il contient les parametres
748 context.update(self.get_contexte_avant(etape))
750 objet = eval(valeur,context)
753 #traceback.print_exc()
757 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
759 #print "supprime",self
760 Noyau.N_JDC.JDC.supprime(self)
763 self.const_context={}
767 self.current_context={}
768 self.condition_context={}
769 self.etapes_niveaux=[]
773 self._etape_context=None
776 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
777 def register(self,etape):
779 Cette méthode ajoute etape dans la liste
780 des etapes self.etapes et retourne l identificateur d'étape
781 fourni par l appel a g_register
783 A quoi sert editmode ?
784 - Si editmode vaut 1, on est en mode edition de JDC. On cherche
785 à enregistrer une étape que l'on a créée avec eficas (en passant
786 par addentite) auquel cas on ne veut récupérer que son numéro
787 d'enregistrement et c'est addentité qui l'enregistre dans
788 self.etapes à la bonne place...
789 - Si editmode vaut 0, on est en mode relecture d'un fichier de
790 commandes et on doit enregistrer l'étape à la fin de self.etapes
791 (dans ce cas l'ordre des étapes est bien l'ordre chronologique
794 if not self.editmode:
795 self.etapes.append(etape)
796 self.index_etapes[etape] = len(self.etapes) - 1
799 return self.g_register(etape)
801 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
802 def NommerSdprod(self,sd,sdnom,restrict='non'):
804 Nomme la SD apres avoir verifie que le nommage est possible :
806 Si le nom est deja utilise, leve une exception
807 Met le concept créé dans le concept global g_context
809 # XXX En mode editeur dans EFICAS, le nommage doit etre géré différemment
810 # Le dictionnaire g_context ne représente pas le contexte
811 # effectif avant une étape.
812 # Il faut utiliser get_contexte_avant avec indication de l'étape
814 # Cette etape est indiquee par l'attribut _etape_context qui a ete
815 # positionné préalablement par un appel à set_etape_context
817 if CONTEXT.debug : print "JDC.NommerSdprod ",sd,sdnom
819 if self._etape_context:
820 o=self.get_contexte_avant(self._etape_context).get(sdnom,None)
822 o=self.sds_dict.get(sdnom,None)
824 if isinstance(o,ASSD):
825 raise AsException("Nom de concept deja defini : %s" % sdnom)
827 # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
828 # Ajoute a la creation (appel de reg_sd).
829 self.sds_dict[sdnom]=sd
832 # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
833 if restrict == 'non':
834 self.g_context[sdnom]=sd
836 #ATTENTION SURCHARGE : cette methode doit etre gardée en synchronisation avec celle de Noyau
837 def delete_concept_after_etape(self,etape,sd):
839 Met à jour les étapes du JDC qui sont après etape en fonction
840 de la disparition du concept sd
842 index = self.etapes.index(etape)+1
843 if index == len(self.etapes) :
844 return # etape est la dernière étape du jdc ...on ne fait rien !
845 for child in self.etapes[index:]:
846 child.delete_concept(sd)
848 #ATTENTION SURCHARGE : les methodes ci-dessous surchargent des methodes de Noyau et Validation : a reintegrer
850 def get_file(self,unite=None,fic_origine=''):
852 Retourne le nom du fichier correspondant à un numero d'unité
853 logique (entier) ainsi que le source contenu dans le fichier
855 if self.appli is not None:
856 # Si le JDC est relié à une application maitre, on délègue la recherche
857 file,text= self.appli.get_file(unite,fic_origine)
861 if os.path.exists("fort."+str(unite)):
862 file= "fort."+str(unite)
864 raise AsException("Impossible de trouver le fichier correspondant"
865 " a l unite %s" % unite)
866 if not os.path.exists(file):
867 raise AsException("%s n'est pas un fichier existant" % unite)
871 #if file == None : return None,None
872 text=string.replace(text,'\r\n','\n')
874 linecache.cache[file]=0,0,string.split(text,'\n'),file
877 def isvalid(self,cr='non'):
878 if hasattr(self,'valid'): old_valid=self.valid
880 valid=Validation.V_JDC.JDC.isvalid(self,cr)
881 if valid != old_valid:
882 CONNECTOR.Emit(self,"valid")