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.
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 # ======================================================================
22 Ce module contient la classe PARAMETRE qui sert à définir
23 des objets paramètres qui sont compréhensibles et donc affichables
25 Ces objets sont créés à partir de la modification du fichier de commandes
26 de l'utilisateur par le parseur de fichiers Python
29 # import de modules Python
33 # import de modules Eficas
34 from Noyau.N_CR import CR
35 from Noyau import N_OBJECT
36 from Ihm import I_OBJECT
38 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
40 Cette classe permet de créer des objets de type PARAMETRE
41 cad des affectations directes dans le jeu de commandes (ex: a=10.)
42 qui sont interprétées par le parseur de fichiers Python.
43 Les objets ainsi créés constituent des paramètres pour le jdc
49 def __init__(self,nom,valeur=None):
50 # parent ne peut être qu'un objet de type JDC
52 self.valeur = self.interprete_valeur(valeur)
55 # La classe PARAMETRE n'a pas de définition : on utilise self pour
58 self.jdc = self.parent = CONTEXT.get_current_step()
59 self.niveau=self.parent.niveau
61 self.state='undetermined'
64 def __getitem__(self,key):
65 param_item=ITEM_PARAMETRE(self,key)
72 print "******* Probleme : pas de valeur négative"
77 return self.valeur+a.valeur
79 print "******* Probleme : a l addition"
84 return self.valeur+a.valeur
86 print "******* Probleme : a l addition"
91 return self.valeur - a.valeur
93 print "******* Probleme : a la soustraction"
98 return a.valeur - self.valeur
100 print "******* Probleme : a la soustraction"
105 return self.valeur*a.valeur
107 print "******* Probleme : a la multiplication"
110 def __rmul__(self,a):
112 return self.valeur*a.valeur
114 print "******* Probleme : a la multiplication"
119 return self.valeur*a.valeur
121 print "******* Probleme : a la multiplication"
124 def __rmul__(self,a):
126 return self.valeur*a.valeur
128 print "******* Probleme : a la multiplication"
131 def __add__(self,other):
133 return self.valeur+other
135 print "******* Probleme : a l addition"
138 def __radd__(self,other):
140 return self.valeur+other
142 print "******* Probleme : a l addition"
145 def __sub__(self,other):
147 return self.valeur - other
149 print "******* Probleme : a la soustraction"
152 def __rsub__(self,other):
154 return other - self.valeur
156 print "******* Probleme : a la soustraction"
159 def __mul__ (self,other):
162 retour = eval(self.valeur) * other
165 retour = self.valeur * other
167 print "******* Probleme : a la multiplication"
170 def __rmul__ (self,other):
173 retour = eval(self.valeur) * other
176 retour = self.valeur * other
178 print "******* Probleme : a la multiplication"
182 def __div__(self,other):
185 retour = eval(self.valeur) / other
188 retour = self.valeur / other
190 print "******* Probleme : a la division"
194 def interprete_valeur(self,val):
196 Essaie d'interpréter val (chaîne de caractères)comme :
199 - une chaîne de caractères
200 - une liste d'items d'un type qui précède
201 Retourne la valeur interprétée
203 if not val : return None
205 # on vérifie si val est un entier
207 valeur = string.atoi(val) # on a un entier
211 # on vérifie si val est un réel
213 valeur = string.atof(val) # on a un réel
217 # on vérifie si val est un tuple
222 #PN je n ose pas modifier je rajoute
224 if type(valeur) == types.TupleType:
232 # la liste est hétérogène --> on refuse d'interpréter
233 # self comme une liste
234 # on retourne la string initiale
235 print 'liste hétérogène ',val
238 return tuple(l_new_val)
239 # PN : commente le print
241 # on a réussi à évaluer val en autre chose qu'un tuple ...
242 #print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
243 #print 'on trouve : ',str(valeur),' de type : ',type(valeur)
244 # on retourne val comme une string car on n'a pas su l'interpréter
246 if type(valeur).__name__ == 'list':
248 for i in range(len(valeur)):
249 self.dict_valeur.append(valeur[i])
252 def get_valeurs(self):
254 if self.dict_valeur != []:
255 for val in self.dict_valeur:
256 valeurretour.append(val)
258 valeurretour.append(self.valeur)
261 def set_valeur(self,new_valeur):
263 Remplace la valeur de self par new_valeur interprétée
265 self.valeur = self.interprete_valeur(new_valeur)
268 def init_modif(self):
270 Méthode qui déclare l'objet courant comme modifié et propage
271 cet état modifié à ses ascendants
273 self.state = 'modified'
275 self.parent.init_modif()
277 def get_jdc_root(self):
279 return self.parent.get_jdc_root()
285 Enregistre le paramètre dans la liste des étapes de son parent (JDC)
287 self.parent.register_parametre(self)
288 self.parent.register(self)
290 def isvalid(self,cr='non'):
292 Retourne 1 si self est valide, 0 sinon
293 Un paramètre est considéré comme valide si :
299 self.cr.fatal("Pas de nom donné au paramètre ")
302 if self.valeur == None :
304 self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
310 Indique si self est obligatoire ou non : retourne toujours 0
314 def isrepetable(self):
316 Indique si self est répétable ou non : retourne toujours 1
320 def liste_mc_presents(self):
325 Méthode qui supprime toutes les boucles de références afin que
326 l'objet puisse être correctement détruit par le garbage collector
334 Rend l'etape courante active.
335 Il faut ajouter le paramètre au contexte global du JDC
339 self.jdc.append_param(self)
345 Rend l'etape courante inactive
346 Il faut supprimer le paramètre du contexte global du JDC
349 self.jdc.del_param(self)
350 self.jdc.delete_concept_after_etape(self,self)
354 Booléenne qui retourne 1 si self est actif, 0 sinon
358 def set_attribut(self,nom_attr,new_valeur):
360 Remplace la valeur de self.nom_attr par new_valeur)
362 if hasattr(self,nom_attr):
363 setattr(self,nom_attr,new_valeur)
366 def supprime_sdprods(self):
368 Il faut supprimer le paramètre qui a été entré dans la liste des
371 self.jdc.delete_param(self)
373 def update_context(self,d):
375 Update le dictionnaire d avec le paramètre que produit self
381 Donne un echo de self sous la forme nom = valeur
383 return self.nom+' = '+str(self.valeur)
387 Retourne le nom du paramètre comme représentation de self
391 def get_sdprods(self,nom_sd):
393 Retourne les concepts produits par la commande
398 """ Génère l'objet rapport (classe CR) """
400 self.isvalid(cr='oui')
405 Retourne le nom interne associé à self
406 Ce nom n'est jamais vu par l'utilisateur dans EFICAS
410 def delete_concept(self,sd):
413 def replace_concept(self,old_sd,sd):
416 def verif_condition_bloc(self):
418 Evalue les conditions de tous les blocs fils possibles
419 (en fonction du catalogue donc de la définition) de self et
420 retourne deux listes :
421 - la première contient les noms des blocs à rajouter
422 - la seconde contient les noms des blocs à supprimer
426 def verif_condition_regles(self,liste_presents):
428 Retourne la liste des mots-clés à rajouter pour satisfaire les règles
429 en fonction de la liste des mots-clés présents
433 def verif_existence_sd(self):
436 def control_sdprods(self,d):
442 class ITEM_PARAMETRE :
443 def __init__(self,param_pere,item=None):
444 self.param_pere = param_pere
449 return self.param_pere.nom+'['+str(self.item)+']'
457 longueur= len(self.param_pere.dict_valeur) - 1
460 if self.item > longueur :