]> SALOME platform Git repositories - tools/eficas.git/blob - Extensions/commande_comm.py
Salome HOME
CCAR: corrections diverses dans le cas d'insertion d'un include avec concepts de
[tools/eficas.git] / Extensions / commande_comm.py
1 # -*- coding: utf-8 -*-
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.
9 #
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.
14 #
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.
18 #
19 #
20 # ======================================================================
21 import os,traceback,string
22
23 from Noyau.N_CR import CR
24 from Noyau.N_Exception import AsException
25 from Noyau import N_OBJECT
26 from Ihm import I_OBJECT
27
28 class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
29     """
30     Cette classe sert à définir les objets de type Commande commentarisée
31     """
32     nature = "COMMANDE_COMMENTARISEE"
33     idracine='_comm'
34     
35     def __init__(self,texte='',parent=None,reg='oui'):
36         self.valeur = texte
37         if not parent :
38             self.jdc = self.parent = CONTEXT.get_current_step()
39         else:
40             self.jdc = self.parent = parent
41         if hasattr(self.parent,'etape'):
42           self.etape = self.parent.etape
43         else :
44           self.etape = None
45         self.definition=self
46         self.nom = ''
47         self.niveau = self.parent.niveau
48         self.actif=1
49         self.state="unchanged"
50         #self.appel = N_utils.callee_where(niveau=2)
51         if reg=='oui' : self.register()
52             
53     def isvalid(self):
54         return 1
55
56     def report(self):
57         """
58         Génère l'objet rapport (classe CR)
59         """
60         self.cr=CR()
61         if not self.isvalid(): self.cr.warn("Objet commande commentarisé invalide")
62         return self.cr
63
64     def copy(self):
65         """
66         Retourne une copie de self cad un objet COMMANDE_COMM
67         """
68         # XXX self.texte ne semble pas exister ???
69         return COMMANDE_COMM(self.texte,parent = self.parent,reg='non')
70
71     def init_modif(self):
72         self.state = 'modified'
73         self.parent.init_modif()    
74
75     def set_valeur(self,new_valeur):
76         """
77         Remplace la valeur de self(si elle existe) par new_valeur)
78         """
79         self.valeur = new_valeur
80         self.init_modif()
81
82     def get_valeur(self) :
83         """
84         Retourne la valeur de self, cad le texte de la commande commentarisée
85         """
86         return self.valeur
87
88     def register(self):
89         """
90         Enregistre la commande commenatrisée dans la liste des étapes de son parent lorsque celui-ci
91         est un JDC
92         """
93         self.parent.register(self)
94
95     def isoblig(self):
96         """
97         Indique si self est obligatoire ou non : retourne toujours 0
98         """
99         return 0
100
101     def ident(self):
102         """
103         Retourne le nom interne associé à self
104         Ce nom n'est jamais vu par l'utilisateur dans EFICAS
105         """
106         return self.nom
107
108     def isrepetable(self):
109         """
110         Indique si self est répétable ou non : retourne toujours 1
111         """
112         return 1        
113
114     def get_attribut(self,nom_attribut) :
115         """
116         Retourne l'attribut de nom nom_attribut de self (ou hérité)
117         """
118         if hasattr(self,nom_attribut) :
119           return getattr(self,nom_attribut)
120         else :
121           return None
122
123     def get_fr(self):
124         """
125         Retourne l'attribut fr de self.definition
126         """
127         try :
128           return getattr(self.definition,'fr')
129         except:
130           return ''
131
132     def liste_mc_presents(self):
133         return []
134
135     def supprime(self):
136         """ 
137         Méthode qui supprime toutes les boucles de références afin que l'objet puisse
138         être correctement détruit par le garbage collector 
139         """
140         self.parent = None
141         self.etape = None
142         self.jdc = None
143         self.niveau = None
144         self.definition = None
145         self.valeur = None
146         self.val = None
147         self.appel = None
148
149     def supprime_sdprods(self):
150         pass
151
152     def update_context(self,d):
153         """
154         Update le dictionnaire d avec les concepts ou objets produits par self
155         --> ne fait rien pour une commande en  commentaire
156         """
157         pass
158
159     def delete_concept(self,sd):
160         pass
161
162     def replace_concept (self,old_sd,sd):
163         pass
164
165     def get_sdprods(self,nom_sd):
166         return None
167
168     def uncomment(self):
169         """
170         Cette méthode a pour but de décommentariser l'objet courant,
171         cad de retourner un tuple contenant :
172           - l'objet CMD associé
173           - le nom de la sdprod éventuellement produite (sinon None)
174         """
175         # on récupère le contexte avant la commande commentarisée
176         context_ini = self.jdc.get_contexte_avant(self)
177         try:
178             # on essaie de créer un objet JDC...
179             CONTEXT.unset_current_step()
180             J=self.jdc.__class__(procedure=self.valeur,
181                                  definition=self.jdc.definition,
182                                  cata=self.jdc.cata,
183                                  cata_ord_dico=self.jdc.cata_ordonne_dico,
184                                  context_ini = context_ini,
185                                 )
186             J.analyse()
187         except Exception,e:
188             traceback.print_exc()
189             #self.jdc.set_context()
190             raise AsException("Erreur",str(e))
191         if len(J.cr.crfatal)>0 :
192             # des erreurs fatales ont été rencontrées
193             #self.jdc.set_context()
194             print 'erreurs fatales !!!'
195             raise AsException("Erreurs fatales",string.join(J.cr.crfatal))
196         if not J.etapes :
197             # des erreurs ont été rencontrées
198             raise AsException("Impossible reconstruire commande\n",str(J.cr))
199         #self.jdc.set_context()
200
201         new_etape = J.etapes[0]
202         if new_etape.sd :
203             nom_sd = new_etape.sd.nom
204         else:
205             nom_sd = None
206         #new_etape=new_etape.copy()
207         #print "uncomment",new_etape.sd
208
209         pos=self.parent.etapes.index(self)
210         self.parent.addentite(new_etape,pos)
211         self.parent.suppentite(self)
212         return new_etape,nom_sd
213
214     def active(self):
215         """
216         Rend l'etape courante active
217         """
218         self.actif = 1
219
220     def inactive(self):
221         """
222         Rend l'etape courante inactive
223         """
224         self.actif = 0
225
226     def isactif(self):
227         """
228         Booléenne qui retourne 1 si self est valide, 0 sinon
229         """
230         return self.actif
231     
232     def verif_condition_bloc(self):
233       """
234           Evalue les conditions de tous les blocs fils possibles
235           (en fonction du catalogue donc de la définition) de self et
236           retourne deux listes :
237             - la première contient les noms des blocs à rajouter
238             - la seconde contient les noms des blocs à supprimer
239       """
240       return [],[]
241
242     def verif_condition_regles(self,liste_presents):
243       """
244           Retourne la liste des mots-clés à rajouter pour satisfaire les règles
245           en fonction de la liste des mots-clés présents
246       """
247       return []
248
249     def reparent(self,parent):
250       """
251           Cette methode sert a reinitialiser la parente de l'objet
252       """
253       self.parent=parent
254       self.jdc=parent.get_jdc_root()
255       self.etape=self
256
257     def verif_existence_sd(self):
258       """
259          Vérifie que les structures de données utilisées dans self existent bien dans le contexte
260          avant étape, sinon enlève la référence à ces concepts
261          --> sans objet pour les commandes commentarisées
262       """
263       pass
264         
265     def control_sdprods(self,d):
266       """sans objet pour les commandes commentarisées"""
267       pass
268     def close(self):
269       pass