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     self.dict_valeur=[]
  60     self.interprete_valeur(valeur)
  61
  62   def __getitem__(self,key):
  63     param_item=ITEM_PARAMETRE(self,key)
  64     return param_item
  65
  66   def interprete_valeur(self,val):
  67     """
  68     Essaie d'interpréter val (chaîne de caractères)comme :
  69     - un entier
  70     - un réel
  71     - une chaîne de caractères
  72     - une liste d'items d'un type qui précède
  73     Retourne la valeur interprétée
  74     """
  75     if not val : return None
  76     valeur = None
  77     #  on vérifie si val est un entier
  78     try :
  79         valeur = string.atoi(val)       # on a un entier
  80         return valeur
  81     except :
  82         pass
  83     #  on vérifie si val est un réel
  84     try:
  85         valeur = string.atof(val)   # on a un réel
  86         return valeur
  87     except :
  88         pass
  89     # on vérifie si val est un tuple
  90     try :
  91         valeur = eval(val)
  92     except:
  93         pass
  94     #PN je n ose pas modifier je rajoute
  95     if valeur != None :
  96         if type(valeur) == types.TupleType:
  97             l_new_val = []
  98             typ = None
  99             for v in valeur :
 100                 if not typ:
 101                     typ = type(v)
 102                 else:
 103                     if type(v) != typ :
 104                         # la liste est hétérogène --> on refuse d'interpréter
 105                         #  self comme une liste
 106                         # on retourne la string initiale
 107                         print 'liste hétérogène ',val
 108                         return val
 109                 l_new_val.append(v)
 110             return tuple(l_new_val)
 111         # PN : commente le print
 112         #else:
 113             # on a réussi à évaluer val en autre chose qu'un tuple ...
 114             #print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
 115             #print 'on trouve : ',str(valeur),' de type : ',type(valeur)
 116     # on retourne val comme une string car on n'a pas su l'interpréter
 117     if valeur != None :
 118        if type(valeur).__name__ == 'list':
 119           self.dict_valeur=[]
 120           for i in range(len(valeur)):
 121               self.dict_valeur.append(valeur[i])
 122     return val
 123
 124   def get_valeurs(self):
 125     valeurretour=[]
 126     if self.dict_valeur != []:
 127        for val in self.dict_valeur:
 128            valeurretour.append(val)
 129     else:
 130         valeurretour.append(self.valeur)
 131     return valeurretour
 132
 133   def set_valeur(self,new_valeur):
 134     """
 135     Remplace la valeur de self par new_valeur interprétée
 136     """
 137     self.valeur = self.interprete_valeur(new_valeur)
 138     self.init_modif()
 139
 140   def init_modif(self):
 141     """
 142     Méthode qui déclare l'objet courant comme modifié et propage
 143     cet état modifié à ses ascendants
 144     """
 145     self.state = 'modified'
 146     if self.parent:
 147       self.parent.init_modif()
 148
 149   def register(self):
 150     """
 151     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
 152     """
 153     self.parent.register_parametre(self)
 154     self.parent.register(self)
 155
 156   def isvalid(self,cr='non'):
 157     """
 158     Retourne 1 si self est valide, 0 sinon
 159     Un paramètre est considéré comme valide si :
 160       - il a un nom
 161       - il a une valeur
 162     """
 163     if self.nom == '' :
 164         if cr == 'oui':
 165            self.cr.fatal("Pas de nom donné au paramètre ")
 166         return 0
 167     else:
 168         if self.valeur == None :
 169             if cr == 'oui' :
 170                self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
 171             return 0
 172     return 1
 173
 174   def isoblig(self):
 175     """
 176     Indique si self est obligatoire ou non : retourne toujours 0
 177     """
 178     return 0
 179
 180   def isrepetable(self):
 181     """
 182     Indique si self est répétable ou non : retourne toujours 1
 183     """
 184     return 1
 185
 186   def liste_mc_presents(self):
 187     return []
 188
 189   def supprime(self):
 190     """
 191     Méthode qui supprime toutes les boucles de références afin que
 192     l'objet puisse être correctement détruit par le garbage collector
 193     """
 194     self.parent = None
 195     self.jdc = None
 196     self.definition=None
 197
 198   def active(self):
 199     """
 200     Rend l'etape courante active.
 201     Il faut ajouter le paramètre au contexte global du JDC
 202     """
 203     self.actif = 1
 204     try:
 205         self.jdc.append_param(self)
 206     except:
 207         pass
 208
 209   def inactive(self):
 210     """
 211     Rend l'etape courante inactive
 212     Il faut supprimer le paramètre du contexte global du JDC
 213     """
 214     self.actif = 0
 215     self.jdc.del_param(self)
 216     self.jdc.delete_concept_after_etape(self,self)
 217
 218   def isactif(self):
 219     """
 220     Booléenne qui retourne 1 si self est actif, 0 sinon
 221     """
 222     return self.actif
 223
 224   def set_attribut(self,nom_attr,new_valeur):
 225     """
 226     Remplace la valeur de self.nom_attr par new_valeur)
 227     """
 228     if hasattr(self,nom_attr):
 229       setattr(self,nom_attr,new_valeur)
 230       self.init_modif()
 231
 232   def supprime_sdprods(self):
 233     """
 234     Il faut supprimer le paramètre qui a été entré dans la liste des
 235     paramètres du JDC
 236     """
 237     self.jdc.delete_param(self)
 238
 239   def update_context(self,d):
 240     """
 241     Update le dictionnaire d avec le paramètre que produit self
 242     """
 243     d[self.nom]=self
 244
 245   def __repr__(self):
 246     """
 247         Donne un echo de self sous la forme nom = valeur
 248     """
 249     return self.nom+' = '+str(self.valeur)
 250
 251   def __str__(self):
 252     """
 253         Retourne le nom du paramètre comme représentation de self
 254     """
 255     return self.nom
 256
 257   def get_sdprods(self,nom_sd):
 258      """
 259          Retourne les concepts produits par la commande
 260      """
 261      return None
 262
 263   def report(self):
 264     """ Génère l'objet rapport (classe CR) """
 265     self.cr=CR()
 266     self.isvalid(cr='oui')
 267     return self.cr
 268
 269   def ident(self):
 270     """
 271     Retourne le nom interne associé à self
 272     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 273     """
 274     return self.nom
 275
 276   def delete_concept(self,sd):
 277     pass
 278
 279   def replace_concept(self,old_sd,sd):
 280     pass
 281
 282   def verif_condition_bloc(self):
 283     """
 284         Evalue les conditions de tous les blocs fils possibles
 285         (en fonction du catalogue donc de la définition) de self et
 286         retourne deux listes :
 287           - la première contient les noms des blocs à rajouter
 288           - la seconde contient les noms des blocs à supprimer
 289     """
 290     return [],[]
 291
 292   def verif_condition_regles(self,liste_presents):
 293     """
 294         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 295         en fonction de la liste des mots-clés présents
 296     """
 297     return []
 298
 299   def verif_existence_sd(self):
 300      pass
 301
 302   def control_sdprods(self,d):
 303       """sans objet """
 304       pass
 305
 306
 307
 308 class ITEM_PARAMETRE :
 309   def __init__(self,param_pere,item=None):
 310       self.param_pere = param_pere
 311       self.item = item
 312
 313
 314   def __repr__(self):
 315     return self.param_pere.nom+'['+str(self.item)+']'
 316
 317
 318   def isvalid(self):
 319       isvalid = 1
 320       if self.item < 0:
 321          isvalid =  0
 322       try:
 323          longueur= len(self.param_pere.dict_valeur) - 1
 324       except:
 325          longueur=0
 326       if self.item > longueur :
 327          isvalid= 0
 328       return isvalid