]> SALOME platform Git repositories - tools/eficas.git/blob - Extensions/parametre.py
Salome HOME
PN Pour les formules
[tools/eficas.git] / Extensions / parametre.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 """
22     Ce module contient la classe PARAMETRE qui sert à définir
23     des objets paramètres qui sont compréhensibles et donc affichables
24     par EFICAS.
25     Ces objets sont créés à partir de la modification du fichier de commandes
26     de l'utilisateur par le parseur de fichiers Python
27 """
28
29 # import de modules Python
30 import string,types
31
32 # import de modules Eficas
33 from Noyau.N_CR import CR
34
35 class PARAMETRE :
36   """
37      Cette classe permet de créer des objets de type PARAMETRE
38      cad des affectations directes dans le jeu de commandes (ex: a=10.)
39      qui sont interprétées par le parseur de fichiers Python.
40      Les objets ainsi créés constituent des paramètres pour le jdc
41   """
42
43   nature = 'PARAMETRE'
44   idracine = 'param'
45
46   def __init__(self,nom,valeur=None):
47     # parent ne peut être qu'un objet de type JDC
48     self.valeur = self.interprete_valeur(valeur)
49     self.val=valeur
50     self.nom = nom
51     # La classe PARAMETRE n'a pas de définition : on utilise self pour
52     # complétude
53     self.definition=self
54     self.jdc = self.parent = CONTEXT.get_current_step()
55     self.niveau=self.parent.niveau
56     self.actif=1
57     self.state='undetermined'
58     self.register()
59
60   def interprete_valeur(self,val):
61     """
62     Essaie d'interpréter val (chaîne de caractères)comme :
63     - un entier
64     - un réel
65     - une chaîne de caractères
66     - une liste d'items d'un type qui précède
67     Retourne la valeur interprétée
68     """
69     if not val : return None
70     valeur = None
71     #  on vérifie si val est un entier
72     try :
73         valeur = string.atoi(val)       # on a un entier
74         return valeur
75     except :
76         pass
77     #  on vérifie si val est un réel
78     try:
79         valeur = string.atof(val)   # on a un réel
80         return valeur
81     except :
82         pass
83     # on vérifie si val est un tuple
84     try :
85         valeur = eval(val)
86     except:
87         pass
88     if valeur != None :
89         if type(valeur) == types.TupleType:
90             l_new_val = []
91             typ = None
92             for v in valeur :
93                 if not typ:
94                     typ = type(v)
95                 else:
96                     if type(v) != typ :
97                         # la liste est hétérogène --> on refuse d'interpréter
98                         #  self comme une liste
99                         # on retourne la string initiale
100                         print 'liste hétérogène ',val
101                         return val
102                 l_new_val.append(v)
103             return tuple(l_new_val)
104         # PN : commente le print
105         #else:
106             # on a réussi à évaluer val en autre chose qu'un tuple ...
107             #print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
108             #print 'on trouve : ',str(valeur),' de type : ',type(valeur)
109     # on retourne val comme une string car on n'a pas su l'interpréter
110     return val
111
112   def set_valeur(self,new_valeur):
113     """
114     Remplace la valeur de self par new_valeur interprétée
115     """
116     self.valeur = self.interprete_valeur(new_valeur)
117     self.init_modif()
118
119   def init_modif(self):
120     """
121     Méthode qui déclare l'objet courant comme modifié et propage
122     cet état modifié à ses ascendants
123     """
124     self.state = 'modified'
125     if self.parent:
126       self.parent.init_modif()
127
128   def register(self):
129     """
130     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
131     """
132     self.parent.register_parametre(self)
133     self.parent.register(self)
134
135   def isvalid(self,cr='non'):
136     """
137     Retourne 1 si self est valide, 0 sinon
138     Un paramètre est considéré comme valide si :
139       - il a un nom
140       - il a une valeur
141     """
142     if self.nom == '' :
143         if cr == 'oui':
144            self.cr.fatal("Pas de nom donné au paramètre ")
145         return 0
146     else:
147         if self.valeur == None :
148             if cr == 'oui' : 
149                self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
150             return 0
151     return 1
152
153   def isoblig(self):
154     """
155     Indique si self est obligatoire ou non : retourne toujours 0
156     """
157     return 0
158
159   def isrepetable(self):
160     """
161     Indique si self est répétable ou non : retourne toujours 1
162     """
163     return 1
164
165   def liste_mc_presents(self):
166     return []
167
168   def supprime(self):
169     """
170     Méthode qui supprime toutes les boucles de références afin que 
171     l'objet puisse être correctement détruit par le garbage collector
172     """
173     self.parent = None
174     self.jdc = None
175     self.definition=None
176
177   def active(self):
178     """
179     Rend l'etape courante active.
180     Il faut ajouter le paramètre au contexte global du JDC
181     """
182     self.actif = 1
183     try:
184         self.jdc.append_param(self)
185     except:
186         pass
187
188   def inactive(self):
189     """
190     Rend l'etape courante inactive
191     Il faut supprimer le paramètre du contexte global du JDC
192     """
193     self.actif = 0
194     self.jdc.del_param(self)
195     self.jdc.delete_concept_after_etape(self,self)
196
197   def isactif(self):
198     """
199     Booléenne qui retourne 1 si self est actif, 0 sinon
200     """
201     return self.actif
202
203   def set_attribut(self,nom_attr,new_valeur):
204     """
205     Remplace la valeur de self.nom_attr par new_valeur)
206     """
207     if hasattr(self,nom_attr):
208       setattr(self,nom_attr,new_valeur)
209       self.init_modif()
210
211   def supprime_sdprods(self):
212     """
213     Il faut supprimer le paramètre qui a été entré dans la liste des
214     paramètres du JDC
215     """
216     self.jdc.delete_param(self)
217
218   def update_context(self,d):
219     """
220     Update le dictionnaire d avec le paramètre que produit self
221     """
222     d[self.nom]=self
223
224   def __repr__(self):
225     """
226         Donne un echo de self sous la forme nom = valeur
227     """
228     return self.nom+' = '+str(self.valeur)
229
230   def __str__(self):
231     """
232         Retourne le nom du paramètre comme représentation de self
233     """
234     return self.nom
235
236   def get_sdprods(self,nom_sd):
237      """
238          Retourne les concepts produits par la commande
239      """
240      return None
241
242   def report(self):
243     """ Génère l'objet rapport (classe CR) """
244     self.cr=CR()
245     self.isvalid(cr='oui')
246     return self.cr
247
248   def ident(self):
249     """
250     Retourne le nom interne associé à self
251     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
252     """
253     return self.nom
254
255   def delete_concept(self,sd):
256     pass
257
258   def replace_concept(self,old_sd,sd):
259     pass
260
261   def verif_condition_bloc(self):
262     """
263         Evalue les conditions de tous les blocs fils possibles
264         (en fonction du catalogue donc de la définition) de self et
265         retourne deux listes :
266           - la première contient les noms des blocs à rajouter
267           - la seconde contient les noms des blocs à supprimer
268     """
269     return [],[]
270
271   def verif_condition_regles(self,liste_presents):
272     """
273         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
274         en fonction de la liste des mots-clés présents
275     """
276     return []
277
278   def verif_existence_sd(self):
279      pass
280
281   def control_sdprods(self,d):
282       """sans objet """
283       pass
284
285
286
287