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