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 from math import *
  32
  33 # import de modules Eficas
  34 from Noyau.N_CR import CR
  35 from Noyau import N_OBJECT
  36 from Ihm import I_OBJECT
  37
  38 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
  39   """
  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
  44   """
  45
  46   nature = 'PARAMETRE'
  47   idracine = 'param'
  48
  49   def __init__(self,nom,valeur=None):
  50     # parent ne peut être qu'un objet de type JDC
  51     self.dict_valeur=[]
  52     self.valeur = self.interprete_valeur(valeur)
  53     self.val=valeur
  54     self.nom = nom
  55     # La classe PARAMETRE n'a pas de définition : on utilise self pour
  56     # complétude
  57     self.definition=self
  58     self.jdc = self.parent = CONTEXT.get_current_step()
  59     self.niveau=self.parent.niveau
  60     self.actif=1
  61     self.state='undetermined'
  62     self.register()
  63
  64   def __getitem__(self,key):
  65     param_item=ITEM_PARAMETRE(self,key)
  66     return param_item
  67
  68   def __neg__(self):
  69     try:
  70       return -1*self.valeur
  71     except:
  72       print "******* Probleme : pas de valeur négative"
  73       return None
  74
  75   def __add__(self,a):
  76     try :
  77       return self.valeur+a.valeur
  78     except :
  79       print "******* Probleme : a l addition"
  80       return None
  81
  82   def __radd__(self,a):
  83     try :
  84       return self.valeur+a.valeur
  85     except :
  86       print "******* Probleme : a l addition"
  87       return None
  88
  89   def __sub__(self,a):
  90     try :
  91       return self.valeur  - a.valeur
  92     except :
  93       print "******* Probleme : a la soustraction"
  94       return None
  95
  96   def __rsub__(self,a):
  97     try :
  98       return a.valeur - self.valeur
  99     except :
 100       print "******* Probleme : a la soustraction"
 101       return None
 102
 103   def __mul__(self,a):
 104     try :
 105       return self.valeur*a.valeur
 106     except :
 107       print "******* Probleme : a la multiplication"
 108       return None
 109
 110   def __rmul__(self,a):
 111     try :
 112       return self.valeur*a.valeur
 113     except :
 114       print "******* Probleme : a la multiplication"
 115       return None
 116
 117   def __mul__(self,a):
 118     try :
 119       return self.valeur*a.valeur
 120     except :
 121       print "******* Probleme : a la multiplication"
 122       return None
 123
 124   def __rmul__(self,a):
 125     try :
 126       return self.valeur*a.valeur
 127     except :
 128       print "******* Probleme : a la multiplication"
 129       return None
 130
 131   def __add__(self,other):
 132     try :
 133       return self.valeur+other
 134     except :
 135       print "******* Probleme : a l addition"
 136       return None
 137
 138   def __radd__(self,other):
 139     try :
 140       return self.valeur+other
 141     except :
 142       print "******* Probleme : a l addition"
 143       return None
 144
 145   def __sub__(self,other):
 146     try :
 147       return self.valeur  - other
 148     except :
 149       print "******* Probleme : a la soustraction"
 150       return None
 151
 152   def __rsub__(self,other):
 153     try :
 154       return other - self.valeur
 155     except :
 156       print "******* Probleme : a la soustraction"
 157       return None
 158
 159   def  __mul__ (self,other):
 160     retour=None
 161     try :
 162       retour = eval(self.valeur) * other
 163     except :
 164       try :
 165          retour = self.valeur * other
 166       except :
 167          print "******* Probleme : a la multiplication"
 168     return retour
 169
 170   def __rmul__ (self,other):
 171     retour=None
 172     try :
 173       retour = eval(self.valeur) * other
 174     except :
 175       try :
 176          retour = self.valeur * other
 177       except :
 178          print "******* Probleme : a la multiplication"
 179     return retour
 180
 181
 182   def __div__(self,other):
 183     retour=None
 184     try:
 185       retour = eval(self.valeur) / other
 186     except :
 187       try :
 188         retour = self.valeur / other
 189       except :
 190         print "******* Probleme : a la division"
 191     return retour
 192
 193
 194   def interprete_valeur(self,val):
 195     """
 196     Essaie d'interpréter val (chaîne de caractères)comme :
 197     - un entier
 198     - un réel
 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
 202     """
 203     if not val : return None
 204     valeur = None
 205     #  on vérifie si val est un entier
 206     try :
 207         valeur = string.atoi(val)       # on a un entier
 208         return valeur
 209     except :
 210         pass
 211     #  on vérifie si val est un réel
 212     try:
 213         valeur = string.atof(val)   # on a un réel
 214         return valeur
 215     except :
 216         pass
 217     # on vérifie si val est un tuple
 218     try :
 219         valeur = eval(val)
 220     except:
 221         pass
 222     #PN je n ose pas modifier je rajoute
 223     if valeur != None :
 224         if type(valeur) == types.TupleType:
 225             l_new_val = []
 226             typ = None
 227             for v in valeur :
 228                 if not typ:
 229                     typ = type(v)
 230                 else:
 231                     if type(v) != typ :
 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
 236                         return val
 237                 l_new_val.append(v)
 238             return tuple(l_new_val)
 239         # PN : commente le print
 240         #else:
 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
 245     if valeur != None :
 246        if type(valeur).__name__ == 'list':
 247           self.dict_valeur=[]
 248           for i in range(len(valeur)):
 249               self.dict_valeur.append(valeur[i])
 250     return val
 251
 252   def get_valeurs(self):
 253     valeurretour=[]
 254     if self.dict_valeur != []:
 255        for val in self.dict_valeur:
 256            valeurretour.append(val)
 257     else:
 258         valeurretour.append(self.valeur)
 259     return valeurretour
 260
 261   def set_valeur(self,new_valeur):
 262     """
 263     Remplace la valeur de self par new_valeur interprétée
 264     """
 265     self.valeur = self.interprete_valeur(new_valeur)
 266     self.init_modif()
 267
 268   def init_modif(self):
 269     """
 270     Méthode qui déclare l'objet courant comme modifié et propage
 271     cet état modifié à ses ascendants
 272     """
 273     self.state = 'modified'
 274     if self.parent:
 275       self.parent.init_modif()
 276
 277   def get_jdc_root(self):
 278     if self.parent:
 279       return self.parent.get_jdc_root()
 280     else:
 281       return self
 282
 283   def register(self):
 284     """
 285     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
 286     """
 287     self.parent.register_parametre(self)
 288     self.parent.register(self)
 289
 290   def isvalid(self,cr='non'):
 291     """
 292     Retourne 1 si self est valide, 0 sinon
 293     Un paramètre est considéré comme valide si :
 294       - il a un nom
 295       - il a une valeur
 296     """
 297     if self.nom == '' :
 298         if cr == 'oui':
 299            self.cr.fatal("Pas de nom donné au paramètre ")
 300         return 0
 301     else:
 302         if self.valeur == None :
 303             if cr == 'oui' :
 304                self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
 305             return 0
 306     return 1
 307
 308   def isoblig(self):
 309     """
 310     Indique si self est obligatoire ou non : retourne toujours 0
 311     """
 312     return 0
 313
 314   def isrepetable(self):
 315     """
 316     Indique si self est répétable ou non : retourne toujours 1
 317     """
 318     return 1
 319
 320   def liste_mc_presents(self):
 321     return []
 322
 323   def supprime(self):
 324     """
 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
 327     """
 328     self.parent = None
 329     self.jdc = None
 330     self.definition=None
 331
 332   def active(self):
 333     """
 334     Rend l'etape courante active.
 335     Il faut ajouter le paramètre au contexte global du JDC
 336     """
 337     self.actif = 1
 338     try:
 339         self.jdc.append_param(self)
 340     except:
 341         pass
 342
 343   def inactive(self):
 344     """
 345     Rend l'etape courante inactive
 346     Il faut supprimer le paramètre du contexte global du JDC
 347     """
 348     self.actif = 0
 349     self.jdc.del_param(self)
 350     self.jdc.delete_concept_after_etape(self,self)
 351
 352   def isactif(self):
 353     """
 354     Booléenne qui retourne 1 si self est actif, 0 sinon
 355     """
 356     return self.actif
 357
 358   def set_attribut(self,nom_attr,new_valeur):
 359     """
 360     Remplace la valeur de self.nom_attr par new_valeur)
 361     """
 362     if hasattr(self,nom_attr):
 363       setattr(self,nom_attr,new_valeur)
 364       self.init_modif()
 365
 366   def supprime_sdprods(self):
 367     """
 368     Il faut supprimer le paramètre qui a été entré dans la liste des
 369     paramètres du JDC
 370     """
 371     self.jdc.delete_param(self)
 372
 373   def update_context(self,d):
 374     """
 375     Update le dictionnaire d avec le paramètre que produit self
 376     """
 377     d[self.nom]=self
 378
 379   def __repr__(self):
 380     """
 381         Donne un echo de self sous la forme nom = valeur
 382     """
 383     return self.nom+' = '+str(self.valeur)
 384
 385   def __str__(self):
 386     """
 387         Retourne le nom du paramètre comme représentation de self
 388     """
 389     return self.nom
 390
 391   def get_sdprods(self,nom_sd):
 392      """
 393          Retourne les concepts produits par la commande
 394      """
 395      return None
 396
 397   def report(self):
 398     """ Génère l'objet rapport (classe CR) """
 399     self.cr=CR()
 400     self.isvalid(cr='oui')
 401     return self.cr
 402
 403   def ident(self):
 404     """
 405     Retourne le nom interne associé à self
 406     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 407     """
 408     return self.nom
 409
 410   def delete_concept(self,sd):
 411     pass
 412
 413   def replace_concept(self,old_sd,sd):
 414     pass
 415
 416   def verif_condition_bloc(self):
 417     """
 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
 423     """
 424     return [],[]
 425
 426   def verif_condition_regles(self,liste_presents):
 427     """
 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
 430     """
 431     return []
 432
 433   def verif_existence_sd(self):
 434      pass
 435
 436   def control_sdprods(self,d):
 437       """sans objet """
 438       pass
 439
 440   def close(self):
 441       pass
 442
 443
 444
 445 class ITEM_PARAMETRE :
 446   def __init__(self,param_pere,item=None):
 447       self.param_pere = param_pere
 448       self.item = item
 449
 450
 451   def __repr__(self):
 452     return self.param_pere.nom+'['+str(self.item)+']'
 453
 454
 455   def isvalid(self):
 456       isvalid = 1
 457       if self.item < 0:
 458          isvalid =  0
 459       try:
 460          longueur= len(self.param_pere.dict_valeur) - 1
 461       except:
 462          longueur=0
 463       if self.item > longueur :
 464          isvalid= 0
 465       return isvalid