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